Home › Topics › Post-Incident Reviews › Beyond Root Cause

Beyond Root Cause: Contributing Causes and the Five Whys Done Right


Every incident report template has the same field, in bold: Root Cause. Singular. Fill in the one true reason, close the ticket, move on. It is a comforting idea, because finding a broken part and replacing it feels like an ending. It is also responsible for a great deal of repeat misery, because real incidents almost never have one cause. They have a chain of causes, plus a surrounding cast of conditions. Those conditions made the chain possible, made it invisible, and made it hurt more than it had to.


I learned this the usual way. I once closed a report with a single cause and replaced the part it named. I watched the same outage come back a few months later with a different trigger and every other cause still in place. The part had been the least interesting thing in the room.


This guide is about finding all of it. You will learn why "the root cause" is usually a simplification that leaves loaded guns lying around. You will learn how to run the classic five whys questioning technique so that it finds systems instead of scapegoats. You will learn when to stop asking why (there is a real answer, and it is not "after five"). And you will learn a four-lens sweep that catches the contributing causes the why-chain walks straight past. By the end you will be able to take one incident and mine it for its full list of fixable things. That is the whole economic point of doing reviews.


In this guide

  • The myth of the single root cause
  • The five whys, demonstrated
  • Ask about systems, not people
  • Let it branch: the why-tree
  • Knowing when to stop
  • The four-lens sweep for contributing causes
  • From findings to priorities
  • The worked analysis, end to end
  • The analysis kit

The myth of the single root cause


Take a plausible outage. On a Tuesday morning, the switch feeding your server room fails outright — power supply, dead, no drama about the diagnosis. Users lose the file service and the line-of-business app for three hours. The incident report writes itself: root cause — hardware failure of core switch. Action — switch replaced. Closed.


Now look closer, the way a review should. That switch had a redundant partner — a standby path that was supposed to take over. It did not, because the standby's uplink had quietly died months earlier. Nobody knew, because those ports were never monitored. The outage also ran longer than it needed to. The first alert fired into a chat channel someone had muted during a noisy week and never unmuted. And the repair took an extra forty minutes because of the runbook — the written procedure for exactly this failover. It described the topology from two redesigns ago. So the admin following it was navigating a network that no longer existed.


Count the causes: a failed switch, an unmonitored redundant path, a muted alert channel, an outdated runbook. Four distinct, fixable things — and the single-root-cause report found exactly one of them. Replace the switch and you have left three loaded guns exactly where they were. The standby is still invisible, the channel is still muted, and the runbook still lies. The next incident — different trigger, probably a different day of the week — will happily use any of them. This is why teams that "fix the root cause" every time still feel like they are living the same month over and over.


The alternative is the contributing-cause mindset. Hunt for everything that, had it been different, would have prevented the incident or made it shorter or smaller. This is not to spread blame thinner — blame is not the currency here at all. It is because each of those things is a separate opportunity to make next month quieter. Opportunities are what a review is for. The rest of this guide is the toolkit for that hunt. The five whys dig down the chain. The four-lens sweep looks around it.


It is worth asking why the single-cause habit is so sticky, because you will be arguing against it. Partly it is the templates — one field, one answer. Partly it is that a single cause makes a satisfying story: a villain, a fix, an ending. And partly it is speed. During the incident, hunting for the cause is exactly right, because you need the one thing to change to restore service. The trap is carrying that firefighting mindset into the review. There, the question has changed from "what do we fix right now?" to "what do we fix so this stops happening?" Different question, different number of answers.


The five whys, demonstrated


The five whys is the oldest tool in the causal-analysis drawer. Start from the failure and ask "why?" repeatedly, each answer becoming the next question, until you hit something worth fixing. The number five is folklore, not law — sometimes it is three, sometimes seven. The value is in the discipline of not stopping at the first answer. Here it is, run honestly on the Tuesday outage:


Why did users lose service for three hours?
  → All traffic to the server room was on one path,
    and the switch carrying it failed.
Why did the failover not engage when the switch died?
  → The standby path was already dead.
Why was the standby path dead?
  → Its uplink transceiver had failed months earlier,
    and it simply stayed dead.
Why did nobody know about a failure months old?
  → The standby ports had no monitoring checks
    — only "important" devices got checks.
Why were they unmonitored?
  → Coverage was set up once, by hand, long ago.
    Nothing and nobody ever asks "what is missing?"

Notice where five honest whys landed: not on the switch, not on a person, but on a process — the absence of any recurring review of monitoring coverage. That is typical, and it is the payoff. Hardware causes explain one incident; process causes explain the next ten. A why-chain that ends on "the part broke" almost always stopped too early, because parts breaking is what parts do. The interesting question is why breaking one part became a three-hour outage.


Two mechanics keep the exercise honest when you run it live. First, write the chain where everyone can see it — a whiteboard, a shared doc. A chain that lives in the facilitator's head quietly becomes the facilitator's opinion. Second, check each answer against the timeline before accepting it. "The standby was already dead" is a claim; the graph showing zero traffic on that path for four months is a fact. A why-chain built on unverified answers is just a story with arrows, and stories with arrows are how teams end up confidently fixing the wrong thing.


Ask about systems, not people

The fastest way to ruin a why-chain is to route it through a person: "why did Bob mute the channel?" Now Bob is defending himself, the room is watching a trial, and the chain is dead. You will get justifications, not causes. The fix is grammatical and non-negotiable: every why asks about the system. "Why did Bob mute the channel?" becomes "why was muting that channel the natural thing to do?" Suddenly the honest answer surfaces. The channel carried forty low-value alerts a day, and muting was the only tool anyone had for the noise. That answer contains two fixables (the noise, the lack of a critical-alerts route that cannot be muted). The Bob version contained none. This is the blameless grammar. It is covered in depth — along with what to do when blame surfaces anyway — in blameless reviews that actually change things. Inside the why-chain, the rule is simply: if a why lands on a name, rephrase it until it lands on a condition.


Let it branch: the why-tree

The textbook five whys is a straight line, and real incidents are not. Ask "why did users lose service for three hours?" There are at least two honest answers. One is that the failover did not engage (which is about the outage happening). Another is that detection and repair were slow (which is about the three hours). A straight chain forces you to pick one and silently drop the other. Do not pick — branch. Follow both. The muted-channel branch runs: why three hours? → the first alert went unseen for 35 minutes → why? → it fired into a muted channel → why muted? → chronic alert noise with no quiet-hours design — actionable. The runbook branch runs: why was the repair slow once started? → the failover procedure misdirected the admin → why? → the runbook described the old topology → why outdated? → network changes have no step that updates affected runbooks — actionable again. What you end up drawing is not a chain but a why-tree. It has one incident at the top, causes fanning out and downward, and several actionable leaves at the bottom. The tree is the honest shape of the incident. If your analysis of a multi-hour outage produced exactly one cause, that is usually the signature of an un-branched chain, not a simple incident.


Knowing when to stop

Every why-chain has two failure modes at its end. Go too far and you reach philosophy: why was coverage manual? → because the team is small → why? → because budgets → why? → because the company exists. Somewhere back there the answers stopped being fixable by you, which is the signal you overshot. Stop too early and you land on the great cop-out of incident analysis: "human error." Human error is never a stopping point — it is a doorway. A person doing the wrong thing is the beginning of a question (what made the wrong thing easy, natural, or invisible?), never the answer to one.


At Meridian Parts the warehouse label printers stopped three times in one quarter. The first two reviews each closed on "root cause: human error," because each time someone had restarted the wrong service. The third review was run by someone new, who asked what made the wrong service the natural one to restart. The server listed two services, "Print Spooler" and "Print Spooler (Labels)," and the runbook said "restart the spooler." One line in one runbook was changed, and there was no fourth time. The first two reviews had found the same cause twice, and fixed it neither time.


The working rule between those failure modes is the actionable-cause test. Stop at the last answer that names something you can realistically change, on your team, in weeks. That might be a check you can add, a procedure you can create, a default you can fix, or a document you can correct. "No recurring coverage review" passes: you can start one this month. "Parts fail" does not pass, and neither does "the company underinvests" — true, maybe, but not a work item. When a why produces an answer that fails the test, take one step back up the chain. The actionable cause is usually the rung above the philosophical one. And if a genuinely bigger cause is real — understaffing, ancient hardware — record it honestly as context feeding a budget conversation. Do not record that cause as an action item that will never close.


The four-lens sweep for contributing causes


The why-tree digs downward from the failure, and that is its blind spot. It only finds causes attached to the chain it happens to walk. Plenty of contributing causes are not on any chain — they are the surrounding conditions that made the incident bigger, longer, or harder than it had to be. To catch those, finish every analysis with a sweep of the incident timeline through four lenses, asking one question per lens:


Diagram of a why-tree growing downward from one incident: a main chain of causes with two branches, leaves marked actionable or keep-asking, and four contributing-cause lenses - detection, response, impact, recovery - feeding a combined findings list

Figure 1: The honest shape of incident analysis — a why-tree with branches and actionable leaves, plus the four-lens sweep, both feeding one findings list.


LensThe questionTypical findings
DetectionWhy was this not seen sooner?Missing checks, blunt thresholds, alerts routed nowhere useful — the gap between true start and first alert (the number your detection-time metrics track)
ResponseWhat slowed the fix once we knew?Unclear ownership, missing access or spares, misleading dashboards, outdated runbooks, single-person dependencies
ImpactWhy did it hurt this much?Missing redundancy or isolation, too many services on one box, no degraded mode, dependencies nobody had mapped
RecoveryWhat slowed the return to normal?Slow restores, untested failback, no "how do we verify it is actually fixed?" step

Run the sweep as a literal pass over the reconstructed timeline. That is the ordered, agreed sequence of events you built from monitoring data, logs, and chat (see reconstructing the timeline). Walk it four times, once per lens, jotting anything the lens catches. It feels mechanical, and that is the point: the mechanics guarantee breadth, where free-form discussion reliably fixates on whichever cause is most vivid. (Usually the one that happened last.) Ten extra minutes, and the findings list is usually noticeably longer.


From findings to priorities


A thorough tree-plus-sweep on a decent-sized incident yields six to twelve findings. Here you must resist the completionist urge. Not every contributing cause earns an action item. A review that spawns twelve actions produces twelve stalled tickets and a team that dreads reviews. Sort by leverage — which fix prevents or shrinks the most future incidents, not just a rerun of this one?


The sort has a consistent winner worth knowing in advance: findings that touch shared infrastructure of response itself. The muted alert channel did not just lengthen this outage. It silently lengthens every future incident of any kind, because every incident's first alert must survive that channel. The coverage-review gap likewise is not about one standby port. It is the reason unknown numbers of other dead things are sitting undiscovered right now. Fixes like these compound. A finding that only prevents an exact rerun ("replace this transceiver") still matters, but it is a smaller purchase. Take your top three or four by leverage into properly written action items — owner, date, verification, per action items that actually happen. Record the rest as observations in the review document, unashamed and unactioned.


The worked analysis, end to end


Here is the Tuesday outage, analyzed with the full method — main chain, two branches, four-lens sweep. It lands in a prioritized findings table of the kind your review document should end with:


#FindingFound byLeverageDisposition
1No recurring monitoring-coverage review; unknown dead spots likely elsewhereMain why-chainHigh — every future incidentAction: quarterly coverage walk
2Critical alerts share a mutable, noisy channelBranch A / detection lensHigh — every future incidentAction: separate always-loud critical route; start noise cleanup
3Runbooks not updated when topology changesBranch B / response lensMedium — every incident using a runbookAction: add "update affected runbooks" to change checklist
4Standby path unmonitored (specific ports)Main why-chainMedium — this failure classAction: add checks now (fastest fix on the list)
5File service and app on one network path — no degraded modeImpact lensMedium, costly to fixObservation → budget conversation, with this incident as evidence
6Switch power supply failedTimelineLow — already replacedClosed during incident

Read the table once more with the myth in mind. The old report said "root cause: switch failure" — item six, the least interesting line. It was the only one that was already fixed before the review started. Items one through three are where next year's quiet months are hiding, and every one of them was invisible to the single-root-cause template.


Tip: when two findings point at the same underlying condition — the muted channel and a "nobody saw the warning" from a previous review, say — you have found a pattern. Patterns outrank individual findings. Keep old review documents where you can search them. The third appearance of the same contributing cause is your system telling you, politely, where to spend real money.


The analysis kit


The whole method, compressed to a worksheet you can run in the causes segment of a 45-minute review, or alone at your desk:


  • Start from the agreed timeline, never from memory.
  • Dig: ask why from the user-visible failure. Write each answer down. Rephrase any why that lands on a person until it lands on a condition.
  • Branch: when a why has two honest answers, follow both — expect a tree, not a chain.
  • Stop each branch at the last actionable answer: something your team can change in weeks. "Human error" is a doorway; "parts fail" is a shrug; neither is a leaf.
  • Sweep the timeline through the four lenses: detection, response, impact, recovery.
  • Sort the combined findings by leverage; shared-infrastructure fixes usually win.
  • Convert the top three or four into owned, dated actions; file the rest as observations.

And here is the stopping-rules card, since the ends of chains are where analyses go wrong. Too shallow sounds like "human error," "the part broke," "it just happens sometimes" — keep asking. Too deep sounds like budgets, org charts, and the human condition — step back up one rung. Just right names a check, a procedure, a default, a document, or a design choice, and you can picture the ticket.


Where to go next


This analysis sits in the middle of the review pipeline. Upstream it needs an honest, agreed sequence of events, which is reconstructing the timeline. It needs that sequence inside a meeting where people can tell the truth, which is the blameless review. Downstream its findings are worth exactly what gets shipped, the territory of action items that actually happen. For incidents too small to deserve a full tree, the one-branch version lives inside the fifteen-minute mini-review. The full set is in Post-Incident Reviews. And if your template still has one bold field marked Root Cause, leave it in. Write "see findings table" in it.


Put this into practice with SysPeep Monitor

Half the findings in a good cause analysis turn out to be monitoring findings — the unmonitored standby, the alert nobody saw. SysPeep Monitor auto-discovers devices and interfaces on your network (including the ones set up before your time). Its threshold and dependency rules are built to keep the critical alert loud while the noise stays down. The free trial installs in minutes on a Windows machine.

Download Free TrialLearn About SysPeep