Agent Foskett Academy • Microsoft Sentinel • Module 5 • Lesson 50

Lesson 50 — Building an SOC Operations Dashboard

Fifty lessons into the Academy, it is time to bring everything together.

Build an evidence-first SOC operations dashboard that highlights open incidents, ownership, trends, ageing cases and data health.

Module 5 — Workbooks and Dashboards • SOC operational visibility
Agent Foskett Microsoft Sentinel SOC operations dashboard
What you will learn

Turn workbook panels into a usable shift dashboard.

✓ Incident KPI cards
✓ Triage and ownership
✓ Backlog and trends
✓ Data freshness

Lesson 50 — A milestone worth investigating

Fifty lessons into the Microsoft Sentinel Academy, Agent Foskett has built detections, investigated incidents and created interactive workbooks. Now we bring those skills together into one SOC operations dashboard that helps an analyst decide what to do next.

What you will build

  • An operational incident overview for the selected period.
  • A current open-incident triage queue.
  • An incident creation trend and severity breakdown.
  • An ownership and workload view.
  • A sign-in activity panel for supporting context.
  • A data-health panel that exposes stale or missing telemetry.
  • Clear links from summary to underlying incident evidence.

The operating question

SOC SHIFT STARTS ↓ WHAT IS OPEN? → WHAT IS URGENT? ↓ ↓ WHO OWNS IT? → WHAT CHANGED? ↓ ↓ CAN WE TRUST THE DATA? ↓ OPEN THE INCIDENT AND INVESTIGATE

Dashboard versus investigation

A dashboard helps prioritise and navigate. It is not a substitute for the Microsoft Sentinel incident record, investigation graph, alerts, entities or evidence notes. Every summary should offer a clear route to the source investigation.

Prepare your workspace

  1. Open the workbook created in Lessons 47–49 and save a new copy called SOC Operations Dashboard — Lab.
  2. Confirm access to the Log Analytics workspace and its Microsoft Sentinel data.
  3. Verify the SecurityIncident table is present and has records.
  4. Keep your tested time-range control from Lesson 48.
  5. Choose a lab period that contains incidents; do not use production data in public screenshots.

The queries below target SecurityIncident in a Log Analytics workspace. In this table, updates to an incident can produce multiple records. A current-state dashboard must account for that.

Dashboard layout

SOC OPERATIONS — [TIME RANGE] [Open] [High Severity Open] [Unassigned Open] [Incident Creation Trend] [Open by Severity] [Current Triage Queue — click to investigate] [Ownership and Workload] [Identity Signal] [Data Freshness] [Definitions • Permissions • Last Refresh]

Important: incident rows are versioned

A naive count() over SecurityIncident can count updates as separate incidents. For current-state views, select the most recent row per incident using arg_max(TimeGenerated, *) by IncidentNumber in the intended workspace. For historical incident-creation trends, use the incident’s creation timestamp from its latest known row and make the reporting scope explicit.

The examples assume one Sentinel workspace. When querying across workspaces, incident identifiers and aggregation keys need additional care.

Step 1 — Inspect the incident schema

Check the incident data source
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
SecurityIncident
| where TimeGenerated > ago(30d)
| project TimeGenerated, IncidentNumber,
          Title, Severity, Status,
          CreatedTime, Owner
| take 20

Confirm the table and fields exist in your workspace before building the visuals. If this returns no rows, inspect your workspace selection, permissions and incident history.

Step 2 — Build a current-state base

Latest available row per incident
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
SecurityIncident
| summarize arg_max(TimeGenerated, *)
    by IncidentNumber
| project IncidentNumber, Title, Severity,
          Status, CreatedTime, TimeGenerated

Notice that the current-state query does not filter TimeGenerated to the last 24 hours before selecting the latest row. Doing so could silently omit still-open incidents whose last update happened earlier.

Step 3 — Create operational KPI cards

Open, high-severity and unassigned KPIs
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
SecurityIncident
| summarize arg_max(TimeGenerated, *)
    by IncidentNumber
| where Status != "Closed"
| extend OwnerName = tostring(Owner.assignedTo)
| summarize OpenIncidents = count(),
            HighSeverityOpen =
                countif(Severity == "High"),
            UnassignedOpen =
                countif(isempty(OwnerName))

Add a query component and use a suitable tile, grid or number-style presentation. Clearly label the measures as current known state, not “incidents created in the last 24 hours”.

Owner field structure and naming can differ by ingestion version. Check the observed Owner value and adapt the extraction if required.

Step 4 — Build the open-incident queue

Actionable triage table
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
SecurityIncident
| summarize arg_max(TimeGenerated, *)
    by IncidentNumber
| where Status != "Closed"
| extend OwnerName = tostring(Owner.assignedTo)
| project IncidentNumber, Title, Severity,
          Status, OwnerName, CreatedTime
| order by CreatedTime asc
| take 100

Display the table below the KPI cards. Configure sorting and incident-opening links in the workbook editor where supported. The queue is capped for responsiveness; clearly disclose that limit and keep the source incident list accessible.

Step 5 — Explain severity and priority

Severity alone does not define operational priority. Analysts should also consider the incident age, evidence quality, affected entities, business context, active containment needs and available ownership. A high-severity incident may already be assigned and progressing; an older medium-severity incident may need urgent review.

Step 6 — Show the creation trend

Incidents created each day
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
SecurityIncident
| summarize arg_max(TimeGenerated, *)
    by IncidentNumber
| where CreatedTime >= ago(14d)
| summarize IncidentsCreated = count()
    by bin(CreatedTime, 1d)
| order by CreatedTime asc

Use a time chart titled Incidents created per day — last 14 days. This is a fixed-window teaching example; when publishing, bind the intended time range and validate that the chart reflects the same selection.

Step 7 — Open incidents by severity

Current backlog composition
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
SecurityIncident
| summarize arg_max(TimeGenerated, *)
    by IncidentNumber
| where Status != "Closed"
| summarize OpenIncidents = count()
    by Severity
| order by OpenIncidents desc

Use a bar chart for a clear comparison. Keep the zero baseline and label the measure as open incidents, not “security attacks”.

Step 8 — Ownership and workload

Open incidents by assigned owner
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
SecurityIncident
| summarize arg_max(TimeGenerated, *)
    by IncidentNumber
| where Status != "Closed"
| extend OwnerName = tostring(Owner.assignedTo)
| extend OwnerName =
    iff(isempty(OwnerName), "Unassigned", OwnerName)
| summarize OpenIncidents = count()
    by OwnerName
| order by OpenIncidents desc

A workload view helps a shift lead spot unassigned work and uneven distribution. It is not a productivity ranking: complexity and case age differ.

Step 9 — Find older open incidents

Backlog age in days
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
SecurityIncident
| summarize arg_max(TimeGenerated, *)
    by IncidentNumber
| where Status != "Closed"
| extend AgeDays =
    datetime_diff("day", now(), CreatedTime)
| project IncidentNumber, Title, Severity,
          Status, AgeDays, CreatedTime
| order by AgeDays desc
| take 50

This helps identify work that may need review. The age calculation measures calendar-day difference from creation, not time since assignment or time actively worked.

Step 10 — Add supporting identity context

Recent failed sign-in trend
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
SigninLogs
| where TimeGenerated > ago(24h)
| where ResultType != "0"
| summarize FailedSignIns = count()
    by bin(TimeGenerated, 1h)
| order by TimeGenerated asc

Place this in a clearly separated Identity signal section. It provides context but is not automatically linked to any particular incident. Do not infer causation from nearby spikes.

Step 11 — Data freshness is operational evidence

Latest available event by source
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
union isfuzzy=true
    (SecurityIncident
     | summarize Latest = max(TimeGenerated)
     | extend Source = "SecurityIncident"),
    (SigninLogs
     | summarize Latest = max(TimeGenerated)
     | extend Source = "SigninLogs")
| project Source, Latest,
          MinutesSinceLatest =
              datetime_diff("minute", now(), Latest)

A missing table may produce a warning or partial result depending on the environment. Verify both sources separately when troubleshooting. A freshness value is descriptive; set any alert thresholds according to your connector and ingestion expectations.

Step 12 — Distinguish current state from selected period

PanelScopeImportant distinction
Open incident KPIsLatest known incident stateNot limited to newly updated incidents
Open triage queueLatest known incident stateMay include old open incidents
Creation trendIncidents created in chosen windowNot all current incidents
Identity trendSign-in events in chosen windowSeparate data source
Data freshnessLatest ingested record per sourceNot a guarantee of completeness

Step 13 — Keep time controls honest

One workbook-level time parameter does not mean every metric should obey it identically. Apply it to event and creation trends. For current-state backlog panels, explicitly show that the query uses the latest known incident record, including incidents older than the selected trend period. Label this distinction in the interface.

Step 14 — Add incident navigation

  1. In the triage table, select the incident identifier or title column.
  2. If supported, configure a link action that opens the incident in the appropriate Microsoft Sentinel experience.
  3. Check that the target incident opens for the signed-in analyst.
  4. Test with a non-administrator role.
  5. If your workbook editor does not support a safe dynamic incident link, provide a clear link to the Sentinel incident list instead.

Portal navigation and workbook link-action options can vary; avoid hard-coding unverified incident URLs.

Step 15 — Design for the shift handover

  • Put unassigned and older open incidents near the top.
  • Make data freshness visible, not hidden in a footer.
  • Include a last-reviewed note and a dashboard owner.
  • Keep the underlying incident queue one click away.
  • Avoid exposing unnecessary personal data on a wall display.
  • Use accessible labels and avoid colour-only priority cues.

Step 16 — Validate dashboard totals

ValidationExpected result
Open KPI vs queueCounts align after accounting for row cap
Severity bars vs open KPICategory totals reconcile
Creation trend vs incident listCreation dates agree for same window
Ownership viewUnassigned cases visible
Refresh checkLatest data timestamp is plausible
Permissions checkAnalyst can access source records

Step 17 — Performance and reliability

Incident snapshots and broad time windows can be expensive. Test realistic data volumes, avoid unnecessarily repeating large queries, cap detail views and consider query optimisation. Where workbook controls offer refresh settings, select a cadence that matches operational need and workspace cost.

Step 18 — Common dashboard mistakes

MistakeWhy it mattersFix
Count every SecurityIncident rowUpdates inflate incident countsUse latest row per incident
Filter snapshots to last 24hOld open incidents disappearSeparate current state and trends
No freshness indicatorStale data looks reassuringShow source freshness
No evidence drill-downAnalyst cannot validateLink to incident records
Overload with chartsUrgent work gets buriedPrioritise action-oriented panels
Call failed sign-ins attacksOverstates the evidenceUse precise labels

Agent Foskett scenario — The quiet dashboard

At 08:00, the SOC dashboard shows only two new incidents. The shift lead calls it a quiet morning. Agent Foskett opens the backlog panel: nine incidents remain open, three are unassigned and one is several days old. The new-incident trend was correct — but it was never a measure of total outstanding work.

Lesson: a dashboard must separate what arrived from what still needs attention.

Hands-on build exercise

  1. Create a fresh workbook copy for the SOC Operations Dashboard.
  2. Add three current-state KPI measures.
  3. Build an open-incident triage table.
  4. Add incident creation and severity charts.
  5. Add an owner workload panel and backlog-age view.
  6. Add the sign-in signal and data freshness panels.
  7. Check that current-state views include older open incidents.
  8. Validate totals and write a short shift-handover summary.

Publishing checklist

  • The workbook clearly identifies its workspace and scope.
  • Current-state and time-window metrics are distinguished.
  • Counts do not double-count incident updates.
  • Critical triage work is visible without scrolling excessively.
  • Charts have accurate units, labels and limits.
  • Data freshness and missing-source behaviour are documented.
  • Links open appropriate incident evidence.
  • Access follows least privilege.
  • The workbook has been tested after save and reload.

Agent Foskett takeaway

A good SOC dashboard does not simply show what happened. It shows what needs attention — and makes the evidence easy to reach.

Fifty lessons down. The logs already knew. The dashboard finally asked the right questions.

Lesson 50 complete — a major Academy milestone!
You can now assemble a practical SOC operations dashboard, distinguish incident state from historical trends and verify the evidence behind each metric.
Sentinel Academy Home