Where Network Detection Fits in a Small Shop
You have decided, or been told, that the network should have some kind of intrusion detection. You understand the basics: a sensor watches a copy of traffic and raises alerts when it sees a known-bad pattern. The next questions are the practical ones that the basics never answer. Where, physically, does the sensor plug in? What will it actually do for you, as opposed to what the brochure says? Who is going to read the alerts, and what happens when one arrives at two in the morning? And how much of your week is this going to eat?
Those questions matter more in a small shop than in a large one. In a large one there is a security team to absorb the answers. In a small shop the answer to "who owns this" is usually you. A sensor nobody owns gets unplugged during a rack cleanup eighteen months later with no one noticing. This guide ranks the realistic placement points on a small network by value and sets honest expectations. It shows how to fold sensor alerts into the monitoring you already run. It lays out a first-ninety-days plan that keeps the whole thing from becoming another abandoned project.
In this guide
- What a sensor is actually for
- The placement points, ranked by value
- Placement, value, and effort: the table
- Getting traffic to the sensor without a second sensor
- Feed alerts into the alerting you already read
- Ownership: who reads it, who tunes it, what happens at 2 a.m.
- The time budget
- The first ninety days
- Where to go next
What a sensor is actually for
Start with expectations, because misplaced ones kill sensor projects. A network sensor is not a magic shield. A passive sensor cannot stop anything. IDS vs. IPS in Plain Language explains why a small team should not start with the inline kind that can. A network sensor will not catch everything, or even most things. Most traffic is encrypted and most attacks that matter are quiet. What it gives you is three things, each genuinely valuable and none dramatic.
Context for the alerts you already get. Your monitoring says a server's CPU spiked at 03:12. Your firewall log says a connection from that server went out to an unfamiliar address at 03:11. Neither, alone, is a story. A sensor that saw the outbound connection and recognized the pattern of a known malware check-in turns two disconnected facts into a diagnosis. Much of the day-to-day value of a sensor is exactly this: one more source of evidence that makes other evidence make sense.
Evidence during incidents. When something goes wrong, the question that costs the most time is "what else did it touch?" A sensor that has been logging connections, DNS lookups, and alerts for months lets you answer from records instead of guesses. Even when it raised no alert at the time, its logs are the closest thing a small shop has to a flight recorder for the network.
Policy-violation catches. A sensor is the cheapest way to find out that the things you believe about your network are not true. The retired cleartext protocol still in use. The camera system phoning a manufacturer's server. The workstation running a remote-access tool you never approved. Guest devices reaching a segment they should not reach because a firewall rule is wrong. None of these is an attack; every one is worth knowing, and most small shops discover a couple of them in the first week.
Expect those three things and you will be pleased. Expect a flashing red map that catches hackers in real time and you will be disappointed within a month. Disappointment is the first stage of abandonment.
The placement points, ranked by value
A sensor sees only the traffic that crosses the point where it listens. Choosing that point is the most consequential decision in the project, more than which engine you run or which rules you load. On a typical small network there are three candidates, and they are not equal.
First choice: just inside the internet edge
This is the link between your firewall's inside interface and your core switch. Everything leaving your network for the internet crosses it, and everything the firewall let in crosses it. That framing matters: you are not watching the raw internet, a firehose of automated junk your firewall already discards. You are watching what got through and what is leaving. Inbound, that means exploit attempts against services you actually publish. Outbound, it means malware check-ins and data going somewhere it should not. It also means DNS to resolvers you do not run, and cleartext protocols crossing a boundary they never should. For most small shops the outbound half is where the real findings live. An infected internal machine has to talk out, and this is where it does.
Place the sensor here first. If you only ever have one sensor, this is the one.
Second choice: the server segment boundary
Your servers may live on their own VLAN or behind an internal firewall. If so, the point where user traffic crosses into that segment is the second most valuable spot. What it sees is east-west traffic — internal hosts talking to internal hosts — which the edge sensor never sees at all. This is where you catch a compromised workstation scanning the server range. Or you catch an unusual host trying an administrative protocol against a domain controller. Or you catch a laptop that should only touch the file server suddenly talking to the database. The East-West and Lateral Movement pillar covers why this traffic matters. Here the point is simply that an edge sensor cannot see it. If your servers hold anything worth protecting, this boundary is worth a second look.
Third choice: the guest and IoT segment
This segment includes guest wireless, cameras, badge readers, building controls, and the smart television in the conference room. Here you have the least control over what is connected and the least idea what it does. A sensor on its uplink is not there to protect the guests. It is there to tell you when that segment tries to reach the rest of your network, and what its devices talk to on the internet. Alerts here are noisier, because visitor laptops carry all kinds of software, and less urgent, because the segment should be isolated anyway. But "should be isolated" is exactly the kind of belief a sensor exists to test.
Notice what is not on this list. The user access layer — the switches desktops plug into — is rarely worth a dedicated sensor in a small shop. Desktop-to-desktop traffic is low value and the number of places you would need to listen is high. Watch the boundaries traffic has to cross, not the leaves.
Placement, value, and effort: the table
| Placement | What it sees | Typical findings | Value | Effort |
|---|---|---|---|---|
| Inside the internet edge | Everything leaving for the internet; everything the firewall admitted | Malware check-ins, unexpected outbound services, exploit attempts on published services, rogue DNS | Highest | Low: one mirror port on one link |
| Server segment boundary | Internal traffic entering and leaving the server VLAN | Internal scanning, unusual administrative access, workstations reaching servers they should not | High, if the servers matter | Moderate: may need a mirror of a VLAN or an internal firewall link |
| Guest / IoT uplink | What that segment talks to, inside and out | Isolation failures, devices phoning home, infected visitor laptops | Moderate | Low, but alerts are noisy |
| User access switches | Desktop-to-desktop traffic on that switch only | Little of consequence | Low | High: many switches, many mirrors |
| Inside a virtualization host | VM-to-VM traffic that never touches a physical switch | Lateral movement between VMs | High for VM-heavy shops | High: needs virtual switch mirroring or a sensor VM per host |
The last row is the honest footnote to any placement plan. If most of your servers are virtual machines on one or two hosts, much of their traffic to each other never leaves the host. No physical mirror port will show that traffic to you. Virtual switches can usually mirror to a sensor running as a VM, but that is a second project. Start with the physical edge and be clear-eyed about the blind spot.
Getting traffic to the sensor without a second sensor
A single sensor box can often watch more than one placement point. Most engines capture from several interfaces at once. So one machine with three capture ports can listen to the edge link, the server boundary, and the guest uplink simultaneously. It must be able to keep up with the combined traffic. The mechanics of mirror ports, VLAN mirroring, and hardware taps are covered in SPAN, Mirror Ports and Taps. That includes the detail that an oversubscribed mirror port silently drops packets. Everything there applies directly to feeding a sensor.
Two placement-specific points are worth adding. First, label each capture interface with what it watches, in the engine's configuration and on the physical port. An alert is far more useful when it says "seen on the guest uplink" than "seen on eth2." Second, resist the urge to mirror everything to one port. A mirror carrying the edge link and the whole server VLAN will oversubscribe the sensor's interface long before you notice. A sensor that drops packets quietly misses things while looking healthy.
Tip: before you buy or build anything, look at the traffic counters on the link you plan to mirror — your monitoring already has them. The peak throughput on that interface, not the average, is the number the sensor has to keep up with. Deploying and Maintaining a Sensor You Won't Abandon walks through sizing from measured numbers.
Feed alerts into the alerting you already read
Every detection engine ships with, or has bolted on, some kind of console: charts, a list of recent alerts, a pie chart of categories. Those consoles are fine for investigation. They are terrible as the place alerts live, because they require somebody to open them. In a small shop nobody opens a second console on a normal Tuesday. The sensor fires and the console updates. The tab stays closed. Three weeks later you find out from someone else's email that a machine was compromised.
The fix is to route sensor output into the alerting pipeline you already trust and look at. Concretely, one or more of the following, in rough order of how easily a small team can do them.
- Syslog forwarding. Nearly every engine can send alerts as syslog messages. If your monitoring system or log collector already receives syslog from the firewall and switches, point the sensor at the same place. You get one timeline with firewall events and sensor alerts side by side, which is exactly what triage needs.
- Structured log output into a log collector. Modern engines write alerts and metadata as one JSON object per line. A log shipper can tail that file and forward it to whatever you use for logs. The SIEM-Lite pillar covers building that kind of pipeline without a full security platform.
- Email for a tiny set of high-confidence rules only. Never email every alert. Pick a handful of rules you have watched fire correctly — a known malware check-in, a scan from an internal host. Let those, and only those, reach an inbox or a pager.
- Sensor health into monitoring. The sensor is a server. Its CPU, disk, capture-interface drops, and the success of its rule-update job belong on the same dashboard as every other server, with the same thresholds.
Here is what a forwarded alert typically looks like once it lands in a shared log, in the one-line-per-event style most engines produce:
Mar 14 03:11:52 sensor-edge ids: {"event_type":"alert","in_iface":"edge-inside",
"src_ip":"10.20.0.44","src_port":51823,"dest_ip":"203.0.113.9","dest_port":443,
"proto":"TCP","alert":{"signature":"MALWARE Known family check-in over TLS",
"category":"A Network Trojan was detected","severity":1},
"tls":{"sni":"update-cdn.example"},"flow":{"pkts_toserver":9,"pkts_toclient":7}}
Ignore the exact field names; they vary by engine. What matters is that this one record carries the interface it was seen on, the internal source, and the external destination. It also carries the rule that matched and the server name from the TLS handshake. That is enough for whoever reads it in your log system to start asking the right questions without opening anything else.
Ownership: who reads it, who tunes it, what happens at 2 a.m.
A sensor without a named owner will be abandoned. Before it goes live, write down three answers, somewhere other than your own head.
Who reads it? One person, by name, has the daily job of looking at what the sensor produced. In a small shop that person is probably the same one who reads the monitoring alerts. That is another argument for putting the two in the same place. The daily look is short — fifteen minutes is the right budget. And Triaging IDS Alerts Without a SOC is built around exactly that. But the daily look has to be someone's, and it has to survive that someone's vacation. Name a backup.
Who tunes it? Reading and tuning are different jobs. Tuning means disabling rules that cannot apply to your network, raising thresholds on rules that fire on benign scanners, and suppressing known-good sources. It requires authority to change the sensor's configuration and the judgment to know that disabling a rule is a decision, not housekeeping. In a small shop the reader and the tuner are usually the same person, but say so explicitly. Keep a short log of what was disabled and why.
What happens at 2 a.m.? This is the question small teams avoid, and the answer is more comfortable than they fear. For a passive sensor, almost nothing needs to happen at 2 a.m. The sensor cannot stop anything, so a night alert is information, not an emergency the sensor is holding open. You chose a handful of rules to page on — a confirmed malware check-in from a server, say. Those rules should page through the same on-call arrangement your monitoring uses, with the same expectation. Acknowledge, contain if obvious (block the destination at the firewall, isolate the host), and investigate in the morning. Everything else waits for the daily fifteen minutes. If your shop has no on-call arrangement, the sensor does not create the need for one; it just makes the gap visible.
The time budget
A sensor costs attention every week, forever, and it is better to know the bill before you install it. A realistic budget for one sensor in a small shop, after the first noisy month:
- Daily: fifteen minutes. Skim what fired, dismiss the obvious, note anything that needs a second look.
- Weekly: thirty to sixty minutes. Review the week's alert counts by rule and tune the worst offenders. Follow up on anything you flagged for a second look. Check that the rule-update job actually ran.
- Monthly: an hour. Check sensor health trends (disk, drops, CPU) and confirm retention is behaving. Look at whether any network changes moved traffic away from the sensor's placement.
- Quarterly: a couple of hours. Prune the rule set, revisit placement, and decide honestly whether the sensor is still earning its time.
Add it up and a sensor costs a few hours a week during the first month and settles to under two afterwards. If your team cannot spare that, the honest answer is not to deploy yet. An unread sensor is worse than none, because it creates a belief in coverage that does not exist. If you can spare it, the return is real. Most of those hours are spent learning things about your own network that you would otherwise have discovered during an outage.
The first ninety days
Small scope, integrated alerts, one owner, and a calendar. Here is a plan that has those properties built in.
- Days 1–7: measure and place. Pull a week of throughput from the link you intend to mirror. Decide on the edge placement. Configure the mirror port, plug in the sensor with no IP on its capture interface, and confirm it sees both directions of traffic. Do not enable a single rule yet.
- Days 8–14: metadata first. Run the sensor in log-only mode, producing connection and DNS records with no alerts. Read them. You will find at least one thing that surprises you, and you will learn the sensor's normal load before rules add to it.
- Days 15–30: rules on, alerts local. Load a community rule set. Let alerts accumulate in the sensor's own logs, not in anyone's inbox. Spend the daily fifteen minutes learning which rules fire here and why. Disable the ones that cannot apply.
- Days 31–45: integrate. Forward alerts and sensor health into your monitoring and log system. Build one dashboard panel: alerts per day, by category. Add sensor health checks with real thresholds.
- Days 46–60: choose the pagers. Pick no more than a handful of rules whose alerts should reach a human outside working hours. Wire them into the existing on-call path. Write the two-line response for each.
- Days 61–75: the second vantage point, maybe. If the server boundary matters and the sensor has headroom, add a second capture interface there. If not, skip this step without guilt.
- Days 76–90: review and calendar. Look back: what did it find, what did it cost, what would you change? Put the weekly, monthly, and quarterly tasks on a real calendar with a named owner. Write down the placement and the disabled-rule list somewhere a successor could find them.
The plan is deliberately slow. Teams that load every rule and email every alert on day one have their sensor muted by day ten. Teams that spend two weeks reading metadata before enabling a single rule tend to still be reading their sensor a year later. By the time alerts arrive, those teams already understand the network the alerts describe.
Where to go next
Placement decides what a sensor can see; expectations decide whether you will keep looking. Put the first sensor just inside the internet edge. Add the server boundary if your servers matter. Treat the guest segment as a check on your own isolation. Accept that VM-to-VM traffic is a blind spot until you tackle it separately. Route alerts into the monitoring you already read. Give the sensor a named owner with a fifteen-minute daily habit, and budget the weekly hours honestly. From here, the IDS/IPS for Generalists pillar continues with the open-source engines you can run. It covers how to triage what they produce, and how to keep the whole thing alive past its first anniversary.
Put this into practice with SysPeep Monitor
This guide argues for sensor alerts and sensor health on the same dashboards as everything else. That integration is easier when the monitoring side is ready for it. SysPeep Monitor watches the sensor host like any other server over SNMP or WMI. It tracks the interface you mirrored so you can size against real peaks. It keeps alerts, maps, and reports in one web console. The free trial installs on a Windows machine in minutes.
Download Free TrialLearn About SysPeep