Post Mortem Documentation Template in Markdown (Free)

November 11, 2026 · 12 min read

Post Mortem Documentation Template for Blameless Incident Reviews

A post mortem documentation template gives every incident review the same shape: metadata, summary, impact, a UTC timeline, root cause, resolution, lessons and owned action items. Below you'll find a blank postmortem template in Markdown to copy, then the same file filled in for a fictional 47-minute checkout outage, written in blameless language throughout.

What a Post Mortem Documentation Template Should Include

An incident postmortem is a written record of what broke, who it affected, how you fixed it and what you'll change so it doesn't happen again. Google's example postmortem from the SRE book is the closest thing to a reference layout. The sections below cover the same ground, reordered so the timeline sits near the top.

  • Metadata: date, authors, status, severity and duration, so anyone scanning a folder of reviews can sort them.
  • Summary: two or three sentences a manager can read and stop.
  • Impact: what users, customers or revenue lost, with numbers where you have them.
  • Timeline: timestamped events in UTC, from the trigger to the all-clear.
  • Root cause and trigger: the underlying weakness, plus the event that exposed it.
  • Detection: how you found out. An alert is good news; a customer email is a finding.
  • Resolution: what stopped the bleeding and what fixed it for good.
  • Lessons learned: what went well, what went wrong and where you got lucky.
  • Action items: each with an owner, a due date and a ticket.
  • Supporting links: dashboards, logs, the incident channel and related tickets.

This template is for production incidents. Project retrospectives ("what did we learn from this launch?") need a different shape, so don't force one into the other.

The Blank Postmortem Template in Markdown

Copy this into a new .md file and replace each placeholder in angle brackets. Every heading is optional except Summary, Timeline and Action items; a postmortem without those three isn't worth reviewing.

# Postmortem: <short description> on <YYYY-MM-DD>

- **Status:** Draft | In review | Complete
- **Severity:** <SEV1 / SEV2 / SEV3>
- **Duration:** <start UTC> to <end UTC> (<n> min)
- **Authors:** <names or team>
- **Incident ticket:** <link>

## Summary
<Two or three sentences: what failed, for how long, and how it was fixed.>

## Impact
<Who was affected and how much. Users, requests, orders, revenue, SLO budget.>

## Timeline (UTC)
| Time | Event | Source |
|---|---|---|
| <HH:MM> | <what happened> | <alert, deploy log, chat> |

## Root cause
<The underlying weakness. Systems and processes, not people.>

## Trigger
<The specific change or event that exposed it.>

## Detection
<How the team found out, and how long that took.>

## Resolution
<What mitigated the impact, then what fixed it.>

## What went well
- <item>

## What went wrong
- <item>

## Where we got lucky
- <item>

## Action items
- [ ] <action> (type: mitigate / prevent / process, owner: <name>, due: <YYYY-MM-DD>, ticket: <link>)

## Supporting information
- <dashboards, logs, incident channel>

The metadata sits in a bullet list because plain consecutive lines merge into one paragraph in many renderers, including GitHub's file view. Pipes in the Status line are just a list of allowed values; delete the ones that don't apply. Replace every placeholder before you preview the file, because Markdown reads some of them, like <item> and <link>, as HTML tags and hides them. If you also need README, meeting-notes or decision-record files, our collection of Markdown templates covers those, so this post sticks to incidents.

How Do You Write an Incident Timeline in Markdown?

Write the timeline as a table with one row per event, times in UTC, and a column for where each fact came from. Pull entries from the alert history, the deploy log and the incident channel while they're fresh, then fill gaps from memory and mark them as such.

| Time (UTC) | Event | Source |
|---|---|---|
| 14:02 | Config change deployed to all regions | Deploy log |
| 14:04 | Checkout error rate climbs from 0.3% to 18% | Dashboard |
| 14:09 | Error-rate alert pages the on-call engineer | Pager |
| 14:12 | Payment provider status page shows no incident | Incident channel |
| 14:24 | Deploy history links the spike to the 14:02 change | Incident channel |
| 14:31 | Rollback started | Deploy log |
| 14:49 | Error rate back to baseline, incident resolved | Dashboard |

It renders as a three-column grid that you can scan top to bottom, with every claim traceable to a source. Google's own example uses a bulleted list with the date and "all times UTC" in a header line, and that works too. We prefer the table, because the Source column makes reviewers ask "how do we know that?" before the review meeting, not during it.

Pin everything to UTC, even if the whole team sits in one office. Logs, cloud consoles and vendors' status pages rarely agree on local time. For alignment, escaping pipes and other table details, see the Markdown table guide. If you'd rather fill cells in a spreadsheet-style grid, the Markdown table generator runs in your browser and outputs a GFM table you can paste straight into the file.

Action Items as Task Lists With Owners and Due Dates

Action items are the reason the document exists. Write each one as a GFM task list item with an owner, a due date and a ticket link, so nobody has to ask who's doing what.

- [ ] Reject out-of-range timeout values in config CI (type: prevent, owner: platform team, due: 2026-11-17, ticket: PLAT-412)
- [ ] Show deploys from the last hour on every error-rate alert (type: mitigate, owner: observability, due: 2026-11-24, ticket: OBS-88)
- [x] Add a checkout error dashboard (type: mitigate, owner: payments, due: 2026-11-05, ticket: PAY-301)
- [ ] Require a second reviewer for payment config changes (type: process, owner: payments lead, due: 2026-11-20, ticket: PAY-305)

On GitHub, these render as checkboxes, and in an issue or pull request body you can tick them. The GFM spec defines both task list items and tables as extensions, and many Git hosts and wikis support them. Our Markdown checkbox guide covers nesting and where checkboxes are clickable.

The types come from Google's example, which tags each item as mitigate, prevent, process or other. Here's the limitation: a checkbox in a Markdown file can't chase anyone. The ticket in your issue tracker is the source of truth, and the checkbox is just a snapshot you update at review time. When a process item changes how the team works, record the new workflow in a process documentation template.

How Do You Write a Blameless Root Cause Section?

A blameless root cause explains which safeguard was missing, not who slipped. Google's postmortem culture chapter puts it plainly: assume everyone involved had good intentions and did the right thing with the information they had. If a person's action is the last link in your chain, keep asking why.

Separate three things. The trigger is the event that set it off. The root cause is the weakness that let a normal event become an outage. Contributing factors made it worse or slower to fix. Google's example points to the 5 Whys technique for digging from symptom to cause, and it works well on short incidents:

  1. Why did checkouts fail? Payment API calls timed out after 50 ms.
  2. Why was the timeout 50 ms? A change meant to lower it from 3,000 ms to 500 ms set it to 50.
  3. Why did review miss it? The diff was one value, and nothing showed the old and new numbers side by side.
  4. Why didn't CI catch it? Config CI checks syntax, not whether a timeout is in a sane range.
  5. Why is there no range check? The config schema has no minimum or maximum for timeout fields.

The chain ends at a missing schema rule, which you can fix. Wording matters just as much as structure:

Instead ofWrite
Sam typed the wrong timeout and took checkout down.A config change set the payment timeout to 50 ms. Nothing in review or CI checks timeouts against a safe range.
On-call wasted 15 minutes on the payment provider.The alert didn't link recent deploys, so the first 15 minutes went to ruling out the payment provider.

Atlassian's guide to blameless postmortems argues the same point from the team side: people share honest details only when they don't fear punishment. Without those details, your root cause section is guesswork.

Incident Postmortem Template Example: A 47-Minute Checkout Outage

Here's the template filled in for the fictional incident used throughout this post, cut down to the sections that show the format best. The numbers are invented for the example. In a real review you'd include every section from the blank file.

Postmortem: Checkout errors on 2026-11-03

Status: In review | Severity: SEV2 | Duration: 47 min

Summary

A config change set the payment API timeout to 50 ms. About 18% of checkouts failed until the change was rolled back.

Timeline (UTC)

Time Event
14:02 Config change deployed
14:09 Error-rate alert fires
14:31 Rollback started
14:49 Errors back to baseline

Action items

  • Reject out-of-range timeouts in config CI (owner: platform)
  • Add a checkout error dashboard (owner: payments)
100 words559 characters18 lines
Markdown

The preview renders the timeline as a table and the action items as checkboxes. Our editor shows task list items as disabled checkboxes, so you tick them by changing [ ] to [x] in the text. Swap in your own times, owners and tickets, and the structure carries over to any incident.

When Should Your Team Write a Postmortem?

Agree on the triggers before the next incident, not during it. Google's SRE book lists common ones, and many teams start from a version of this list:

  • Users saw downtime or degradation past a threshold you've set.
  • Any data was lost.
  • On-call had to step in, for example with a rollback or a traffic reroute.
  • Resolution took longer than a set limit.
  • Monitoring failed, and a person found the problem instead.

Any stakeholder can also ask for a postmortem, even when no trigger fires. Severity levels help decide how much write-up an incident needs. Here's an illustrative scale; there's no industry standard, so set thresholds that fit your product:

SeverityExample thresholdPostmortem
SEV1Core service down for most users, or any data lossRequired, reviewed by senior engineers
SEV2A key flow failing for some usersRequired
SEV3Minor degradation with a workaroundOptional, short form

Once the draft is done, review it as a group before it's filed. Google's chapter calls this out directly: an unreviewed postmortem might as well not exist.

Keeping Postmortems as Markdown Files Next to Your Code

Plain Markdown files fit postmortems well. Put them in a folder such as docs/postmortems/, name each one YYYY-MM-DD-short-name.md, and they sort by date in any file browser. Opening a pull request for each draft gives you a review thread, a record of who approved it and a URL to paste into the incident ticket. Deploy and rollback plans can sit in the same repo, and our release documentation template gives each release its own file.

To draft one outside your repo, paste the template into our Markdown editor. It's free, runs in your browser and needs no account to write, preview or download the .md file. The split view puts the Markdown on the left and the rendered tables and checkboxes on the right.

Not everyone reads Markdown, though. For stakeholders who want Word or PDF, the Download/Export menu also has Export as PDF and Export as DOCX. Free users can export documents up to 5,000 characters, and a full postmortem often runs longer. PDF and Word exports also draw on a shared free pool of 3 server operations a day. Download .md has no limit, and Pro removes both caps.

Postmortem Naming, Timing and Format Questions

A post mortem documentation template only pays off when the team uses it the same way every time. That means a UTC timeline in a table, action items with owners and tickets, and a root cause that names a missing safeguard instead of a person. Copy the blank file above, fill it in for your next incident, and check the tables and checkboxes in the free Markdown editor before you open the review.