Home › Topics › Post-Incident Reviews › Blameless Reviews

Blameless Reviews That Actually Change Things


The service is back and the adrenaline is wearing off. Somewhere in the building a question is forming, and it is not "what do we change?" It is whose fault was that? How your team answers it decides whether next month is quieter than this one. A post-incident review is the short meeting where you work out what happened and what to change. On a team of one, it is the short document. It exists for one purpose: fewer, shorter, smaller incidents. The biggest threat to that purpose is blame.


That is not a soft claim about feelings. It is a hard claim about data. A review that can punish people gets fed a tidied version of events. And a tidied version produces fixes for problems you do not have. I know this from both chairs. I have been the person whose change caused the outage, and I have run the meeting afterwards. And the true account only turns up in a room where it is safe to give.


This guide covers the mechanics: why blame corrupts the facts, the question to ask instead, and how to run a blameless review. It is for a team of three to eight, with the 45-minute agenda, the language rules, and the facilitator moves. It also covers the written version for the solo admin. None of it needs a big company, a full-time process person, or anyone saying the word "synergy."


In this guide

  • What a review is actually for
  • Why blame hides the causes
  • The master question
  • Blameless does not mean consequence-free
  • The 45-minute meeting, step by step
  • The solo version
  • The first admission: where the culture is decided
  • The written record
  • The meeting kit

What a review is actually for


A post-incident review is not a trial, not compliance paperwork, and not group therapy — though a bad one can feel like all three at once. Its output is a short list of concrete changes that make a similar incident less likely to happen, faster to detect, or smaller when it lands. Examples include a monitoring check added, a threshold corrected, a runbook step fixed, or a confusing device name changed. The meeting is just the machine that produces that list from the raw material of what happened.


The test of a good review is simple: two weeks later, is something about your systems measurably different? If the honest answer is "we talked about it," the review consumed an hour and produced a feeling. There is a blunter test too. The same incident happening twice, for the same reason, means your review process is broken, whatever it felt like in the room.


Keeping that purpose in view is what makes the blameless part make sense. You are not being kind for kindness's sake. You are protecting the accuracy of the only raw material the review has: honest accounts of what people actually saw, thought, and did. Kind is a side effect. Accurate is the point.


Why blame hides the causes


Inside a review that can punish, every person in the room quietly runs the same calculation before they speak: how does this sentence make me look? And then they edit. Not usually by lying outright — most people will not invent facts — but by sanding off the details that matter most. The timeline gets sanitized. "I made a config change at 2:10 and did not think it was related" becomes "we investigated several possibilities." The moment someone saw an early warning and dismissed it goes unmentioned, because mentioning it invites the question "why did you ignore it?" The five minutes spent on a wrong guess get compressed to nothing.


Each individual edit is small and understandable. Added together, they destroy the one thing the review needs: the real sequence of events. And the real sequence is where the causes live. If the config change never makes it into the timeline, nobody asks why the change was so easy to get wrong. In that case, nothing gets fixed. The incident closes with a vague cause, a vague action, and a room full of people relieved it is over.


Then, a few months later, the same incident returns wearing a different hostname. It is a different device, a different service, with the same underlying cause nobody was allowed to find. The insidious part is that you will not connect the two, because the first review's record is fiction. Blame does not just make reviews unpleasant. It makes them useless, while leaving everyone with the warm sense that "we did a review."


At Harbourview Clinic the records server lost its storage for two hours after a firmware update went to both array controllers at once. The review had a chair for the manager, a chair for the person who ran the update, and a projector. Its one action item was "be more careful with updates," with no owner and no date. Nobody mentioned that the update page defaulted to "both controllers" or that the runbook did not say to change it. Five months later a different person applied the same update to both controllers, and was also asked to be more careful. The second review found the default in ten minutes, once it was allowed to look.


The master question


The alternative to blame is not pretending nobody made a mistake. Somebody usually did — typed the wrong command, applied the change to the wrong switch, misread the graph. The alternative is a different theory about what a mistake means. Here is the insight that underpins every blameless review: the person who made the error was almost always acting sensibly given what they knew, what they could see, and the pressure they were under at that moment. They did not choose the wrong switch out of carelessness. They chose it because it was named almost identically to the right one. The terminal prompt looked the same on both, and the runbook said "the core switch" without saying which one. Anyone reasonable, standing in the same spot with the same information, had a good chance of doing the same thing.


That reframing matters because of what it makes fixable. You cannot patch a human. You can, however, rename the switches so they are impossible to confuse. You can make the prompt show the device name in red on production gear and rewrite the ambiguous runbook step. Runbooks are the written procedures your team follows under stress, and one of the most common places these traps hide. The Runbooks guides cover keeping them honest. The bad default, the missing guardrail, the lookalike name, the unclear document: these are the systems that made the error easy. Systems accept patches gracefully.


All of this compresses into one question, the master question of the whole discipline: "why did the system let a reasonable person do this?" Ask it every time human error appears in a review. It converts "Bob broke it" — a dead end, unless your action item is "get a better Bob" — into a list of specific, buildable defenses. It is also a question people will help you answer honestly, because it is not aimed at them.


Blameless does not mean consequence-free


A skeptic on your team, possibly your manager, will raise an objection that deserves a straight answer: "so nobody is ever accountable for anything?" No. Blameless means the review examines systems, not people. It does not mean the organization has no way to deal with genuinely bad behavior.


State the boundary out loud, because that is what makes blameless credible instead of naive. An honest mistake made while trying to do the job — even a big one, even an embarrassing one — is system data, full stop. But a pattern of recklessness is different. That could be someone repeatedly skipping agreed process after it has been made clear and easy to follow. That, or anything done in bad faith, is a management matter, handled by a manager, elsewhere, on a different day. The review room does not do discipline, and the disciplinary process does not mine review notes for ammunition. Two separate channels, and the second one is rarely needed.


When you introduce blameless reviews, say exactly that. People trust a rule that admits its own edges. A team told "nothing bad can ever happen to anyone" hears wishful thinking and stays guarded. A team told "this meeting studies systems; genuine misconduct is a different conversation that will never be held in this room" can relax, because the deal is honest.


The 45-minute meeting, step by step


Everything above is culture. Here is the mechanism, sized for a three-to-eight-person shop. Hold the review within a week of the incident, while memories are still attached to reality. Human memory does not just fade; it quietly rewrites itself. After two weeks you are reviewing a legend. Invite everyone who touched the incident plus whoever owns the affected systems. Book 45 minutes, and name a facilitator — the person who runs the agenda and enforces the language rules. Ideally the facilitator is not the most senior person in the room, and the role rotates.


MinutesSegmentWhat happens
0–5Ground rulesFacilitator restates the purpose (a quieter next month) and the blameless rule, every single time — even when everyone has heard it before.
5–20Timeline walkThe group walks the assembled timeline start to finish, fixing errors and filling gaps. Facts only; no "why" allowed yet.
20–25What went wellThe things that worked, named explicitly so they are kept.
25–38Contributing causesThe why-hunt: what conditions and decisions let this happen, and what made it as big as it was.
38–45ActionsConvert the top causes into small, owned, dated action items. Stop at a handful.

The timeline walk comes first for a reason. Disagreements about what happened must be settled before anyone argues about why. Otherwise the meeting dissolves into competing recollections. Build the timeline before the meeting from monitoring data, logs, and chat history. The task of reconstructing the timeline is its own craft and its own guide. The causes segment likewise has real technique behind it, covered in contributing causes and the five whys. And the actions segment lives or dies by the writing discipline in action items that actually happen.


A word for the segment everyone skips: what went well. It feels like a participation trophy, so teams cut it. Keep it. When the failover worked, when the runbook held, when the backup restored on the first try — those are load-bearing behaviors. Behaviors that go unnamed get optimized away by the next budget or the next reorg. Naming them also changes the room's chemistry: a meeting that starts by acknowledging competence makes admitting problems easier five minutes later.


Language rules

Grammar shapes the room more than intentions do. The core rule: describe events by what happened to the system, not who did it. "The change was applied to the standby switch" rather than "Bob applied the change to the standby switch." This is not about hiding who did what. Everyone knows, and the timeline can record it. It is about keeping every sentence pointed at the mechanism instead of the person. It feels stilted for the first two meetings and automatic afterward.


The facilitator redirect

Blame will surface anyway; it is a reflex. Someone will say "well, if Sam had checked the interface first…" The facilitator's job is a single, calm redirect: "what made that the natural thing to do at the time?" Not as a rebuke — as a genuine question. Nine times out of ten the answer surfaces a system fact ("the dashboard shows the old interface names") that goes straight onto the causes list. The redirect converts blame into evidence, live, in front of everyone, which teaches the technique better than any policy document.


The person most involved speaks first

Whoever was closest to the incident gets the floor first, uninterrupted, to tell the story as they experienced it. That is often the person who made the key mistake. Frame it as the privilege it is: they hold the best data in the room. Going first means their account shapes the review, instead of the review constructing a story around a silent, shrinking participant. It is the single strongest structural signal that the blameless rule is real.


Tip: if the meeting keeps running long, you are trying to fix too much per incident. Take the top two or three causes to actions and write the rest down as observations. A review that reliably ends on time keeps getting scheduled; a 90-minute marathon quietly stops happening — and then no review happens at all.


The solo version


If you are the whole IT department, you do not get a meeting. But in that case, you need the review more, because nobody else will ever ask you the questions. The solo version is a written self-review with the identical structure: timeline, what went well, contributing causes, actions. Thirty minutes, within a day or two, into the same template you would use for a team review. Attendance is usually good.


Writing it down is the whole trick, because a solo admin's memory runs two failure modes at once. The first is the self-blame spiral: "I'm an idiot, I should have caught that" — which feels like accountability and is exactly as useless as blaming Bob. The second is the self-excuse shrug: "weird one-off, whatever" — which files the lesson in the bin. The template counteracts both, because it does not accept "I'm an idiot" as a cause. It keeps asking what made the mistake easy. The master question works just as well when the reasonable person is you. Rename your own confusing switches. Fix your own ambiguous runbook. Future-you is a colleague worth protecting.


The first admission: where the culture is decided


You can announce blameless reviews in a team meeting, put the rules on a wiki page, and mean every word. None of it will matter, because the culture is not decided by the announcement. It is decided the first time the rule gets tested. And it will be tested in a specific way. At some review in the first month or two, someone will take a breath and admit a real mistake. "I pushed that change without testing it. That is what started this." I have been that someone. The breath is longer than you would think.


What happens in the next thirty seconds defines your review culture for years, and the most senior person's reaction decides it. If the response is curiosity — "okay, thank you, that is exactly what we needed to know; what made the untested push the easy path?" — then honesty just visibly paid. In that case, the next review will be more honest still. If the response is a sigh, a joke with an edge, a raised eyebrow, or the mistake surfacing later in a performance conversation, blameless is dead in your shop. Not weakened: dead. Everyone in the room just learned the real rule, and no policy page will ever overwrite what they watched happen.


The follow-through matters as much as the moment. When an honest admission leads to a visible system fix, you complete the proof. For example, the guardrail is added or the runbook corrected. The fix is announced as plainly as "because we knew exactly what happened, we found the trap and removed it." That proves telling the truth here produces improvement, not punishment. A couple of cycles of that and the pre-editing stops, and you start hearing timelines as they actually happened. That is the asset everything else in this pillar is built on.


The written record


Every review, meeting or solo, ends as a short document — one or two pages, plain text or a wiki page, filed with the incident. Not for bureaucracy: an unwritten review evaporates within a month, actions and all. The shape that works:


INCIDENT REVIEW — <short name>
Date of incident / date of review:
Duration and user impact:            (what broke, for whom, for how long)
Severity:

TIMELINE        one line per event, timestamped, from first cause
                to verified fix
WHAT WENT WELL  the defenses and habits that worked
CAUSES          contributing causes found, most important first
ACTIONS         each: verb + owner + date  (tracked in the ticket
                system, linked here)
LESSONS         anything true beyond this incident

The record earns its keep twice more. Filed alongside your availability numbers, it becomes the story behind the statistics. The uptime evidence file turns "we had 99.7% this quarter" into "and here is what caused the 0.3%, and what we changed." That is the version budget conversations respond to. And a stack of past reviews is the best onboarding document your team will ever accidentally write. A new hire who reads the last six learns where the traps are faster than any network diagram can teach them. For small incidents that do not justify this full treatment, there is a lighter form — the fifteen-minute mini-review — so the lessons still get caught.


The meeting kit


Everything above, condensed into two cards you can keep open during the meeting. First, the language card — the swaps that keep sentences pointed at systems:


Instead ofSay
"Who did this?""What happened next?"
"Bob applied the wrong config""The config was applied to the standby switch"
"Why didn't you check first?""What did the system show at that point?"
"That was careless""What made that the natural thing to do?"
"Human error""Which trap did the system set, and how do we remove it?"

Second, the facilitator card — the situations that recur and the move for each:


When…The facilitator…
The meeting opensRestates purpose and the blameless rule, every time
"Why" starts during the timeline walkParks it: "hold that for causes — are the facts right so far?"
Blame surfacesRedirects: "what made that the natural thing to do?"
Someone admits a mistakeThanks them, out loud, and mines the admission for system causes
One voice dominatesInvites the person most involved, or the quietest, by name
Ten minutes remainCuts to actions no matter where the discussion is

Where to go next


Blameless is the operating system, and the other guides are the applications that run on it. Before the meeting you need an honest sequence of events; reconstructing the timeline from monitoring data shows how to build one. During it you need the cause-hunt done properly, which is the five whys and contributing causes. Afterwards the whole exercise is worth exactly what your action items deliver. The rest of the Post-Incident Reviews guides take each piece in turn. Get this one right and nobody in the building asks whose fault it was.


Put this into practice with SysPeep Monitor

A blameless review runs on facts, and the facts live in your monitoring history. SysPeep Monitor keeps alert timestamps, performance graphs, and device status history. Those let a timeline be reconstructed from evidence instead of memory. Its dashboards make the "what did the system show at that point?" question answerable. The free trial installs on any Windows machine in minutes.

Download Free TrialLearn About SysPeep