Where Monitoring Ends and Detection Begins
Sooner or later someone will point at your monitoring dashboard and ask, "so that is our security monitoring, right?" Usually it happens on a tour, with a visitor standing next to the person asking. It is a fair question, and the honest answer is "partly." The same data that keeps the network running does reveal hostile activity; that is the whole premise of this pillar.
But a monitoring system is not a detection system, and treating it as one leads to two opposite mistakes. The first is trusting it to catch things it cannot see. The second is dismissing it as useless for security because it is not a specialist tool. I have watched one team make both mistakes in the same quarter.
This guide draws the boundary in plain language. You will learn the three verbs that separate monitoring, detection, and response. You will learn what a monitoring platform genuinely does well for security and what it honestly does not do. You will see where the handoffs to security tooling and people happen. You will learn why a monitoring alert can afford to be wrong while a security escalation cannot. And you will learn how to label alerts as "suspicious" or "sick" so everyone knows which kind of problem they are looking at. The guide ends with a way to set scope that a small team can actually keep.
In this guide
- Three verbs: notice, judge, act
- What a monitoring platform does well
- What it does not do
- The handoff points
- False-positive economics
- Suspicious vs. sick
- Honest scope for a small team
- Where to go next
Three verbs: notice, judge, act
The cleanest way to hold the boundary in your head is three verbs. Monitoring notices. It compares what is happening now against what is expected and flags the difference. For example, a port is passing ten times its usual packets. Or a host has appeared that was not there yesterday. Or an account has failed to log in forty times. Monitoring does not know why. It only knows "this is not normal."
Detection judges. Given a deviation, detection asks whether an adversary is behind it. That requires context monitoring does not have: what hostile behavior looks like and which addresses are known bad. Detection also needs to know what this host was doing an hour ago and whether the account belongs to someone on vacation. Detection is a judgment about intent, and intent is not a counter you can poll.
Response acts. Once something is judged hostile, response contains it, removes it, and recovers from it. That means disabling ports, resetting credentials, restoring from backup, and calling the people who need to know. Response is expensive, disruptive, and sometimes irreversible, which is why it should never be triggered by a raw monitoring alert.
A medical analogy helps. A thermometer notices a fever. A doctor judges whether the fever is a cold or something serious. Treatment acts on the diagnosis. Nobody expects the thermometer to diagnose, and nobody starts a course of antibiotics because a number on a screen went up. Your monitoring system is a very good thermometer. That is a compliment, and it is also a limit.
In practice the line between noticing and judging is a little blurry, and that is fine. A threshold that says "fifty failed logons from one source" is arguably a crude detection rule. Someone chose that number with hostile behavior in mind. The point of the three verbs is not to forbid monitoring from encoding a bit of judgment. It is to be clear about who makes the final call — a person. It is also to make sure nothing expensive happens automatically on the strength of a counter alone.
What a monitoring platform does well
Within the "notice" job, a mature monitoring platform brings real strengths that security tooling often lacks, and you should lean on them deliberately.
Baselines
A baseline is a record of what normal looks like for a specific metric in a specific place. For example: this port carries about this much traffic at this hour on a weekday. Most hostile behavior is, at bottom, a departure from normal. And a monitoring system that has watched a network for months knows normal better than any freshly installed security tool possibly can. That history is your single biggest security asset.
Thresholds
A threshold is a line that, when crossed, raises an alert. Thresholds are simple, understandable, and cheap. "More than fifty failed logons from one source in ten minutes" is a threshold, and it catches a real security signal without any specialist machinery.
Dependency-aware alerting
A good platform knows that if the core switch is down, the forty servers behind it are unreachable because of the switch. In that case, it sends you one alert instead of forty-one. That same dependency logic keeps a security view readable: one root cause, one alert. You avoid a wall of symptoms you have to untangle at the worst possible moment.
History and inventory
Monitoring systems keep time-series history and a device inventory as a matter of course. When something suspicious surfaces, the first questions are "when did this start?" and "what is this thing?" A platform that can answer both in two clicks is doing detection's homework for it.
Availability of the sensors themselves
One underrated strength: monitoring tells you when your sensors go dark. Suppose the log collector stops receiving from a server, or an agent on ten hosts stops reporting at once. That is both an ops problem and one of the strongest early security signals there is. Monitoring the monitor turns out to be security work.
What it does not do
Now the honest half, which is the half that never makes it onto the tour. There are things detection needs that a monitoring platform does not have. Pretending otherwise is how small teams end up with a false sense of coverage.
Signatures
A signature is a precise description of a known-bad thing. Examples are a specific byte pattern in a packet, a specific file hash, or a specific sequence of requests. Intrusion detection systems and endpoint protection carry libraries of thousands of signatures, updated constantly. A monitoring platform has none. It can tell you a host is sending unusual traffic; it cannot tell you the traffic matches a known malware family.
Threat intelligence
Threat intelligence is curated knowledge about adversaries. It covers which addresses and domains are currently used for command and control (the channel a compromised machine uses to take its orders). It also covers which techniques are active. It is what turns "this host talked to an unfamiliar address" into "this host talked to a known-bad address." Monitoring can show you the address. It cannot tell you its reputation. Some platforms can consume external lists, but the lists themselves are a separate, maintained thing.
Forensics
Forensics is the discipline of reconstructing exactly what happened. It uses packet-level captures, disk images, memory snapshots, file timelines, and a documented chain of custody so the evidence holds up later. Monitoring keeps summaries — flows, counters, log lines. These are excellent for pointing an investigator in the right direction and useless for proving what a process wrote to disk. Summaries tell you where to dig; forensics does the digging.
Judgment and containment
Finally, a monitoring platform does not decide. It will not tell you whether the account failing to log in belongs to a confused colleague or an intruder. And it should not be the thing that disables a port or resets a password on its own. Do not let it. Not for the obvious cases. Not "just for the servers". The judgment belongs to a person, and the action belongs to a process that person follows.
The handoff points
If monitoring notices and something else judges and acts, the interesting question is where the baton changes hands. There are three kinds of handoff, and each carries a different package.
| Monitoring has noticed | Hand off to | What you hand over |
|---|---|---|
| A host talking to an unfamiliar external address on a regular schedule | Security tooling: endpoint protection or an intrusion detection sensor, if you have one; otherwise a person | Host identity, destination address, first-seen time, flow history |
| Failed logons across many accounts from one source | A person: whoever owns identity, then management if it continues | Source address, list of accounts, timestamps, whether any succeeded |
| A scan-like pattern from an internal workstation | A process: your incident response steps, with containment first | Switch port, user, what you already did (and did not do) |
| Monitoring agents on many hosts going quiet at once | A person immediately, then an outside responder if confirmed | Which hosts, exact time, anything else that changed in the same window |
Whatever the destination, the package should be the same shape. Build the habit of assembling a small handoff packet before you pick up the phone:
- What was noticed, in one plain sentence, with the metric and the threshold it crossed.
- Which host, account, or port, with its inventory record: owner, location, role.
- When it started, from history, not from when you happened to look.
- What else changed in the same window: new devices, configuration events, other alerts.
- What you have already done, including nothing. Silence about actions is the most common way handoffs go wrong.
- Where the raw data lives and how long it will be kept, so the responder can pull it before it ages out.
Tip: a handoff is not an admission that you failed. Noticing early and handing off cleanly is exactly what a monitoring layer is for. The failure mode is the opposite: sitting on a signal for three days because you wanted to be sure before bothering anyone.
An example handoff, start to finish
Tuesday, 4:10 PM. Monitoring flags a workstation that has contacted the same external address every four minutes since 2:00 AM. You check the inventory: it belongs to someone in accounts, who is at her desk and has no idea what the address is. You check flows for the last week: the pattern started Sunday night, when nobody was in the building. Nothing else on the network talks to that address. That is a five-minute triage, and it did not produce an innocent explanation.
So you write it up in the packet shape. Include one sentence on what was noticed. Add the host and its owner, and the Sunday start time. Include the fact that no other host is involved and that you have taken no action beyond looking. You send it to your manager and, because your plan says so, to the outside responder your company keeps on call. You do not wipe the machine, because whoever investigates will want it as it is. Total elapsed time from alert to handoff: under half an hour. That is the layer working as designed. My first one took three hours, most of it spent deciding whether to bother anyone.
False-positive economics
Ops alerting and security alerting cannot be tuned the same way, and the reason is what each kind of mistake costs. Every alert has two possible errors: it fires when nothing is wrong (a false positive), or it stays silent when something is (a false negative). Tuning is the art of trading one against the other, and the right trade depends on what each error costs.
An operations alert can afford to be wrong. If "disk 85% full" fires and the disk turns out to be fine, you lose two minutes. If it stays quiet and the disk fills, you lose an afternoon. Both costs are modest, so a slightly noisy threshold is the sensible choice, and you tune by nudging the number.
A security escalation is a different economy. A false positive that reaches escalation costs someone's evening, a phone call to a manager, and possibly an invoice from an outside responder. Worst of all, it costs credibility, because the third false alarm is the one nobody answers. A false negative can cost the company. Both sides of the trade are expensive, which means you cannot fix it by moving a threshold. Raise it and you miss things; lower it and you burn out the people who respond.
The way out is a stage in between. Monitoring raises a suspicious alert cheaply and often. A human — you — triages it within a bounded time, using the handoff packet above. Only what survives triage becomes an escalation. The monitoring alert is allowed to be wrong because a five-minute look is cheap. The escalation is expensive, so it is gated by that look. Two stages, two different tolerances for error, and the whole thing stays affordable.
"Bounded time" is doing real work in that sentence. Decide in advance how long a suspicious alert may wait for its first look. Four business hours is a common choice for a small team. Decide what happens if the window passes with nobody available. The safe default is that an untriaged suspicious alert escalates on its own, not that it quietly ages out. That feels uncomfortable until you consider the alternative. A rule that says "if we are too busy, assume it was nothing" is a rule an intruder would write for you.
Suspicious vs. sick
That two-stage model needs one piece of vocabulary, and it is the most practical idea in this guide. Every alert your platform raises is either sick or suspicious. A sick alert means something is broken and the fix is operational: a cable, a full disk, a crashed service. A suspicious alert means something is behaving in a way that has no obvious operational explanation. And a person needs to decide whether it is hostile.
Labeling alerts this way changes how they are handled. Sick alerts go through your normal channel and can be worked at your normal pace. Suspicious alerts go to a distinct channel and always require a human to acknowledge them. They never auto-clear just because the metric went back to normal — an intruder who stops scanning has not left. The same signal can carry either label depending on what the first check shows. That is why the label is applied by a rule, not by a mood.
At Northgate Retail the packets-per-second alert on a workstation port fired at twenty to three in the morning. It ran for twenty minutes and cleared itself when the traffic stopped, because that is what the rule did for every other alert. The morning review found it in the resolved column, which nobody reads, and the administrator only opened it because the host name was unfamiliar. Four hours of asking around established that it was the security contractor's authorized vulnerability scan. Security had scheduled it, approved it, and told nobody in operations about it. The two teams had been watching the same port from different desks for a year. Suspicious alerts at Northgate now stay open until a person closes them, and the scan schedule is on the shared calendar.
| Signal | Sick if… | Suspicious if… |
|---|---|---|
| Packets per second spike on a port | Broadcast counter rose with it (a storm or a loop) | Broadcast flat, many distinct destinations (a scan) |
| Burst of failed logons | One account, one source, then silence | Many accounts from one source, or off-hours |
| New device on the network | Claimed by someone within the day | Unclaimed, or on a port that should be empty |
| DNS failure rate climbs | Every client is failing (resolver problem) | One client is failing on gibberish names |
| Agents stop reporting | One host, and it also stopped answering pings | Many hosts at once, still pingable |
Two subtleties. First, the label is a category, not a severity. A suspicious alert can be low severity (a new device in the guest network) or high (agents going quiet on a dozen servers). And a sick alert can be either too. Keep the two axes separate so a high-severity sick alert does not get confused with a security incident. That also ensures a low-severity suspicious alert still lands in the right channel. Second, a sick alert that keeps recurring without an operational cause should be promoted to suspicious. The port that "storms" every night at 3:00 AM has earned a second look through the other lens. So has the account that locks itself out every Sunday.
A simple way to make the label unmissable is to put it in the alert name. Describe the first check inside the alert text, too. That way, whoever reads it at eleven at night knows what to do without looking anything up:
[SUSPICIOUS] Auth failures: 63 across 21 accounts from 10.0.5.140 (10 min) First check: group by account; look for off-hours timing and nonexistent names. Sick if: one account, one device, user confirms password change. If not sick: do NOT clear. Assemble handoff packet and escalate per runbook. [SICK] Interface errors: 412 CRC errors on core-sw1 port 7 (1 hour) First check: cable and transceiver on port 7. Work in normal queue.
Honest scope for a small team
The last piece is deciding, out loud and in writing, what your monitoring layer promises about security. This matters because a scope nobody wrote down defaults, in management's mind, to "everything." Then the first incident becomes an argument about why the monitoring did not catch it. The honest answer is that it was never built to.
A useful scope statement has three parts: what you will notice, how fast, and what you will do about it. Keep each part modest enough that you can keep the promise on a bad week. Here is a template a team of one or three can realistically stand behind:
Security monitoring scope (from existing monitoring) We WILL notice, within one business day: - new devices appearing on the wired or wireless network - bursts of failed logons against domain, VPN, or Wi-Fi accounts - internal hosts contacting many other hosts or many new external addresses - DNS failure storms or unusual query volume from a single host - monitoring agents or log sources going quiet on several hosts at once We will TRIAGE each within four business hours and either close it as operational or escalate it as a possible security incident. We do NOT detect: known malware by signature, malicious content inside encrypted traffic, credential theft that produces no failed logons, or anything that never touches the network we monitor. Escalation path and outside help: see the incident contact sheet.
Notice what the statement refuses to say. It does not promise to detect "intrusions." It promises to notice five specific behaviors, quickly enough to matter, and to hand them off. The "do not detect" section is not an apology; it is what lets management decide, with clear eyes, whether to fund something more. Scope-setting for monitoring in general has its own guide in Monitoring Goals and Scope, and the same discipline applies here with higher stakes.
Two practical rules keep the scope honest over time. First, review it whenever the network changes shape — a new site, a move to cloud services, a merger. The "do not detect" list grows quietly. Second, when an incident does happen, compare it against the statement before anyone assigns blame. Either the behavior was in scope and the process needs fixing, or it was out of scope and the conversation is about coverage, not competence.
Where to go next
Monitoring notices, detection judges, response acts. A monitoring platform is a genuinely good first layer, as long as nobody mistakes it for the whole stack. It offers baselines, thresholds, dependency-aware alerts, history, and sensor health. Label alerts suspicious or sick, gate expensive escalations behind a cheap human look, and write down what you can and cannot see. The next time the question comes up on a tour, "partly" becomes a sentence you can finish. From here, Security Signals Hiding in Your Ops Monitoring catalogs the specific signals worth a suspicious label. Who Owns What settles who triages and who escalates. The rest of Network Monitoring as a Security Layer builds the view itself.
Put this into practice with SysPeep Monitor
The "notice" layer in this guide is exactly what a monitoring platform is built for. SysPeep Monitor gives you thresholds, dependencies, and alert rules designed to keep noise down, with email and other notifications you can route by label. It also gives you the history and device inventory a handoff packet needs. All of this comes from one web console on a Windows machine. Judgment and response stay with you; the free trial covers the noticing.
Download Free TrialLearn About SysPeep