An incident postmortem template is a short, fixed structure for writing down what broke, who was affected, what happened minute by minute, why it happened, and what you will change. The one below fits on two pages, assumes a blameless review, and ends in a small number of action items with named owners. Copy it, trim it to your team, and use it for the next incident that earns one.
Most templates fail in one of two ways. They are so long that nobody finishes them, or so loose that they become a story instead of a record. This one is built to avoid both.
TL;DR
- Write a postmortem for every customer-facing outage, data loss event or incident that needed an on-call intervention. Skip the ones that teach nothing.
- Keep the document to about two pages: summary, impact, timeline, root cause, contributing factors, action items.
- Build the timeline from logs, alerts and deploy records, not from memory.
- Limit yourself to a few action items, each with one owner and a due date.
- Review the document in a short meeting, then track the actions like any other engineering work.
Table of Contents
- When an incident deserves a postmortem
- The template
- Summary
- Impact
- Detection
- Timeline (UTC)
- Root cause
- Contributing factors
- What went well
- What went poorly
- Where we got lucky
- Action items
- Lessons learned
- How to fill in each section
- Running a blameless review
- Keeping postmortems short enough to read
- Our perspective: fix the alert before you fix the document
- Postmortem or post incident review?
- Where monitoring data fits in
- FAQ
- Sources
When an incident deserves a postmortem
Not every blip needs a document. Google’s SRE book lists the triggers it uses: user-visible downtime or degradation past a threshold, data loss of any kind, an on-call engineer having to intervene (a rollback or rerouting traffic), a long resolution time, and a monitoring failure, which usually means someone found the problem by hand.
A practical version for a small team:
- Any SEV-1 or SEV-2 incident.
- Any customer-facing outage longer than 15 minutes. That cutoff comes from one published postmortem template; pick your own number and write it down.
- Any security event or data loss, regardless of duration.
- Any incident your customers told you about before your monitoring did.
That last trigger matters more than it looks. If a customer noticed first, the postmortem has a built-in question about detection, and the answer often changes your alerting more than it changes your code.
The template
Paste this into your wiki, repo or docs tool. Every heading earns its place; delete the ones that do not fit your team rather than leaving them empty.
# Postmortem: [short, plain description of the failure]
**Incident ID:**
**Date:**
**Severity:** SEV-1 / SEV-2 / SEV-3
**Author(s):**
**Incident commander:**
**Status:** Draft / In review / Complete, actions in progress
## Summary
Two or three sentences. What broke, for whom, for how long, and how it was fixed.
## Impact
- Customers or requests affected (count or percentage):
- Duration of customer-visible impact:
- Revenue, SLA or support impact, if known:
- Data lost or corrupted: none / describe
## Detection
How did we find out? Alert, customer report, or a person looking at a dashboard?
Time from start of impact to first alert:
Time from first alert to acknowledgment:
## Timeline (UTC)
| Time | Event | Source |
|------|-------|--------|
| 14:02 | Deploy of build 4812 begins | CI/CD log |
| 14:09 | First failed health check from EU Central | Monitoring |
| 14:11 | Incident opened, on-call paged | Alerting |
| 14:15 | On-call acknowledges | Pager |
| 14:31 | Rollback started | Deploy log |
| 14:36 | Checks recovering in all regions | Monitoring |
| 14:44 | Incident resolved | Incident tool |
## Root cause
The technical chain of events. Use 5 Whys until you reach something you can change.
## Contributing factors
Conditions that made it worse or let it through: missing test, noisy alerts,
unclear runbook, a dependency with no timeout.
## What went well
## What went poorly
## Where we got lucky
## Action items
| # | Action | Type | Owner | Due | Ticket |
|---|--------|------|-------|-----|--------|
| 1 | | Prevent / Improve / Process / Architect | | | |
## Lessons learned
One or two sentences someone could repeat to a new hire.
How to fill in each section
Summary and impact
Write the summary last, even though it sits first. Someone in finance or customer support should be able to read only this paragraph and know what happened. Name the system in plain words, give the duration, and say whether customers were affected.
For impact, use numbers you can defend. “About 8% of API requests returned 5xx for 27 minutes” beats “significant degradation.” If you do not know yet, write “unknown” and add an action item to find out. Google’s published example postmortem is a good model for how compact this can be: a one-line summary, a quantified impact, a root cause, a trigger and a resolution before the detail begins.
Detection
This section is the one teams skip, and it is where monitoring improvements come from. Record when impact began (from logs or metrics, not from when someone noticed), when the first alert fired, and when a human acknowledged it. The gaps between those three times tell you whether your problem is detection, alerting or response.

One published write-up claims that 69% of major incidents lack proper alerting, with detection times stretching far longer in organizations without standardized alerting. Treat the figure as a rough signal, not a benchmark, but the direction matches what most on-call engineers see: slow detection is common and fixable.
Timeline
A good timeline is boring. Each row has a UTC timestamp, one event and a source. Pull entries from deploy logs, alert history, chat transcripts and monitoring data. Avoid rows like “team realized the cache was the problem,” which are interpretation, not events.
Practitioners sometimes call this incident archaeology: dig up concrete artifacts such as log timestamps and metric spikes, rather than reconstructing events from what people think they remember. A USENIX SRE talk on the subject lists the same basics: time of detection, start and end times, and a written timeline.
If your monitoring stores check history per region, include it. Seeing that one region failed at 14:09 and the others at 14:12 tells you more than “the site was down.”
An incident timeline example
Here is a short fictional one, to show the level of detail to aim for. It is invented for illustration, not a real customer incident.
| Time (UTC) | Event | Source |
|---|---|---|
| 09:58 | Config change merged: connection pool max reduced from 50 to 5 | Git history |
| 10:03 | Change deployed to production | CI/CD log |
| 10:06 | p95 latency on /checkout rises from 300 ms to 4 s |
Metrics |
| 10:08 | Three consecutive failed checks, second region confirms | Monitoring |
| 10:08 | Incident opened, on-call paged | Alerting |
| 10:12 | On-call acknowledges, begins checking recent deploys | Pager |
| 10:19 | Config change identified as suspect | Chat log |
| 10:23 | Revert deployed | CI/CD log |
| 10:27 | Checks green in all regions, incident resolved | Monitoring |
Every row can be verified by someone who was not there. That is the standard.
Root cause and contributing factors
Ask “why” until you reach a condition you can change. In the example: why did checkout slow down? The pool was too small. Why was it merged? The value was a typo in a review of a 400-line file. Why did it reach production? There is no load test in the pipeline. The last answer is the useful one.
Keep the root cause to a few sentences and move everything else into contributing factors. Real incidents rarely have a single cause. For a step-by-step method to check your reasoning before you write it down, see our guide to root cause analysis.
What went well, what went poorly, where we got lucky
Three short lists. “Where we got lucky” is the most valuable: the incident happened at a quiet hour, or the one person who knew the system happened to be online. Luck is a risk you have not mitigated.
Action items
This is where postmortems succeed or die. Guidance from the same template source suggests no more than three impactful action items per incident, sorted into four types:
- Prevent: stop this exact failure from happening again.
- Improve: detect it faster or limit the blast radius.
- Process: change how people work or hand off.
- Architect: a larger structural fix that needs planning.
Each item gets one owner, a due date and a ticket in the tracker your team already uses. An action item that lives only in a document is a wish.
Running a blameless review
Blameless does not mean nobody is accountable. It means the question changes from “who caused this?” to “what conditions allowed this?” Google’s SRE book frames it directly: writing a postmortem is not punishment but a learning opportunity for the whole company.
In practice, that shows up in small habits:
- Write “the deploy pipeline allowed an unreviewed config change,” not “Sam pushed a bad config.”
- Refer to roles (on-call engineer, incident commander) instead of names where you can.
- Ask the person closest to the failure to explain their reasoning at the time. Decisions usually made sense with the information they had.
- Do not let the review turn into a debate about severity labels.
A 30 to 45 minute meeting is enough. Read the timeline together, correct it, agree on contributing factors, and pick the action items. Anything that needs longer goes into a ticket.
Keeping postmortems short enough to read
Postmortem fatigue is real. When documents balloon to ten pages, nobody reads them and the exercise turns into box-ticking. Aim for two pages. If a section has nothing to say, write one line and move on.
Two checks help:
- Time to postmortem. One source suggests finishing within five business days for major incidents, while memory and logs are fresh.
- Action item completion. The same source proposes completing over 85% of actions within 30 days. If items keep going overdue, the same guidance reads this as a sign that incident follow-up is disconnected from your team’s real capacity. Plan the work into sprints, or stop promising it.
Be careful with metrics inside the document. MTTR and MTTD are useful for trends, but a five-minute rollback and a two-hour data corruption event are not comparable. Our piece on mean time to recovery shows how one outage can produce three different MTTR numbers, and incident reporting metrics covers what to track across incidents.
Our perspective: fix the alert before you fix the document
We build uptime monitoring, so we read a lot of incident timelines. The pattern that stands out is that the first rows of the timeline are often the weakest. Either detection was late, or the alert fired for something that was not an incident, and the on-call engineer spent the first ten minutes deciding whether to trust it.
That is why Uptime Beacon opens an incident only after several failures in a row, and on paid plans confirms the failure from a second location. A network blip between one probe and your server should not become a page at 3 a.m., and it should not become a row in your postmortem either. Cleaner alerts make cleaner timelines.
The second thing we see is that writing the timeline is tedious, and tedium is why postmortems slip. Check history by region is exactly the raw material you need. With Uptime Beacon, an AI assistant connected over MCP can read monitors, incidents and check history and walk through a failing monitor region by region, which gives you a factual first draft of the detection and timeline sections. It reads; it does not decide. A human still owns the root cause and the action items, and nothing can be deleted over MCP.
Our founders have spent more than 30 years combined running production in banking, fintech, telecom and SaaS. The lesson that stuck is simple: the best postmortem is the one that changes something by next Friday.
— Aaditya Parashar
Postmortem or post incident review?
The names are interchangeable in most teams. “Post incident review” is common in ITSM and Atlassian-style tooling, while “postmortem” is the term in SRE and engineering circles. Atlassian publishes both an incident postmortem template and an ITSM post incident review template, and the structure is much the same as the one above: background, timeline, causes, follow-ups.
Pick one term, put it in your process doc, and use it consistently. What matters is that the review happens and its actions get done.
Where monitoring data fits in
A postmortem is only as good as the data behind its timeline. Before the next incident, check that you can answer these questions from your tools:
- When did the first check fail, and from which region?
- When did the alert fire, and who received it?
- When was the incident acknowledged, and by whom?
- When did checks recover, and in which order across regions?
- Which certificate, domain or scheduled job was involved?
If your monitoring cannot answer them, that is your first action item. For a wider view of the response side, our incident response playbook covers a first-hour checklist, and AI incident response for on-call teams explains confirming at two locations before paging.
If you want to try this on a real service, the Free plan at Uptime Beacon costs €0 per month with no card: 5 monitors checked every 5 minutes from EU Central, one alert channel (email or Slack) and one status page. MCP access for AI assistants is included on every plan, Free too. Starter is €14.99 per month, Pro €39.99 and Business €89.99, and maintenance windows come with Starter and above. Results are stored in the EU. SaaS teams running APIs and cron jobs can start from our SaaS use case page.

FAQ
How long should an incident postmortem be?
About two pages. Long enough to hold a summary, impact, a sourced timeline, root cause and a few owned action items, short enough that people read it. If a document keeps growing, move supporting detail into linked appendices.
Who should write the postmortem?
Usually the incident commander or the engineer closest to the affected service, with input from everyone who responded. Google’s example postmortem lists several authors, so shared writing is normal. The goal is an accurate record, not a single person’s account.
What is the difference between a blameless postmortem and a regular one?
A blameless postmortem treats failure as a result of systems, process and conditions rather than individual error. It asks what allowed the incident to happen and how to change that. People are more willing to share what they saw and did when they will not be punished for it, which gives you better information.
How soon after an incident should we write it?
While the details are fresh. One source suggests a target of under five business days for major incidents. Take notes during the incident itself, so the timeline is half built before the review begins.
Do small teams and solo developers need postmortems?
Yes, in a lighter form. A five-line note with the timeline, the cause and one action item still beats nothing. Solo developers benefit most, because there is nobody else to remember what happened.
Sources
- Google SRE book: Postmortem Culture
- Google SRE book: Example Postmortem
- StackPractices: Incident Postmortem Template
- Ricardo Martins: Postmortems on Azure, learning metrics
- USENIX SREcon: Incident Archeology
- Atlassian: Incident postmortem template
- Atlassian: ITSM post incident review template



