Skip to content

Incident Response

Incidents happen. The most reliable thing about complex software systems is that they will fail in ways the team did not anticipate. Operational maturity is measured less by pretending incidents can be eliminated and more by how quickly, safely, and learnably the organization can respond when they happen.1

A well-run incident response is a discipline, not an improvisation. It has roles, sequences, communication patterns, and follow-through. Teams that develop the discipline recover faster, reduce customer impact, and turn each incident into structural improvement. Teams that do not pay both the recovery cost and the cost of having to learn the same lesson again.

The Lifecycle

A typical incident moves through six stages:

  • Detection. The team becomes aware that something is wrong. The best detection is automated and fast (alerts on user-visible symptoms, anomaly detection on key metrics). The worst is a customer report after the problem has been live for hours.
  • Triage. A quick assessment of scope, severity, and who needs to be involved. Triage answers: is this a real incident? How big? Who needs to know? Who should be doing what?
  • Mitigation. Stopping the bleeding. This often comes before root cause analysis. Flipping a feature flag, rolling back, scaling up, failing over: the goal is to restore service, then investigate.
  • Communication. Internal and external updates while the incident is in progress. Status pages, incident channels, customer notifications, executive briefings. Lack of communication during an incident is one of the most reliable ways to make it worse.
  • Root cause analysis. Once the immediate impact is contained, the team investigates why the incident happened. Not "who," but "what about the system permitted this."
  • Follow-up improvement. The structural changes that come out of the analysis, with owners, dates, and tracking. An incident without follow-up is an incident that will recur.

The stages are not strictly sequential. Communication runs throughout. Root cause analysis often begins in parallel with mitigation. The pattern is more important than the order.

Roles

In any non-trivial incident, distinct roles help the response stay coordinated:

  • Incident commander. The person making decisions about the response. Not necessarily the most senior person in the room; often the person closest to the problem with the authority to call the shots. Coordinates the response, decides on mitigation steps, decides when to declare the incident resolved.
  • Communications lead. Keeps internal and external stakeholders informed. Writes the status page updates, the customer-facing notes, the executive summary. Frees the technical responders from the communication burden.
  • Scribe. Documents the timeline as it happens. Decisions made, actions taken, signals observed. This record is the basis for the postmortem; reconstructing it after the fact is much harder than recording it in the moment.
  • Subject matter experts. The engineers who actually understand the system in question. Brought in by the commander as needed.

Smaller incidents may have one person playing several of these roles. The point of naming them is that the responsibilities are explicit, not that every incident needs four people.

Blameless Postmortems

The discipline that turns incidents from costs into investments is the blameless postmortem.1 The investigation looks for what about the system allowed the incident to occur, not who to blame for letting it happen.

The argument for blamelessness is not soft. It is structural. In a blame culture:

  • Engineers hide mistakes rather than report them.
  • Near-misses go undocumented because nobody wants to be the one who reported one.
  • Root cause analysis stops at "human error" because finding a human to point at ends the investigation.
  • The same incident recurs because the underlying system was never examined.

In a blameless culture, the engineer who made a mistake is treated as a witness, not as a defendant. Their description of what they were trying to do, what they saw, and what they thought is treated as a reliable signal about how the system actually behaves. Most production incidents have the same shape: a competent engineer doing reasonable things ended up in a state nobody predicted. The fix is rarely "be more careful." It is almost always a change to the system that made the dangerous state possible.2

Common Anti-Patterns

  • No declared incidents. Problems that should be handled as incidents are instead handled as "things to look at later." Without declaration, there is no coordination, no communication, and no investigation.
  • Detection by customer report. The first signal of an outage is a tweet or a support escalation. Investment in detection consistently produces the fastest payback in operational work.
  • Heroic recovery, no follow-up. The incident is resolved through individual effort, the team moves on, and the underlying cause is never addressed. The pattern guarantees a repeat.
  • Postmortem theatre. Postmortems happen, action items are listed, nothing changes. The investigation was for the documents, not for the system.
  • Optimizing the wrong metric. A team measured on "incidents per month" eventually has fewer declared incidents and the same number of actual problems. The metrics that matter are mean time to detect, mean time to mitigate, and the rate of recurring categories.

What This Looks Like in Practice

  • Define what counts as an incident. A written threshold (customer impact, duration, severity) tells the team when to escalate. Without one, the decision is ad hoc.
  • Practice the response. Game days, chaos engineering exercises, and tabletop incident drills build the muscle for real incidents. The first time the team uses the incident process should not be the day the production database falls over.
  • Mitigate before you investigate. Restore service first, understand the root cause second. The investigation is much easier with a stable system.
  • Run postmortems blamelessly and write them down. Format matters less than the discipline of doing them and the record they produce.
  • Track follow-up to completion. Action items from postmortems should be tracked in the team's normal work system, with owners and target dates. Untracked actions become untaken actions.
  • Build the team's pattern library. Each incident, properly understood, teaches the team something about how the system behaves. A culture that captures and shares those lessons gets better incrementally; one that does not learns the same lesson repeatedly.

Key principle

Recovery capability is a core quality attribute. A system that recovers quickly and gracefully from problems is a more reliable system than one that almost never fails but cannot recover when it does. The discipline of incident response is what turns incidents from costs into improvements.

See also: Observability, Continuous Improvement, Fix Forward, Deployment Strategies, Support and Triage, Release Coordination.



  1. Betsy Beyer, Chris Jones, Jennifer Petoff, and Niall Richard Murphy (eds.), Site Reliability Engineering: How Google Runs Production Systems (O'Reilly, 2016), and the companion Site Reliability Workbook (O'Reilly, 2018). The canonical articulation of modern incident response, including the case for blameless postmortems, the roles in an incident response, and the discipline of treating reliability as a quantitative engineering target rather than a goal of perfection. 

  2. Richard I. Cook, How Complex Systems Fail (1998), a short paper from the Cognitive Technologies Laboratory at the University of Chicago. The foundational text for the resilience-engineering view of incident analysis. Argues that "human error" is a label that ends investigations rather than explains anything, that complex systems run as constantly broken systems whose ongoing operation depends on continuous adaptation by the humans inside them, and that practitioners' actions are the proximate cause of accidents only in the trivial sense that someone has to be doing the work when the system fails. John Allspaw's writing brought the paper into mainstream software-engineering practice.