Every security architecture diagram I’ve ever seen looks like a layered cake. The perimeter is the frosting. WAFs and firewalls are the middle. IDS and endpoint agents are the sponge. SIEM is the plate. It’s pretty. It’s also mostly an illusion.

Real defense in depth doesn’t mean “we have five tools.” It means “each layer catches what the previous one misses.” When all five tools look for the same thing — say, the same IP address in the same log format — you have five identical copies of one layer, not five layers.

I’ve reviewed more architectures than I’d like to admit. The pattern is always the same: teams pile on controls until the diagram looks impressive, then wonder why the same attack gets through every time.

The Cake Pattern (and Why It Fails)

Here’s what most teams actually deploy:

Internet → Firewall (port-based) → WAF (signature-based) → IDS/IPS (pattern-matching) → EDR (behavior) → SIEM (correlation)

The attack: a low-and-slow credential-stuffing campaign against a web application.

  1. Firewall sees port 443 traffic from known ranges → allows it (it’s HTTPS)
  2. WAF sees 5 requests per second per IP → below the rate limit → allows it (it’s legitimate-looking)
  3. IDS matches a known credential-stuffing user-agent string → alerts (but the attacker rotates user-agents)
  4. EDR sees normal process behavior on the app server → allows it (the app itself makes the outbound API calls)
  5. SIEM correlates the alerts from step 3 → creates a ticket (but the alert volume is so high it gets buried)

Every layer is doing what it was configured to do. None catches what the others miss. The cake looks impressive. It has no structural integrity.

What Real Defense in Depth Looks Like

Real defense in depth means each layer watches for different things in the same attack. When the cake pattern fails, you don’t get a second chance — you get no chance at all.

Here’s the same attack with real defense in depth:

LayerWatches ForWhat It CatchesWhat It Misses
WAFAnomalous auth endpoint patterns (burst from unique IPs to same username)The credential stuffing pattern across the username spaceLegitimate bulk login (e.g., CSV import)
EDRAPI calls from the web app to a different auth backend with unusual timingThe app calling an internal auth service at 3 AM from a non-web processNormal off-hours batch login
FirewallNew destination IPs for outbound connections from the web tierApp server connecting to a new Redis instance on port 6380 (unusual)Redis on the expected port
EDR againChild process spawning from a web process (PHP-FPM → /bin/sh)Command injection via a file upload that triggers exec()PHP that only uses built-in functions
SIEMFailed logins from a new subnet within 10 minutes of successful logins on the same accountCredential compromise followed by lateral movementSlow attacks spread over days

Notice something? The WAF catches the pattern at the entry point. The EDR catches the API call that the WAF doesn’t see. The firewall catches the new destination the EDR doesn’t know about. SIEM catches the cross-layer relationship that no single tool can see alone.

Each layer catches a different slice of the attack. Together, they cover what no single layer can.

How to Audit Your Own Layers

Don’t trust the diagram. Audit it. Here’s the process:

1. Pick a real attack vector

Start with something you know has gotten through. Pick one of the last three incidents where an alert fired but the attacker still got in. Don’t pick a CVE that hasn’t landed yet. Pick something real.

2. Map every layer the attack touches

Go through the timeline. For each minute of the attack, list every tool that saw something. Not every tool that could have seen something — every tool that did see something.

3. Check for overlap

If three tools all alerted on the same IP address in the same 5-minute window, you have one layer with three identical copies. Delete two from your defense-in-depth argument. Keep the one that produced the cleanest signal.

4. Check for gaps

Between each pair of adjacent events in the timeline, is there more than a 15-minute window where no layer is watching for anything relevant? If so, that’s your gap. That’s where the attacker was comfortable.

5. Test each layer independently

Turn off every layer above the one you’re testing. Does this layer still catch the attack on its own? If it depends on the layer above to pre-filter noise, it’s not a layer — it’s a dependency.

6. Document what each layer catches and misses

Build a matrix: rows are layers, columns are attack steps. Mark each cell with what the layer catches and what it misses at that step. The matrix is more honest than any diagram.

Three Layers I Actually Trust

Layer 1: The WAF’s anomaly rules (not the signatures)

The signatures catch the known bad. The anomaly rules catch the unknown-unknown. A rate limit on the /api/v1/auth/login endpoint that’s tuned to the application’s actual traffic pattern (not a generic 100 req/s) catches credential stuffing before it reaches the app. The WAF sees the request pattern; the app sees the result. Between them is where most attacks hide.

Layer 2: EDR process trees on the app tier

A web process spawning a shell is one of the most common post-exploitation behaviors. Not every web app does it, but when one does, the process tree tells you whether it’s a legitimate background job or a command injection. EDR on the app tier catches things the network never sees — local file reads, in-memory data access, unexpected library loads.

Layer 3: SIEM cross-layer correlation

No single layer sees everything. SIEM is the only layer that can see the WAF alert from 14:03, the EDR process tree from 14:07, and the firewall new-destination connection from 14:09, and say “these three things from the same source IP in the same 7-minute window are probably the same attack.” That’s the actual defense: not the individual layers, but the relationships between them.

The Trade-off

Adding more layers costs money, complexity, and alert volume. But adding layers that watch for the same thing costs money, complexity, and alert volume without adding defense. The ROI of a layer is the ratio of unique attacks it catches to unique false positives it creates. A layer with a ratio below 1:1 is a liability.

The best defense-in-depth strategy has fewer layers than you’d expect — because each one is actually doing something the others don’t. Five layers that catch different slices of the attack are worth more than ten layers that catch the same slice ten times over.

Conclusion

Defense in depth isn’t a stack of tools. It’s a set of independent observation points, each watching a different aspect of the same attack. Audit your layers by picking real attacks and checking what each tool actually caught. If the WAF, EDR, and firewall all alerted on the same IP at the same time, you have one layer with a fancy name.

Build your next architecture change around this question: “What does this layer catch that no other layer catches?” If you can’t answer it, it’s just decoration.

Further Reading