Blameless postmortem template (based on Google SRE)
A free blameless postmortem template based on Google's SRE book: every section explained, a filled-in example, blameless wording, and how to follow up.
The payments service went down for 40 minutes on a Friday. By Monday there are three Slack threads with three different explanations, one engineer who thinks it was their fault, and no ticket for the fix everyone agreed on. Two months later, it happens again.
A postmortem turns an incident into something the team keeps. This template follows the example in Google's SRE book and its chapter on postmortem culture, checked on 16 November 2026.
What makes it blameless
The SRE book defines a blameless postmortem as one that identifies contributing causes without indicting any person or team. It assumes everyone acted with good intentions on the information they had. The reason is practical: if people expect blame, they stop reporting problems.
In writing, that means describing actions and conditions, not people:
| Blaming | Blameless |
|---|---|
| Sam forgot to run the migration check | The deploy ran without the migration check; the runbook didn't require it |
| QA missed the bug | The test suite had no case for an empty cart |
| On-call was slow to respond | The alert went to email, not the pager, so it was seen 25 minutes later |
The blameless version also points to the fix.
When to write one
Agree on triggers before you need them. The SRE book's common ones:
- User-visible downtime or degradation beyond a threshold
- Data loss of any kind
- On-call intervention, such as a rollback or rerouting traffic
- Resolution time beyond a threshold
- A monitoring failure, usually meaning someone found the incident by hand
Anyone can also ask for a postmortem.
The template
Paste into Google Docs, Confluence, Notion, or a markdown file:
# [Incident title] postmortem (incident #[number])
| | |
|---|---|
| Date | [Date of incident] |
| Authors | [Names] |
| Status | Draft / In review / Complete, action items in progress |
## Summary
[One or two sentences: what broke, for how long, and why it mattered.]
## Impact
[Who and what was affected, in numbers: users, requests, revenue, data.]
## Root causes
[The underlying conditions that made the incident possible.]
## Trigger
[What set it off.]
## Resolution
[What stopped the impact, and what fixed the cause.]
## Detection
[How we found out. If a person noticed first, say so.]
## Action items
| Action item | Type | Owner | Ticket | Status |
|---|---|---|---|---|
| [Action] | mitigate / prevent / process | [Name] | [Link] | TODO |
## Lessons learned
### What went well
-
### What went wrong
-
### Where we got lucky
-
## Timeline
| Time (UTC) | Event |
|---|---|
| [hh:mm] | [What happened or what someone did] |
## Supporting information
[Links to dashboards, graphs, logs, and chat threads.]
How to fill in each section
Summary. Written last, read first. Someone skimming the incident repository should understand it from this alone.
Impact. Numbers, not adjectives. "2,300 checkout attempts failed" beats "significant impact."
Root causes and trigger. Keep them separate. The trigger is what set it off, such as a traffic spike; root causes are why the system couldn't cope, such as a resource leak. Fixing only the trigger leaves the next one waiting.
Detection. Often the most useful section. If customers told you before monitoring did, that's an action item.
Action items. Google's example tags each as mitigate, prevent, or process, with an owner and a bug. An action without an owner and a ticket won't happen.
Where we got lucky. Things that limited the damage by chance. Each is a risk you haven't fixed yet.
Timeline. Times in one timezone, with what was known at each point. It shows where minutes were lost.
A filled-in example
# Checkout outage postmortem (incident #212)
| | |
|---|---|
| Date | 2026-10-09 |
| Authors | Arjun, Mei |
| Status | Complete, action items in progress |
## Summary
Checkout failed for 41 minutes after a database migration locked the
orders table during peak traffic.
## Impact
2,300 failed checkout attempts; about 1,100 customers affected.
No data lost. Estimated revenue delayed, not lost: most retried.
## Root causes
The migration added an index without CONCURRENTLY, taking a lock on
the orders table. The deploy pipeline doesn't check migrations for
locking operations.
## Trigger
Routine deploy at 17:02 UTC, during the evening peak.
## Resolution
Cancelled the migration at 17:38; checkout recovered by 17:43.
Re-ran the index build concurrently at 22:00.
## Detection
Support saw customer reports at 17:15 before the error-rate alert
fired at 17:19, because the alert threshold was 10%.
## Action items
| Action item | Type | Owner | Ticket | Status |
|---|---|---|---|---|
| Lint migrations for locking operations in CI | prevent | Arjun | ENG-881 | TODO |
| Lower checkout error alert to 2% | mitigate | Mei | ENG-882 | DONE |
| No schema deploys 16:00 to 20:00 UTC | process | Priya | ENG-883 | DONE |
## Lessons learned
### What went well
- Cancelling the migration restored service in 5 minutes.
### What went wrong
- Customers noticed before our alerting did.
### Where we got lucky
- The lock hit orders, not payments; card holds would have needed refunds.
After you write it
The SRE book's best practice: no postmortem left unreviewed. Have senior engineers check that the data is complete, the root cause goes deep enough, and the action items fit. Then share it widely and add it to a searchable collection of past incidents.
Then track the action items like any other work. A postmortem whose actions sit at TODO for three months is a record of a problem you still have.
The decisions inside a postmortem
Some action items are really decisions: "no schema deploys during peak hours," "all migrations must be concurrent." Those need to reach everyone making the next change, including AI coding agents writing migrations, not only the people who read the postmortem.
Where Lockstep fits
Lockstep turns those decisions into approved team records. It captures decisions from documents, Slack, and pull requests, routes each to its owner for approval, and briefs Claude Code sessions on the ones that apply, so the next migration an agent writes uses CONCURRENTLY because the team decided it should.
See how it works.
Sources checked 16 November 2026
Related reading
For recording technical decisions, see architecture decision record examples. For the wider decision record, see the decision log template. For regular team reviews, see the retrospective template. For the procedures on-call engineers follow, see the runbook template. For handling incidents as they happen, see the incident response plan template.
Frequently asked questions
- What is a blameless postmortem?
- A written record of an incident that focuses on the contributing causes without indicting any person or team. Google's SRE book says a blameless postmortem assumes everyone involved had good intentions and did the right thing with the information they had, because blame makes people hide problems.
- What should a postmortem template include?
- Google's example uses: summary, impact, root causes, trigger, resolution, detection, action items with type, owner, and ticket, lessons learned (what went well, what went wrong, where we got lucky), a timeline, and supporting information.
- When should a team write a postmortem?
- Google's SRE book lists common triggers: user-visible downtime or degradation past a threshold, any data loss, on-call intervention such as a rollback, resolution time past a threshold, and monitoring failures. Agree on the triggers before incidents happen; anyone can also request one.
- How do I write a postmortem without blaming someone?
- Describe actions and the information available at the time, not people's character. Write 'the deploy ran without the migration check, which the runbook did not require' rather than 'Sam forgot the migration check'. Then ask why the system allowed it.
- What happens after a postmortem is written?
- It's reviewed, ideally by senior engineers, for completeness, depth of root cause, and appropriate action items. Then it's shared widely and stored with past incidents. Google's SRE book puts it bluntly: an unreviewed postmortem might as well never have existed.
Keep reading