These are the notes for Cybersecurity Fundamentals (defensive), episode 73. In episode 72 we built good logs and shipped them to one central store. That store now receives a billion lines a day and nobody can read them. This episode invents the machine that reads them (the SIEM) and the craft of telling it what to look for (detection engineering), one problem at a time. Every term is defined the first time it appears; the Glossary collects them all.
Scope. Defensive and educational only. Every program is a toy simulation on made-up data; IP addresses come from the documentation ranges (192.0.2.0/24, 198.51.100.0/24). Samples were run on 14 Nov 2026 in Python 3, the same code as in the SyntaxPilot compiler in the video.
The control room: one guard, three hundred cameras
Real-life example: a big mall's CCTV control room. Three hundred cameras record day and night: that is our central log store, everything is recorded. One guard can watch maybe four screens. A thief walks past camera 212 and nobody sees it: recording everything is not the same as watching it. So the mall buys a smart system and the guard writes rules: "person in the store room after 11 pm", "same car circling the parking lot five times". When a rule matches, one beep, and the guard looks at the right screen.
- SIEM (Security Information and Event Management): a system that collects logs from everywhere, makes them searchable in one common format, runs detection rules over them and raises alerts. It is the "smart system" for logs.
- Detection engineering: the discipline of designing, testing, deploying and improving the rules a SIEM (or EDR) uses to find attacks.
Step 1: one language for all logs
Demo 1: one search, three sources, one missed
Log ingestion means taking logs in from servers, applications, devices and cloud services as they arrive. Here are three failed logins for Ravi, from a Linux server (sshd), our own web app (JSON) and a Windows domain controller (event 4625). We search all of them for fail.
# Three log sources, three formats. Search them all for failed logins.
logs = [
"Nov 14 02:10:01 web-01 sshd[811]: Failed password for ravi from 192.0.2.44",
'{"ts":"2026-11-14T02:10:03Z","evt":"login_failure","usr":"ravi","ip":"192.0.2.44"}',
"2026-11-14 02:10:05,DC-01,4625,An account failed to log on,ravi,192.0.2.44",
]
hits = [line for line in logs if "fail" in line]
print(f"searching 'fail': {len(hits)} of {len(logs)} found")
for line in hits: print(" found :", line[:52])
for line in logs:
if line not in hits: print(" MISSED:", line[:52])
Real output:
searching 'fail': 2 of 3 found
found : {"ts":"2026-11-14T02:10:03Z","evt":"login_failure","
found : 2026-11-14 02:10:05,DC-01,4625,An account failed to
MISSED: Nov 14 02:10:01 web-01 sshd[811]: Failed password fo
The Linux line says Failed with a capital F; the app says login_failure; Windows says 4625. Three sources, three ways of saying the same thing. With five hundred sources every search becomes a guessing game, and the attacker hides in the line you did not guess.
Demo 2: parsing and normalisation
- Parsing: reading a raw log line and pulling out its pieces (time, host, user, IP address, outcome). Example: from
... sshd[811]: Failed password for ravi from 192.0.2.44the parser extractsuser = ravi,ip = 192.0.2.44. - Normalisation: putting those pieces into the same named fields for every source, so
usr,userand the fifth CSV column all becomeuser. - Schema: the agreed list of field names and their meaning (here
time, host, user, ip, outcome). Real SIEMs ship hundreds of parsers and a common schema.
# Parsing + normalisation: every source becomes the SAME named fields.
import json, re
def from_sshd(line):
m = re.search(r"(\d\d:\d\d:\d\d) (\S+) sshd\S+ Failed password for (\S+) from (\S+)", line)
return {"time": m[1], "host": m[2], "user": m[3], "ip": m[4], "outcome": "fail"}
def from_app(line):
e = json.loads(line)
ok = e["evt"] != "login_failure"
return {"time": e["ts"][11:19], "host": "app-01", "user": e["usr"], "ip": e["ip"],
"outcome": "ok" if ok else "fail"}
def from_win(line):
date, host, eid, _, user, ip = line.split(",")
return {"time": date[11:], "host": host, "user": user, "ip": ip,
"outcome": "fail" if eid == "4625" else "ok"}
A = "Nov 14 02:10:01 web-01 sshd[811]: Failed password for ravi from 192.0.2.44"
B = '{"ts":"2026-11-14T02:10:03Z","evt":"login_failure","usr":"ravi","ip":"192.0.2.44"}'
C = "2026-11-14 02:10:05,DC-01,4625,An account failed to log on,ravi,192.0.2.44"
events = [from_sshd(A), from_app(B), from_win(C)]
for e in events: print(e["time"], f"{e['host']:7}", e["user"], e["ip"], e["outcome"])
print("failed logins found:", sum(e["outcome"] == "fail" for e in events), "of 3")
Real output:
02:10:01 web-01 ravi 192.0.2.44 fail
02:10:03 app-01 ravi 192.0.2.44 fail
02:10:05 DC-01 ravi 192.0.2.44 fail
failed logins found: 3 of 3
Now one simple question, outcome == "fail", finds all three. A log that fails to parse is a blind spot, so mature teams alert on parsing failures too.
Step 2: events that add up
Demo 3: a correlation rule
One failed login is nothing; people mistype passwords every day. Six failures from one IP followed by a success is a password being guessed. A correlation rule links several events together (same IP, within a time window, in a certain order) and fires only when the combination means danger.
# Correlation rule: 5+ failed logins from one IP, THEN a success, within 10 minutes.
events = [("02:10", "192.0.2.44", "ravi", "fail")] * 6 + [
("02:11", "198.51.100.7", "neha", "fail"),
("02:12", "192.0.2.44", "ravi", "ok"),
("02:13", "198.51.100.7", "neha", "ok")]
def minutes(t): h, m = t.split(":"); return int(h) * 60 + int(m)
alerts = []
for i, (t, ip, user, outcome) in enumerate(events):
if outcome != "ok": continue
fails = [e for e in events[:i] if e[1] == ip and e[3] == "fail"
and minutes(t) - minutes(e[0]) <= 10]
if len(fails) >= 5:
alerts.append(f"ALERT high: brute force then success, user={user} ip={ip} at {t}")
print("events in :", len(events))
print("alerts out:", len(alerts))
for a in alerts: print(" ", a)
Real output:
events in : 9
alerts out: 1
ALERT high: brute force then success, user=ravi ip=192.0.2.44 at 02:12
- Nine events in, one alert out. Neha's single typo followed by a login does not fire.
- Alert: a notification that a rule matched, with a severity (how urgent: low, medium, high, critical) and the details an analyst needs.
- Use case: the security question a rule exists to answer, for example "can we detect a guessed password?" or "can we detect someone clearing the audit log?". Good SIEM programmes start from a list of use cases, not from a list of logs.
- Time window: how far apart events may be and still count together (here 10 minutes).
A SIEM in one picture
ingest → parse → normalise → store → correlate (rules) → alert
collect pull out same field search join events severity
every log fields names months back + details
Step 3: rules as software
Demo 4: detection as code, with tests
A teammate thinks the brute-force rule is noisy and quietly raises its threshold in the SIEM's settings page. Nobody notices until a real attack is missed. The fix is to keep the rule in a file with tests.
# Detection as code: the rule lives in a file, WITH tests that must pass before it ships.
def brute_force(events, threshold=5):
fails = sum(1 for e in events if e == "fail")
return fails >= threshold and events[-1] == "ok"
def test_rule(rule):
assert rule(["fail"] * 6 + ["ok"]), "missed a real brute force"
assert not rule(["fail", "ok"]), "fired on a simple typo"
print("all tests passed: rule can ship")
test_rule(brute_force)
# A teammate 'reduces noise' by raising the threshold to 50 ...
test_rule(lambda events: brute_force(events, threshold=50))
Real output:
all tests passed: rule can ship
Traceback (most recent call last):
File "main.py", line 13, in <module>
test_rule(lambda events: brute_force(events, threshold=50))
~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "main.py", line 7, in test_rule
assert rule(["fail"] * 6 + ["ok"]), "missed a real brute force"
~~~~^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: missed a real brute force
(Saved as main.py, as in the compiler.)
- Detection as code: rules are written as files, kept in version control (a system such as Git that records every change, who made it and why), reviewed by a teammate and tested automatically before they ship, exactly like application code.
- Test: a small program that checks the rule does what it should: fires on a known-bad sample (a true positive) and stays quiet on a known-good one (avoiding a false positive).
- AssertionError: Python's error when an
assertcondition is false; here it blocks the bad change.
Sigma rules
Every SIEM product has its own query language, so a great rule written for one cannot run on another or be shared. Sigma fixes this. The SigmaHQ project describes it as "a generic and open signature format that allows you to describe relevant log events", and says "Sigma is for log files what Snort is for network traffic and YARA is for files". A Sigma rule is a small YAML file (a plain-text format of name: value pairs, indented to nest):
title: Failed network logon
status: experimental
logsource:
product: windows
service: security
detection:
selection:
EventID: 4625
LogonType: 3
condition: selection
falsepositives:
- users mistyping saved passwords
level: low
tags:
- attack.t1110
| Field | Meaning |
|---|---|
title, status |
what the rule detects; how mature it is (experimental, test, stable) |
logsource |
which logs it applies to (product, service, category) |
detection → selection |
the field values to match (4625 failed logon, logon type 3 = network) |
condition |
which selections must match (selection, sel1 and not filter, ...) |
falsepositives |
known harmless causes, to help triage |
level |
severity of the resulting alert |
tags |
links to MITRE ATT&CK, e.g. attack.t1110 = Brute Force |
The official sigma-cli tool and the pySigma library convert a Sigma rule into a specific SIEM's query language.
Demo 5: one rule, two SIEMs
# A Sigma-style rule (normally a YAML file) converted to two different SIEM queries.
rule = {"title": "Failed network logon", "level": "low", "tags": ["attack.t1110"],
"logsource": {"product": "windows", "service": "security"},
"detection": {"selection": {"EventID": 4625, "LogonType": 3},
"condition": "selection"}}
def to_sql(r):
where = " AND ".join(f"{k} = {v}" for k, v in r["detection"]["selection"].items())
return f"SELECT * FROM {r['logsource']['product']}_{r['logsource']['service']} WHERE {where}"
def to_search(r):
terms = " ".join(f"{k}={v}" for k, v in r["detection"]["selection"].items())
return f"index={r['logsource']['service']} {terms}"
print("rule :", rule["title"], "| level", rule["level"], "|", rule["tags"][0])
print("SIEM 1:", to_sql(rule))
print("SIEM 2:", to_search(rule))
Real output:
rule : Failed network logon | level low | attack.t1110
SIEM 1: SELECT * FROM windows_security WHERE EventID = 4625 AND LogonType = 3
SIEM 2: index=security EventID=4625 LogonType=3
Real converters handle many more features (wildcards, lists, not, field mappings), but the idea is the same: write once, convert anywhere, share with everyone. Public Sigma rule collections contain thousands of community rules you can review, test and adopt.
Step 4: what do we cover?
Demo 6: MITRE ATT&CK mapping
MITRE ATT&CK (episode 4) is a public catalogue of attacker tactics (the goal of a step, such as Credential Access) and techniques (how it is done, such as T1110 Brute Force or T1059.001 Command and Scripting Interpreter: PowerShell).
# MITRE ATT&CK mapping: which tactics do our rules cover?
rules = {"Brute force then success": ("Credential Access", "T1110"),
"Failed network logon": ("Credential Access", "T1110"),
"Word starts PowerShell": ("Execution", "T1059.001"),
"Audit log cleared (1102)": ("Defense Evasion", "T1070.001")}
tactics = ["Initial Access", "Execution", "Persistence", "Privilege Escalation",
"Defense Evasion", "Credential Access", "Lateral Movement", "Exfiltration"]
for tactic in tactics:
covered = [name for name, (t, _) in rules.items() if t == tactic]
mark = "COVERED " if covered else "GAP "
print(f"{mark} {tactic:21}", ", ".join(covered)[:40])
gaps = sum(1 for t in tactics if not any(r[0] == t for r in rules.values()))
print(f"{gaps} of {len(tactics)} tactics have no detection")
Real output:
GAP Initial Access
COVERED Execution Word starts PowerShell
GAP Persistence
GAP Privilege Escalation
COVERED Defense Evasion Audit log cleared (1102)
COVERED Credential Access Brute force then success, Failed network
GAP Lateral Movement
GAP Exfiltration
5 of 8 tactics have no detection
- ATT&CK mapping: tagging each rule with the technique it detects, so you can draw a coverage map and see the gaps (tactics or techniques with no detection).
- Use it to choose the next rule by risk, not by what is easiest to write. Coverage is not the same as quality: one weak rule "covers" a technique on paper but may miss most real attacks, so test rules against real or simulated activity.
Step 5: too many alarms
Demo 7: alert fatigue and tuning
A lazy rule alerts on every failed login. One backup service account still uses an old password and fails every few seconds.
# Alert fatigue: one rule fires on EVERY failed login. Then we tune it.
import random
random.seed(7)
users = ["svc-backup"] * 2400 + ["ravi", "neha", "asha"] * 200 # svc-backup has an old password
day = [random.choice(users) for _ in range(3000)]
day += ["priya"] * 8 # the one real attack
before = len(day)
noise = {"svc-backup"} # known false positive, ticket raised
tuned = [u for u in day if u not in noise]
counts = {u: tuned.count(u) for u in set(tuned)}
after = [u for u, n in counts.items() if n >= 5 and u not in ("ravi", "neha", "asha")]
print("alerts per day before tuning:", before)
print("alerts per day after tuning :", len(after), "->", after)
print("the real attack was alert", day.index("priya") + 1, "of", before, "before tuning")
Real output:
alerts per day before tuning: 3008
alerts per day after tuning : 1 -> ['priya']
the real attack was alert 3001 of 3008 before tuning
- Alert fatigue: so many alerts, mostly false positives, that analysts stop paying attention and real attacks are missed. Here the real attack is alert 3,001 of 3,008.
- False positive: an alert on something harmless. False negative: a real attack that raised no alert (worse, because it is silent). True positive: a correct alert on a real attack.
- Tuning: changing a rule to cut noise without losing real detections: exclude a known harmless source, raise a threshold, add a condition, correlate with other events.
- Every exclusion is a place an attacker could hide: document why it exists, raise a ticket to fix the root cause (here, the service account's password) and review exclusions regularly.
Demo 8: baselining and UEBA
A fixed threshold ("alert if more than 100 files") does not fit everyone: a backup job downloads 500 files every day, a normal user three.
# A fixed threshold vs a baseline: what is NORMAL for each user?
from statistics import mean, stdev
history = {"ravi": [2, 3, 1, 2, 4, 2, 3], # files downloaded per day, last 7 days
"backup": [480, 510, 495, 505, 490, 500, 515],
"priya": [5, 4, 6, 5, 3, 5, 4]}
today = {"ravi": 3, "backup": 502, "priya": 260}
print("fixed rule 'alert if > 100 files':")
for u, n in today.items(): print(f" {u:7} {n:4}", "ALERT" if n > 100 else "")
print("baseline rule 'alert if > mean + 3 x stdev':")
for u, n in today.items():
limit = mean(history[u]) + 3 * stdev(history[u])
print(f" {u:7} {n:4} normal up to {limit:5.0f}", "ALERT" if n > limit else "")
Real output:
fixed rule 'alert if > 100 files':
ravi 3
backup 502 ALERT
priya 260 ALERT
baseline rule 'alert if > mean + 3 x stdev':
ravi 3 normal up to 5
backup 502 normal up to 535
priya 260 normal up to 7 ALERT
- Baseline: a measurement of what is normal (per user, per host, per hour) taken before you decide what is abnormal.
- Baselining: building those baselines and alerting on large departures from them.
- Mean: the average. Standard deviation: a measure of how much values usually vary around the mean. "Mean + 3 × standard deviation" is a simple, common "unusually high" limit.
- UEBA (User and Entity Behaviour Analytics): a system that baselines every user and every entity (a laptop, server, service account, application) automatically, and flags unusual behaviour: a login at 3 a.m. from a new country, a sudden spike in files read. It catches a stolen account that logs in "correctly", but it needs history and still errs, so its alerts are clues for a human, not verdicts.
Step 6: the same clicks every time
Demo 9: SOAR and a playbook
Every brute-force alert gets the same steps: look up the IP, check threat intelligence, decide severity, disable the account, open a ticket. At two hundred alerts a day that is a full-time job of copy and paste.
# SOAR: a playbook runs the same steps for every alert, in seconds.
BAD_IPS = {"192.0.2.44"} # threat intelligence list (toy)
def enrich(a): a["ip_known_bad"] = a["ip"] in BAD_IPS; return a
def score(a): a["severity"] = "high" if a["ip_known_bad"] else "medium"; return a
def ask_human(a): print(" ask analyst: disable", a["user"], "? -> approved"); return True
def contain(a): print(" account", a["user"], "disabled, sessions revoked")
def ticket(a): print(" ticket opened:", a["rule"], "|", a["user"], "|", a["severity"])
def playbook(alert):
print("alert:", alert["rule"], "for", alert["user"])
a = score(enrich(alert))
if a["severity"] == "high" and ask_human(a): contain(a)
ticket(a)
playbook({"rule": "brute force then success", "user": "ravi", "ip": "192.0.2.44"})
playbook({"rule": "brute force then success", "user": "neha", "ip": "198.51.100.7"})
Real output:
alert: brute force then success for ravi
ask analyst: disable ravi ? -> approved
account ravi disabled, sessions revoked
ticket opened: brute force then success | ravi | high
alert: brute force then success for neha
ticket opened: brute force then success | neha | medium
- SOAR (Security Orchestration, Automation and Response): a platform that connects security tools (orchestration), runs the routine steps automatically (automation) and helps act on alerts (response).
- Playbook: the written list of steps (and decisions) for one kind of alert, here as code. Playbook automation: letting SOAR run those steps.
- Enrichment: adding context to an alert automatically, such as whether the IP appears in threat intelligence.
- Keep a human approval step before drastic actions (disabling accounts, isolating servers): automation should never lock out the CEO because of a false positive.
The whole chain
- A
failsearch missed one of three logs → ingestion, parsing, normalisation. - One failure is noise → correlation rules, alerts, use cases.
- A rule silently broken → detection engineering, detection as code with tests.
- Every SIEM speaks differently → Sigma rules.
- Which attacks can we see? → MITRE ATT&CK mapping.
- 3,008 alerts a day → tuning; one threshold for everyone → baselining, UEBA.
- The same clicks every time → SOAR, playbook automation.
Common mistakes (and the fix)
| Mistake | What you see | Why | Fix |
|---|---|---|---|
search raw text for fail |
searching 'fail': 2 of 3 found |
each source spells it differently | parse and normalise into one schema |
| editing rules by hand in the SIEM | AssertionError: missed a real brute force (if you had tests) |
untested change broke detection | detection as code: version control, review, tests |
| alert on every single event | alerts per day before tuning: 3008 |
noise hides the attack | correlate, tune, document exclusions |
| exclusions nobody reviews | an attacker uses the excluded account | permanent blind spot | ticket the root cause, review exclusions |
| one fixed threshold for all | the backup job alerts every day | ignores what is normal | baselines, UEBA |
| auto-disable on every alert | the CEO locked out by a false positive | no human in the loop | approval step for drastic actions |
| unparsed logs ignored | a source silently drops out | blind spot | alert on parsing failures and silent sources |
Mini project: a tiny SIEM
Write a program that (1) ingests lines from three made-up sources (syslog-style text, JSON, CSV), (2) normalises them to time, host, user, ip, action, outcome, (3) runs two correlation rules (brute force then success; audit log cleared), each with tests, (4) tags each rule with an ATT&CK technique and prints a coverage table, and (5) sends each alert through a playbook that enriches it and asks for approval before "disabling" an account.
Practice
1. Add a fourth log format to the normaliser (ravi|192.0.2.44|LOGIN_FAILED|02:10:07).
Solution
def from_pipe(line):
user, ip, evt, time = line.split("|")
return {"time": time, "host": "vpn-01", "user": user, "ip": ip,
"outcome": "fail" if evt == "LOGIN_FAILED" else "ok"}
print(from_pipe("ravi|192.0.2.44|LOGIN_FAILED|02:10:07"))
# {'time': '02:10:07', 'host': 'vpn-01', 'user': 'ravi', 'ip': '192.0.2.44', 'outcome': 'fail'}
2. Write a test that would catch someone setting the threshold to 1.
Solution
A threshold of 1 makes the rule fire on a single typo followed by a login, so this assertion catches it:
assert not rule(["fail", "ok"]), "fired on a simple typo"
It is already in test_rule: test_rule(lambda e: brute_force(e, threshold=1)) raises AssertionError: fired on a simple typo.
3. Fill one ATT&CK gap: add a rule for "new user account created" (Windows 4720).
Solution
Account creation is the Persistence technique T1136 (Create Account). Add "New user created (4720)": ("Persistence", "T1136") to rules; the map then shows Persistence as COVERED and the last line becomes 4 of 8 tactics have no detection.
4. Make the playbook skip automatic containment at night unless an analyst approves.
Solution
def playbook(alert, hour, analyst_online):
a = score(enrich(alert))
if a["severity"] == "high":
if analyst_online and ask_human(a): contain(a)
else: print(" no analyst: page the on-call, do not auto-disable")
ticket(a)
5. Why might a UEBA alert be wrong? Answer
Behaviour changes for innocent reasons: travel, a new project, month-end reports, a new job role. Too little history also gives a poor baseline. That is why UEBA alerts are evidence for an analyst, not automatic verdicts.
Quick quiz
A: normalisation
B: alert fatigue
C: a correlation rule
D: a baseline
Analysts ignore a rule that fires 3,000 times a day, almost always on harmless events. What is this called?
Answer
B. Alert fatigue. Too many false positives, so people stop paying attention and the real attack slips through. The fix is tuning (and correlation, baselines).
Interview questions
- What does a SIEM do? Ingests logs from many sources, parses and normalises them, stores them for search, correlates events with rules and raises alerts; often adds dashboards, reports and case management.
- Why normalise logs? So one query or rule works across every source; without a common schema each search must guess every spelling.
- What is a correlation rule? Give an example. A rule joining several events, e.g. five or more failed logins from one IP followed by a success within 10 minutes.
- What is a use case? A security question the SIEM must answer, with the logs, rule, response and owner needed for it.
- What is detection as code? Rules stored as files in version control, peer reviewed, tested with positive and negative samples and deployed automatically.
- What is Sigma? A generic, open, vendor-neutral YAML format for log detection rules, converted to SIEM queries with sigma-cli or pySigma.
- How do you use MITRE ATT&CK in detection engineering? Tag rules with techniques, build a coverage map, prioritise gaps by risk, test detections against simulated techniques.
- What causes alert fatigue and how do you fix it? Noisy, untuned rules with many false positives; fix by tuning, correlation, baselines, better severity, and removing useless rules.
- False positive vs false negative? An alert on harmless activity vs a missed real attack; false negatives are more dangerous because they are silent.
- What is UEBA? Behaviour analytics that baseline users and entities and flag anomalies, catching e.g. compromised accounts that use valid passwords.
- What is SOAR, and what should it not do? Orchestration and automation of response steps through playbooks; it should not take drastic, hard-to-undo actions on low-confidence alerts without human approval.
Glossary
| Term | Meaning |
|---|---|
| SIEM | Security Information and Event Management: collects, normalises, stores and correlates logs and raises alerts |
| log ingestion | taking logs in from servers, apps, devices and cloud services as they arrive |
| parsing | reading a raw log line and extracting its fields |
| normalisation | mapping fields from every source into the same names and formats |
| schema | the agreed list of field names and meanings |
| blind spot | activity you cannot see because a source is missing or unparsed |
| correlation rule | a rule that links several events (same IP, time window, order) |
| time window | how far apart events may be and still count together |
| alert | a notification that a rule matched, with severity and details |
| severity | how urgent an alert is (low, medium, high, critical) |
| use case | the security question a rule exists to answer |
| detection engineering | designing, testing, deploying and improving detection rules |
| detection as code | rules as files in version control, reviewed and tested before deployment |
| version control | a system (such as Git) that records every change to files |
| test | code that checks a rule fires on bad samples and not on good ones |
| AssertionError | Python's error when an assert condition is false |
| Sigma | a generic, open YAML format for log detection rules |
| YAML | a plain-text format of indented name: value pairs |
| sigma-cli, pySigma | the official converter tool and library for Sigma rules |
| MITRE ATT&CK | a public catalogue of attacker tactics and techniques |
| tactic | the attacker's goal for a step (e.g. Credential Access) |
| technique | how a tactic is achieved (e.g. T1110 Brute Force) |
| ATT&CK mapping | tagging rules with techniques to see coverage and gaps |
| coverage map | a table of tactics/techniques showing which have detections |
| true positive | a correct alert on a real attack |
| false positive | an alert on harmless activity |
| false negative | a real attack that raised no alert |
| alert fatigue | analysts ignoring alerts because most are false positives |
| tuning | changing a rule to reduce noise without losing real detections |
| exclusion | a condition that stops a rule firing for a known harmless case |
| baseline | a measurement of normal behaviour |
| baselining | building baselines and alerting on large departures from them |
| mean, standard deviation | the average; how much values usually vary around it |
| UEBA | User and Entity Behaviour Analytics: automatic behaviour baselines and anomaly alerts |
| entity | a non-human thing whose behaviour is tracked: laptop, server, service account, app |
| SOAR | Security Orchestration, Automation and Response |
| orchestration | connecting security tools so they work together |
| playbook | the written steps and decisions for one kind of alert |
| playbook automation | SOAR running a playbook's steps automatically |
| enrichment | adding context (IP reputation, asset owner) to an alert |
Summary
- A SIEM ingests, parses, normalises and stores logs so one question works across every source.
- Correlation rules join events into meaningful alerts, each answering a clear use case.
- Detection engineering treats rules as software: detection as code, reviewed and tested; share them as Sigma rules.
- MITRE ATT&CK mapping shows which attacks you can see and where the gaps are.
- Fight alert fatigue with tuning, documented exclusions, baselines and UEBA.
- SOAR playbooks automate routine steps, with a human approving drastic ones.
- Next episode: the SOC, threat intelligence and threat hunting.
Sources (fetched 14 Nov 2026)
- SigmaHQ, Sigma README: https://github.com/SigmaHQ/sigma
- ManageEngine, What are Sigma rules (rule fields): https://www.manageengine.com/log-management/cyber-security/what-are-sigma-rules.html
- MITRE ATT&CK, T1059.001 Command and Scripting Interpreter: PowerShell: https://attack.mitre.org/techniques/T1059/001/
- Episode 72 notes (Windows event IDs from Microsoft Learn): https://syntaxpilot-learning-2026.web.app/notes/sec/sec_ep72/