Building Dependency Maps That Tame Alert Storms
If you have lived through an alert storm — one dead switch, fifty screaming alerts — you already know the disease. This guide is the cure: teaching your monitoring system what depends on what. That way, when a parent fails, it sends you one alert about the parent instead of fifty echoes about the children. That knowledge is called a dependency map. The relationship it records is simple: "if X is down, Y cannot work (or cannot be reached), so don't alarm about Y separately."
Here is the part that surprises people: this does not require an enterprise software project. Big companies build these maps inside a CMDB, a configuration management database. That is a system that tries to catalog every component and every relationship in the whole environment. Those projects are famous for consuming years and dying of staleness. You need none of that. A small or mid-size network gets most of the benefit from modeling a couple dozen relationships. And you can capture those in an afternoon with a whiteboard and the knowledge already in your head.
By the end of this guide you will know exactly what good dependency data buys you. You will know which relationships are worth modeling (and which to skip), and where the data comes from. You will learn how to encode it in whatever tool you have — even if that tool has no dependency feature at all. You will also learn how to keep the map honest as your network changes.
In this guide
- What dependency data does for your alerting
- Model the core, not the universe
- Where dependency data comes from
- Encoding it: the capability ladder
- Keeping the map honest
- The redundancy nuance
- A worked build: 100 devices, one afternoon
- The top-twenty worksheet
What dependency data does for your alerting
A dependency map pays for itself three separate ways, and it is worth knowing all three, because they justify slightly different modeling choices later.
Payoff 1: Storm collapse
This is the headline. Suppose the monitoring system knows that thirty devices sit behind one closet switch. A dead closet switch then produces one actionable alert — "switch down." The thirty children are marked as unreachable because of the parent rather than independently alarmed. Different tools use different words for that child state ("unreachable" vs. "down," "affected," "suppressed"). But the effect is the same: one page instead of fifty, and the one page names the right device. Your 2 AM self reads a single line and knows where to drive.
Payoff 2: Root-cause hints
Even when an alert does fire, dependency data lets it arrive pre-labeled: "file server unreachable — upstream switch SW-B2 also down." The alert carries its own likely explanation, which turns the triage question from "what could cause this?" into "is the hint right?" That is a much smaller question, especially during a messy multi-failure event where the storm-collapse logic alone cannot sort everything.
Payoff 3: Impact statements
Run the map backwards and you get the other gift. When a parent fails, the map can say what that means: "core switch B down: affects file shares, printing, badge access, building B Wi-Fi." Downward lookups answer "why is this child failing?"; the reversed lookup answers "who is hurt?" That impact sentence is what you tell the helpdesk in minute two of an outage. It is also the bridge to service-level views. If you have mapped which services ride on which infrastructure, the same relationships power both. That mapping is described in service-based monitoring.
One honest caveat before you fall in love: a dependency map is not a root-cause oracle. It models the relationships you told it about, and only those. Multi-failure events, logical dependencies you never encoded, and plain coincidences will still land on a human. That is why the manual skills in the rest of this pillar stay relevant no matter how good your map gets. The map's job is humbler and still transformative: make the common storms boring.
Model the core, not the universe
The reason CMDB projects die is that they try to model everything, and everything changes faster than anyone can type. The reason small dependency maps live is that they refuse to. Storms are not caused by random devices; they are caused by shared things, and every network has a short list of them. Model that list and you have collapsed the vast majority of your future storms — the classic 80/20 trade, and in this case the 20 is genuinely small.
The usual suspects, in rough order of storm-making power:
- The WAN edge → everything remote. Each site's router or firewall is the parent of that entire site. One relationship per site collapses your biggest possible storms.
- Core switches → their closets. The distribution layer: whatever everything plugs into, directly or through access switches.
- Closet/access switches → their devices. APs, printers, cameras, desktops — the leaf tier.
- Hypervisors → their VMs. A virtual machine cannot outlive its host. If you run virtualization, this is a mandatory branch of the tree (and it moves when VMs migrate — more on maintenance later).
- Shared storage → the hypervisors and servers on it. The cascade-storm parent.
- DNS and authentication → nearly everything. Awkward to model as strict parent-child (everything would have them as parents), but even a partial model — or just a prominent note — earns its keep. Dependency thinking is the deep dive on these invisible roots.
- The monitoring path itself. The switches and links between your monitoring server (and any remote probes) and the things they watch. When that path dies, everything looks down — model it so the alert says "you are blind," not "the world ended."
Two layers deep is a perfectly respectable starting map: site parents and switch parents, plus hypervisors if you have them. Deliberately shallow, explicitly unfinished. Then let reality refine it: every real storm that slips through reveals the next dependency worth adding. Keep a literal list — a storm-driven backlog. Your map then grows exactly where your network has proven it matters, instead of where a diagram said it theoretically might.
Where dependency data comes from
Three sources, ranked here by effort and by how much you can trust the result:
| Source | Effort | Truth level | Best for |
|---|---|---|---|
| Network topology (discovery, LLDP) | Low, if tooling supports it | High for physical links, blind to logical needs | Reachability parents: what is plugged into what |
| Manual curation (the whiteboard hour) | An afternoon | High — encodes what admins already know | The top-twenty relationships, site parents, oddities |
| Service decomposition | Ongoing, per service | High for logical needs (DNS, auth, storage) | Service dependencies and impact statements |
Network topology is the cheap, honest backbone. Switches advertise who their neighbors are over LLDP (Link Layer Discovery Protocol). This is a standard where each device periodically announces "I am switch X, port 12" to whatever is plugged into it. Discovery tools can read those announcements plus interface data to work out what sits behind what. Where your monitoring supports it, auto-derived "behind-ness" gives you the reachability tree with almost no typing. Verify a sample rather than trusting it blindly, since a missed uplink makes a wrong tree. Building and keeping this picture of your network is its own discipline; the network documentation guides cover it properly.
Manual curation is underrated because it sounds unscientific. It is actually the highest-density source you have. Every experienced admin already knows that "everything in the warehouse dies with that one switch" and "the badge system lives on the VM host in rack 2." A one-hour whiteboard session reliably produces the top twenty relationships. It takes you, whoever else touches the network, and the question "what shared things would take multiple other things down?" Typing them into the tool takes the rest of the afternoon.
Service decomposition comes at the map from the top. Take a service users care about (email, printing, the ERP), list what it needs layer by layer, and record those chains. It is the only source that captures logical dependencies — the DNS-and-auth kind that no cable diagram shows. It also doubles as an audit of what you are not yet monitoring.
Encoding it: the capability ladder
Tools differ enormously here, so plan against what yours can actually do. There are three rungs, and every rung beats the one below it — but even the bottom rung beats nothing.
Rung 1: Explicit parent-child dependencies
The ideal: your monitoring has a real dependency feature. You declare "these devices depend on SW-B2." When SW-B2 stops responding, the tool either suppresses the children's alerts entirely or files them as "unreachable due to parent." That is distinct from "down," which is exactly the distinction you want. Configure the parent's own alert to remain loud. Check how the tool treats the children's state history (you still want the outage recorded, just not paged). Then test it deliberately: pick a quiet moment, unplug a lab switch or block polling to a parent. Confirm you get one alert, not a storm.
One mechanical detail worth understanding: suppression is a race against your polling schedule. When a child check fails, the tool needs to know the parent's state at that moment to decide whether to stay quiet. If the parent happens to be polled less often than the child, the child can be declared down before the parent's failure is even discovered. Most tools handle this with a re-check or a short notification delay. If yours leaves it to you, give parents at least as fast a polling interval as their children. In that case, also add a couple of minutes of notification delay on the leaf tier. That gives the tree time to settle before anything pages. A little patience in the pipeline is what makes the collapse reliable instead of approximately right.
Rung 2: Group-based approximation
If true trees are not supported, approximate with structure. In that case, put devices into groups by site and closet, name the groups honestly (Site-B / Closet-B2), and route or digest alerts per group. A storm then arrives as forty alerts visibly from one group, which your storm-reading skills turn into a diagnosis in seconds. The tool is not collapsing the storm, but it is pre-sorting it for you. Some tools also let a single "gateway" check gate notifications for a group (alert only if the site's router also answers). That is a poor-man's parent rule worth setting up for remote sites.
Rung 3: The process-only fallback
No tooling support at all? Encode the map in the process instead. Use a one-page dependency sheet — parent, what dies with it, what to check first. Print it and tape it where on-call eyes will land on it, and save it wherever your runbooks live. It will not quiet a single alert, but it converts a storm from a mystery into a lookup. Knowledge beats nothing, every time. (It is also the perfect draft: the day you get a tool with dependency support, the sheet types straight in.)
Tip: whatever rung you are on, model the monitoring path first — the switch and uplink between your monitoring server and everything else. It is the one parent whose failure imitates the end of the world. It also causes the one storm where the correct first move (check the monitor's own connectivity) is the least obvious at 2 AM.
Keeping the map honest
Dependency maps rot, because topology changes and nobody remembers to tell the map. A stale map is worse than none in one specific way: it confidently suppresses the wrong things. Three small habits keep it truthful:
- The change hook. Any change that touches shared infrastructure ends with the question "does the dependency map need to know?" That includes new core gear, a re-cabled uplink, a moved server, and a new site. Put it on the change checklist so it survives busy weeks. VM migrations deserve special mention. If VMs move between hosts automatically, either let the tool track host assignment dynamically or model at the cluster level instead of the host level.
- The post-storm ritual. Every storm that reaches your pager un-collapsed is the map telling you what it is missing. Ten minutes after the incident: add the dependency the storm demonstrated. (This is the storm-driven backlog from earlier, actually being drained.)
- The annual audit. Once a year, walk the map against the current network diagram and delete what no longer exists. Retired switches lingering as parents are how ghosts get blamed for outages.
The redundancy nuance
Sooner or later you hit the awkward case: something with two parents. A server with redundant uplinks to two switches is not down when one switch dies — it is down only when both are. That is an AND-dependency, and honestly, tool support for it is patchy. You have three options, and the right answer is whichever failure mode you would rather live with.
Model the AND properly if your tool allows it — done. If not, you choose between two imperfections. Assign a single parent anyway, and you over-collapse. When that one switch dies, the dual-homed server gets suppressed even though it is actually fine. Or it is actually broken for a different reason — and now silent. Assign no parent, and you under-collapse. The server alerts independently during storms, adding noise but never hiding a real failure. For genuinely redundant, genuinely important things, under-collapse is usually the safer vice. A little extra noise is cheaper than a suppressed real outage. Just make the choice on purpose and write it down, so the next admin does not "fix" it into the dangerous version.
A worked build: 100 devices, one afternoon
Here is what this looks like in real life. A two-building shop: about a hundred monitored devices, a main office, a warehouse across the parking lot on a fiber uplink, one virtualization host, no dependency rules at all. History: every warehouse hiccup produced a thirty-alert storm. The admin books one afternoon.
Hour one is the whiteboard: what shared things take multiple things down? The answers come fast, because everyone already knows them. Hour two is typing the result into the monitoring tool as parent rules. Hour three is testing two of them during lunch. That means blocking polls to the warehouse switch and watching one alert fire instead of thirty. The same hour includes printing the sheet for the on-call desk. The resulting map — the whole thing — fits in one small table:
| Parent | Children (count) | Rule encoded |
|---|---|---|
| Firewall / internet edge | Cloud-service checks (6) | Edge down → suppress external checks |
| Core switch, main bldg | Closet switches, servers, APs (38) | Parent-child, children marked unreachable |
| Fiber uplink / warehouse switch | Everything in warehouse (24) | Parent-child; uplink modeled above switch |
| Closet switch, floor 2 | Floor-2 APs, printers, cameras (17) | Parent-child |
| VM host | Its VMs (9) | Parent-child; revisit if a second host arrives |
| Monitoring server's switch | Monitoring path note | "If this dies, you are blind" alert text |
| DNS/auth server | (note, not tree) | Documented on the dependency sheet as prime suspect for weird scattered failures |
Seven parents, roughly ninety children covered. The next month, a contractor cuts power to the warehouse, and the difference is visible in the notification log. Before the map, the same event looked like this:
14:02-14:05 31 alerts: SW-WH unreachable, AP-WH-1 unreachable,
AP-WH-2 unreachable, PRN-WH unreachable, SCALE-1
unreachable, CAM-WH unreachable ... (26 more)
After the map, it looks like this:
14:02:11 CRIT SW-WH switch unreachable (24 dependent devices
marked affected, not alerted)
14:02:40 WARN UPS-WH on battery power
Two lines, and the second one explains the first. The storm still happened — the warehouse was just as dark. But the map translated it into a sentence. The on-call admin spent the first five minutes dispatching an electrician instead of scrolling. That is the entire promise of this guide, delivered by an afternoon of work and seven rows of configuration.
The top-twenty worksheet
Ready to build yours? Work through these prompts with a whiteboard and whoever knows the network; twenty relationships is the usual harvest, and two layers is deep enough to start:
- For each remote site: what single device or link is that site's lifeline? (One parent per site.)
- What does every closet uplink into? (Core → closet relationships.)
- What plugs into each closet switch? (Closet → leaf devices — groups are fine.)
- Which physical hosts run which VMs, and what storage do those hosts share?
- What would make "everything" fail weirdly at once? (DNS, auth, NTP — note them even if you cannot tree them.)
- What sits between the monitoring server and everything it watches?
- Which of the above are dual-pathed — and for each, did you choose over-collapse or under-collapse on purpose?
- Where will you record the storm-driven backlog, and what change types trigger a map review?
With the map in place, storms collapse into sentences — and the rest of this pillar sharpens what you do with them. Anatomy of an alert storm covers reading the storms that still get through. For everything the map does not know yet, manual correlation is the human fallback. And event enrichment shows how dependency data becomes the impact line inside every alert. The full pillar lives at Alert Correlation & Root-Cause Thinking.
Put this into practice with SysPeep Monitor
Dependency rules are exactly the kind of thing SysPeep Monitor was built for. It auto-discovers your devices and interfaces, lets you encode parent-child dependencies between them, and uses those relationships to keep alert noise down. That means one meaningful alert per failure instead of a storm. Try it free on any Windows machine and model your top twenty this afternoon.
Download Free TrialLearn About SysPeep