Reading width
Wide uses the full column for everything, text, diagrams, code, and exercises. Narrow keeps the standard reading width.
Text size
Scales the body text. Headings and code blocks keep their size.
In this section
Endpoint Security Architecture: Coverage, Measures and Sequence Across Defender for Endpoint
Introduction
Each lesson so far read one control family on its own. This one puts them together. An estate is not secure because each control has a setting; it is secure when every device has the controls its role needs, each one in the mode that does something, with the evidence to show it. That is an architecture, and it is judged a device at a time.
The lesson builds one row per device from the records, takes the measures that can honestly be taken from those rows, finds the devices the rows cannot include, and sets out an order for the work. It is the shape of Module 9's capstone, done once on this estate in miniature.
The four layers every device is judged on, in the order each depends on the last.
The figure is the order every device is judged in. Prevention depends on coverage, because a control on a device without a working sensor cannot be verified, however it is configured. Detection depends on prevention, because it is meant for what prevention missed. Response depends on detection, because it acts on alerts. A gap low in the stack undermines everything above it.
One Row per Device
Every control family on one lineThe inventory's latest record for each device, joined to its process records, its last scan and its ASR blocks:
let inv = DeviceInfo
| summarize arg_max(Timestamp, OSPlatform, OnboardingStatus) by DeviceName;
let proc = DeviceProcessEvents | summarize Proc = count() by DeviceName;
let scan = DeviceEvents | where ActionType == 'AntivirusScanCompleted'
| summarize LastScan = max(Timestamp) by DeviceName;
let asr = DeviceEvents
| where ActionType startswith 'Asr' and ActionType endswith 'Blocked'
| summarize AsrBlock = count() by DeviceName;
inv
| join kind=leftouter proc on DeviceName
| join kind=leftouter scan on DeviceName
| join kind=leftouter asr on DeviceName
| project DeviceName, OSPlatform,
Onboarded = iff(OnboardingStatus == 'Onboarded', 'yes', 'no'),
Proc = coalesce(Proc, 0),
ScanAge = datetime_diff('day', datetime(2026-03-15 12:00), LastScan),
AsrBlock = coalesce(AsrBlock, 0)
| order by DeviceName asc
One row for each of the 21 devices the inventory knows:
DeviceName OSPlatform Onboarded Proc ScanAge AsrBlock
----------------- ----------------- --------- ---- ------- --------
NE-ASHWORTH-LT Windows11 yes 648 2 0
NE-BENNETT-LT Windows11 yes 608 0 0
NE-COLLINS-LT Windows11 yes 653 2 0
NE-DAVIS-LT Windows11 yes 620 0 3
NE-FOSTER-LT Windows11 yes 624 2 5
NE-HARGREAVES-LT Windows11 yes 0 0 0
NE-KHAN-LT Windows11 yes 615 2 4
NE-LEWIS-LT Windows11 yes 615 1 0
NE-MITCHELL-LT Windows11 yes 646 2 0
NE-MORRIS-LT Windows11 yes 666 2 0
NE-PATEL-LT Windows11 yes 671 2 0
NE-RICHARDSON-LT Windows11 yes 647 2 0
NE-SHARMA-LT Windows11 yes 611 2 0
NE-SQL02 WindowsServer2019 no 0 0
NE-SRV-SIEM-01 WindowsServer2022 yes 0 0 0
NE-THOMPSON-LT Windows11 yes 663 0 0
NE-WEBB-MBP macOS yes 0 6 0
NE-WILLIAMS-LT Windows11 yes 629 2 0
NE-ZHANG-LT Windows11 yes 657 1 1
SRV-NGE-MCR-AAD01 WindowsServer2022 yes 1 0 0
WEB-NGE-MCR-01 Linux yes 0 0 0
Read down the columns. Onboarded is yes on every row but NE-SQL02, the server lesson 0.2 found could be onboarded and never was.
Proc separates the devices that describe themselves from those that do not: the laptops send hundreds of process records each, and the Linux server, the Mac, the SIEM server and the Hargreaves laptop send none. ScanAge shows the Mac six days behind everything else. AsrBlock is non-zero only on the four pilot laptops from lesson 0.4.
Then read across the rows that matter most. SRV-NGE-MCR-AAD01 is onboarded, scanning and has one process record, which lesson 0.8 showed was the theft of the sync credentials. WEB-NGE-MCR-01 is onboarded, scanning and sends no processes, on the server that faces the internet and was used to send data out.
Those two rows carry the estate's worst incidents and the least evidence. NE-SRV-SIEM-01 belongs beside them: a server that sends logon records and scans but no processes, on the system the security team itself depends on.
The row also shows what it leaves out. Network protection, device control and SmartScreen produce records only when someone visits a site or plugs in a drive, so their absence on a row is not evidence of anything.
A row built from records can show where a control acted; for a control that has no occasion to act, only its configuration can say it is there. Module 9 combines both sources, and this lesson says plainly which columns come from which.
The row is also cheap to keep. It is one query, it runs in seconds, and it changes as the estate changes: a device that stops sending process records drops to zero in the Proc column the next time it runs, and a pilot that widens shows in AsrBlock.
An architecture that is checked by a query every week is one whose drift is seen in a week rather than in an incident.
The point of the row is that it puts every finding from this module in one place, so that a device's whole position can be seen at once rather than reconstructed from eight lessons.
Measures That Can Be Taken
Counting from the rowsFrom the same joins, the counts an estate report could honestly use:
let inv = DeviceInfo
| summarize arg_max(Timestamp, OSPlatform, OnboardingStatus) by DeviceName;
let proc = DeviceProcessEvents | summarize Proc = count() by DeviceName;
let scan = DeviceEvents | where ActionType == 'AntivirusScanCompleted'
| summarize LastScan = max(Timestamp) by DeviceName;
let asr = DeviceEvents
| where ActionType startswith 'Asr' and ActionType endswith 'Blocked'
| summarize AsrBlock = count() by DeviceName;
inv
| join kind=leftouter proc on DeviceName
| join kind=leftouter scan on DeviceName
| join kind=leftouter asr on DeviceName
| summarize Devices = count(),
Onboarded = countif(OnboardingStatus == 'Onboarded'),
SendProcesses = countif(coalesce(Proc, 0) > 10),
ScannedLast2Days = countif(LastScan >= datetime(2026-03-13 12:00)),
AsrBlocking = countif(coalesce(AsrBlock, 0) > 0)
The five estate counts, from the widest to the narrowest, in one row:
Devices Onboarded SendProcesses ScannedLast2Days AsrBlocking
------- --------- ------------- ---------------- -----------
21 20 15 14 4
20 of 21 devices are onboarded. 15 send more than ten process records in the period. 14 completed a scan in the last two days. 4 show an ASR block. Those numbers fall from the first to the last, and each fall is a finding: onboarded is not the same as observed, observed is not the same as protected.
The gap between the first two is the one to report first. 6 of the 21 devices either are not onboarded or do not describe what runs on them, and each of those is a device where every later control is unverifiable. A report that leads with the onboarding count hides that gap inside its largest number.
Two more measures come from the other lessons and belong in the same report. Of 3 antivirus detections, 1 was remediated. Of 20 High-severity incidents in the incident records, 1 was ever assigned to anyone. Neither number appears on a console's summary page, and both say more about whether the estate is protected than the onboarding count does.
The rule for choosing measures is the one this module has applied throughout: a measure counts something the records can prove. Devices onboarded counts agents installed. Devices sending process records counts agents that can see. Detections remediated counts threats stopped.
The further down that list a measure sits, the closer it is to the question an estate report is meant to answer. Each also has an owner who can move it: onboarding is an operations task, telemetry a configuration task, remediation a policy decision, and incident ownership a staffing one. Reporting them together shows where each part of the gap sits.
There is a trap in the opposite direction too. A measure that is low is not automatically a failure; ASR blocks are low because the pilot was four laptops. The measure has to be read against what the configuration intended, which is why the architecture document Module 9 ends with records the intention beside the evidence.
Devices the Rows Cannot Include
Names in the records that the inventory does not knowEvery row above came from the inventory. A device the inventory does not know has no row, however much it matters. The test is the device names that appear in device records but have no inventory entry:
union
(DeviceProcessEvents | summarize Records = count() by DeviceName),
(DeviceNetworkEvents | summarize Records = count() by DeviceName),
(DeviceLogonEvents | summarize Records = count() by DeviceName),
(DeviceEvents | summarize Records = count() by DeviceName)
| summarize Records = sum(Records) by DeviceName
| join kind=leftanti (DeviceInfo | distinct DeviceName) on DeviceName
| order by DeviceName asc
The device names the records mention and the inventory does not:
DeviceName Records
----------------- -------
NE-FOSTER-WS 6
SRV-NGE-MCR-APP01 9
SRV-NGE-MCR-APP02 12
SRV-NGE-MCR-DB01 11
SRV-NGE-MCR-MON01 8
WEB-NGE-MCR-02 2
6 names. NE-FOSTER-WS is the second hop of the lateral movement chain lesson 0.7 met. SRV-NGE-MCR-DB01 is the server that chain's alert was about. The application and monitoring servers, and a second web server beside the one this module has followed, all appear in records and nowhere in the inventory.
None of these can be scored. They have no platform, no onboarding status and no sensor health in the inventory, so every measure in the previous section silently excludes them. An estate report that says 20 of 21 devices are onboarded is reporting on the devices the inventory knows, and the true denominator is larger by at least these 6.
The records cannot say why each name is missing; a renamed device, a server outside the tenant's scope and an unmanaged host all look the same from here. Each one needs an owner to answer for it, and the answer decides what happens next: onboard it, record it as out of scope, or retire the name.
What matters for the architecture is that the list exists, is checked every week, and is empty or explained. Module 9's assessment phase starts with exactly this reconciliation, because every later phase scores devices against the inventory, and an inventory that is short makes every later score look better than it is.
The two web servers make the risk concrete. WEB-NGE-MCR-01 is in the inventory and was compromised; WEB-NGE-MCR-02 appears in records and is not. If the second server runs the same application, it has the same exposure and none of the evidence, and no measure on this estate would show it.
This is lesson 0.2's coverage question asked from the other side. That lesson asked which inventoried devices were not covered. This one asks which devices are not in the inventory at all.
A Sequence for the Work
What to close first, and whyAn estate with this many gaps cannot close them at once, and the order matters more than the speed. The rule this module points to is blast radius: start where a compromise reaches furthest, and where the work makes the most other work possible.
A sequence for this estate
Blast radius firstThe two servers come first. The Tier 0 sync server holds credentials that reach the whole directory, and the Linux server faces the internet. Both need telemetry that works before anything else on them can be verified, and both are single devices, so the work is small and the reduction in risk is large.
Application control on the sync server and an indicator list fed from alerts are the first controls to add.
Response comes second, because it is mostly configuration and multiplies everything else. An automation level that remediates without approval would have acted on the ransomware binary, isolation for workstations would have stopped the laptop moving laterally, and indicators from alerts would have cut the web server's connections. None of that needs a new product, and lesson 0.7 showed each of them missing.
Prevention in block comes third: antivirus remediation actions set to remove or quarantine, ASR rules extended from the four-laptop pilot by the audit-first method of lesson 0.4, and application control on the laptops. These take longer because each change can break something the business uses, and the audit phase is the price of doing them safely.
The long tail comes last: device control beyond one laptop, the Mac's approvals and the hosts the inventory does not know. They matter, but each is narrower than the work before it, and some of the inventory gaps will close by themselves as the reconciliation in the previous section assigns owners.
Every step in the sequence ends the same way: the row query runs again and the column the step was meant to change has changed. A step that is finished in the console and unchanged in the records is not finished. That is how this module has judged every control, and it is how the sequence judges itself.
The sequence is also a recommendation for this estate, not a template. An estate with a working response team and no internet-facing servers would order the same work differently. What carries over is the rule, blast radius first and evidence before and after, rather than the list.
What the Records Cannot Settle
Where the architecture needs configuration as well as evidenceA records-only view of an estate has limits, and the architecture has to name them. This module has met several. A control with no occasion to act leaves no record; network protection on a laptop nobody used for a phishing link looks the same as no network protection.
A policy's verdict field can be absent, as device control's was. A device can stop sending a kind of record without any record saying so.
So every finding in this module came in one of three kinds, and the card below sorts the main ones.
Three kinds of finding in this module
Say which kindEach kind supports a different strength of statement. A proved finding can be reported as fact. A tested absence can be reported as fact about the records, with the query that tested it. A bounded finding can only be reported as a question, with the configuration that would answer it. Some were proved by records: the ransomware ran for ten minutes, the address was reached for two days.
Some were proved by records' absence after the query was shown able to find them: no application control or exploit protection events, no process records from the Linux server. And some could only be bounded: what the Mac's agent is permitted to do, which automation level the device groups use, whether device control is configured on more than one laptop.
The third kind needs configuration evidence: exported policies, device group settings, the agent's own health report. Module 9 gathers both kinds for each phase and puts them side by side in the architecture document, so that a reader can see which statements rest on what the devices did and which rest on what they were told to do.
That distinction is what makes an architecture document trustworthy. A document that reports configuration alone describes intentions. One that reports records alone misses every control that never had to act. One that reports both, and says which is which, can be checked by anyone with access to the same tables, and is the standard Module 9 holds its own output to.
The bounded findings are also where an engineer's next questions come from. Each one names a piece of configuration to export and read, and the reading usually turns a bounded finding into a proved one in either direction.
What Module 9 Builds On It
The capstoneModule 9 is the capstone, and it is this lesson at full scale. It opens with a briefing and an assessment phase, then works through eight phases that match the course's modules: onboarding and device health, compliance and conditional access, attack surface reduction, antivirus, device and application control, EDR response, servers and Linux, and vulnerability management. It closes with validation, governance and the architecture document.
What Module 9 builds
Module 9Each phase follows the pattern of this lesson: build the row from records, add the configuration evidence, take the measures that can honestly be taken, and decide the order of the fixes. The difference is depth. Where this lesson used one query per control family, each phase in Module 9 uses the full method of its module.
The capstone also changes who the work is for. In the earlier modules the reader is the engineer doing the configuration.
In Module 9 the reader is also whoever has to approve the work and fund it, which is why the measures matter so much: the case for the first month of work on this estate is made by the fall from onboarded to observed, the one remediated detection in three, and the incidents nobody took. Those are numbers a manager can read, and they come from records anyone can check.
The architecture document at the end of Module 9 is the deliverable that carries those numbers. It records, for every control family, the intended configuration, the evidence that it works, the gaps, and the order they will be closed in, with the queries that produced each figure so the next review can run them again.
The habits to carry into it are the ones this lesson used. Judge every device on one row. Choose measures by how close they come to whether the estate is protected. Reconcile the inventory against the records every week.
Order the work by blast radius, and confirm each step by running the row again. And say, for every finding, whether it rests on records, on a proved absence or on configuration.
Practice
Decide where the work starts prepared evidenceThe prepared evidence below is the one-row-per-device table from this lesson. Decide which two devices the first month of work should start on, which onboarded devices send no process records, and which measure would most mislead a report on this estate. Each answer comes with its reasoning, so check it against the rows rather than only the choice.
Read each row as a whole before deciding. A device with every column healthy is not the priority, however many of them there are; a device with one bad column and a high blast radius is.
Bring the earlier lessons' findings with you, because the table shows positions and the lessons showed what happened. The Tier 0 server's single process record looks harmless in a column of counts; it is the theft of the sync credentials.
Remember too which devices are missing from the table entirely. The six names the inventory does not know cannot be ranked here, and a plan that starts only from this table has already left them out. Put them in the plan as a line of their own, with the reconciliation as its first task, so that the gap stays visible until it is closed.
Then extend the row query on this page with two more columns: the count of network records and the count of logon records per device. Note which devices change position when those are added: the SIEM server's logons and the Linux server's connections appear, and the Mac stays empty in every column but one.
A device that is empty in every telemetry column is not a device the estate can defend, whatever its onboarding status says, and the extended row makes that impossible to miss in a weekly review. Finally, run the uninventoried-names query against DeviceFileEvents and DeviceRegistryEvents as well, and see whether the list grows. Any new name belongs in the reconciliation with the others.
An estate is one architecture judged a device at a time, through coverage, prevention, detection and response, in that order. On this estate the measures fall from 20 devices onboarded to 4 with an ASR block, one detection in three was remediated, and 1 of 20 High-severity incidents was ever assigned.
The work starts on the two servers with the widest reach and the least evidence, and every step ends with the row query run again.
The last lesson of the module puts one intrusion through every control on the estate, step by step, and asks at each step which control stopped it, which saw it and which was missing.