---
title: "Incident Postmortem Template + AI Prompt to Build the Timeline"
url: "https://goremy.ai/blog/articles/incident-postmortem-template-an-ai-prompt-to-build-the-timeline"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-18T05:40:10.434Z"
updated: "2026-11-18T05:40:10.434Z"
topic: Cybersecurity and IT Systems
description: A copy-ready incident postmortem template, including a network outage version, plus an AI prompt that turns chat logs and alerts into a timeline.
---

# Incident Postmortem Template + AI Prompt to Build the Timeline

> A copy-ready incident postmortem template, including a network outage version, plus an AI prompt that turns chat logs and alerts into a timeline.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-18

## What is an incident postmortem template?

An incident postmortem template is a fixed outline for writing up what happened during an outage or security event, why it happened, and what will change so it does not repeat. A good one covers a summary, customer impact, a timestamped timeline, root cause and contributing factors, what went well and badly, and action items with owners and due dates. The template below is ready to copy, includes a network outage add-on, and comes with an AI prompt for the slowest part: building the timeline.

## TL;DR

- **Use one template for every incident**, so reviews are comparable and nobody argues about format while the details are still fresh.
- **The timeline is the slow part**, because the evidence is scattered across chat, alerts, tickets and change logs, each with its own time zone.
- **AI is good at merging and sorting raw evidence** into a draft timeline, and bad at deciding why something happened. Keep the judgment human.
- **Make the AI cite its source for every row** and mark gaps instead of filling them. Then check every row against the original.
- **Action items are the point of the document.** Each needs one owner, a due date, and a type (prevent, detect, or reduce impact).
- **Redact before you paste.** Remove credentials, customer data and anything your company's AI policy says must stay out of external tools.

## The incident postmortem template (copy this)

Paste this into your wiki, document tool or ticket. Delete guidance text in brackets once you fill a section.

```
INCIDENT POSTMORTEM

Title: [Short, plain description. Example: "Branch offices lost access to payments app"]
Incident ID / ticket: [ID]
Severity: [Use your company's scale]
Status: [Draft / In review / Final]
Date of incident: [YYYY-MM-DD]
Time zone used throughout: [UTC recommended]
Incident commander: [Name]
Author(s): [Names]
Reviewers: [Names]
Review meeting date: [Date]

1. SUMMARY
[3 to 5 sentences. What broke, who was affected, how long it lasted,
how it was fixed. A reader should be able to stop here.]

2. IMPACT
- Who was affected: [teams, sites, customers, systems]
- How many / how much: [users, transactions, sites. Use measured numbers only.]
- Duration: [start of impact to end of impact]
- Business impact: [lost work, missed SLAs, revenue, compliance exposure]
- Data affected: [none / describe]

3. DETECTION
- How we found out: [alert, user report, monitoring, vendor notice]
- Time from start of impact to detection: [duration]
- Should we have known sooner? [Yes/No, and why]

4. TIMELINE
| Time (UTC) | Event | Source | Who |
|------------|-------|--------|-----|
| | | | |
[Include: first sign of trouble, detection, escalations, key decisions,
changes made, failed attempts, mitigation, full recovery, all-clear.]

5. ROOT CAUSE AND CONTRIBUTING FACTORS
- Trigger: [The event that set it off]
- Root cause: [The underlying condition that allowed the trigger to cause harm]
- Contributing factors: [Missing alert, unclear runbook, no review of
  the change, single point of failure, and so on]
- Why it was not caught earlier: [Testing, review, monitoring gaps]

6. RESPONSE
- What went well:
- What went badly:
- Where we got lucky:

7. RESOLUTION AND RECOVERY
- Fix applied: [What changed]
- Time to mitigate / time to full recovery:
- Verification: [How we confirmed it was really fixed]

8. ACTION ITEMS
| # | Action | Type (Prevent / Detect / Reduce impact) | Owner | Due | Ticket |
|---|--------|------------------------------------------|-------|-----|--------|
| 1 | | | | | |

9. LESSONS AND OPEN QUESTIONS
[What we learned. What we still do not know.]

10. APPENDIX
[Links to chat channels, dashboards, graphs, vendor tickets, change records.
Raw logs belong here, not in the body.]
```

### Add this section for a network outage

A network outage postmortem needs the template above plus a few questions that are specific to networks. Insert this as section 5A.

```
5A. NETWORK-SPECIFIC DETAILS
- Scope: [sites, VLANs, subnets, circuits, devices, regions affected]
- Change correlation: [Was there a change in the 24 hours before?
  Change ticket numbers, who approved, who implemented]
- Layer or domain: [Physical / switching / routing / firewall / DNS /
  DHCP / WAN / VPN / wireless / provider]
- Failover behavior: [Did redundancy work? If not, why not?]
- Dependencies that amplified it: [DNS, authentication, single uplink,
  shared management network]
- Monitoring gaps: [What did we not see? Which check would have caught it?]
- Third parties: [ISP, carrier or vendor ticket numbers and response times]
- Rollback: [Was one available? How long did it take? Was it tested?]
```

## How do you fill in the template without blaming people?

Write about systems and decisions, not individuals. "The change was applied without a second review" is useful. "Dana pushed a bad config" is not, and it teaches people to hide mistakes next time.

A few rules that keep the document honest:

1. **Describe what people knew at the time.** "The on-call engineer saw a link-down alert and reasonably assumed a carrier issue" explains the delay better than "the engineer wasted 20 minutes."
2. **Name the role, not the person,** where you can. "On-call network engineer" works in most sections. Names are fine in the timeline if your culture allows it.
3. **Ask "how did the system allow this?"** If one person's mistake could cause an outage, something upstream (review, testing, guardrails) was missing.
4. **Separate trigger from root cause.** The trigger is the config change. The root cause is that nothing validated it before it reached production.

## How do you build the incident timeline faster?

The timeline is usually the slowest section because the evidence lives in many places, and each tool stamps time differently. Collect these before you start:

- The incident chat channel export (Slack, Teams, or similar)
- Alert and monitoring history (paging tool, network monitoring system)
- Change records for the surrounding 24 to 48 hours
- Ticket history, including customer or user reports
- Device or application logs for the affected window (only the relevant excerpt)
- Vendor or ISP ticket updates
- Any notes someone typed during a bridge call

Then do the same three steps each time: normalize every timestamp to one time zone, sort everything into one sequence, and mark which entries are measured (an alert fired at 14:02:11) and which are recalled (someone said it started "around two"). AI can do the first two steps quickly. You do the third.

## What is the AI prompt to build a postmortem timeline?

Paste this into your company's approved AI assistant, then paste your redacted evidence below it. Fill in the bracketed parts.

```
You are helping me write the timeline section of a blameless incident
postmortem. I will paste raw evidence from several sources: chat export,
alerts, change records, tickets and notes. Build a draft timeline using
ONLY what is in that evidence.

Context:
- Incident: [one-line description]
- Output time zone: [UTC]
- Source time zones: chat is in [zone], alerts are in [zone], change
  records are in [zone], logs are in [zone]. Convert everything to the
  output time zone and tell me any conversion you were unsure about.

Rules:
1. Output a table with columns: Time, Event, Source, Confidence
   (Measured / Reported / Inferred).
2. Every row must name the specific source (for example "alert export,
   line 14" or "chat, message from on-call at 14:07"). If you cannot
   point to a source, do not include the row.
3. Do not guess causes. Do not write "because". Describe what happened
   and what people said they were doing.
4. If two sources disagree on a time or a fact, keep both entries and
   flag the conflict below the table.
5. List gaps: periods longer than [10] minutes with no evidence, and
   decisions that are mentioned but never explained.
6. Use role names ("on-call network engineer") instead of personal names
   unless I say otherwise.
7. After the table, list the five questions a reviewer should ask the
   people involved to fill the gaps.

Evidence:
[paste redacted evidence, labeled by source]
```

Label each block of pasted evidence with its source ("CHAT EXPORT", "ALERTS", "CHANGE RECORD") so the model can cite it correctly.

### A follow-up prompt for the rest of the draft

Only run this after you have checked and corrected the timeline.

```
Here is the verified timeline for an incident. Using only this timeline
and the notes below, draft sections 1 (Summary), 2 (Impact), and 3
(Detection) of the postmortem. Keep the Summary to five sentences.
Do not state a root cause. Instead, list three candidate contributing
factors that the evidence supports, with the timeline row that supports
each one, so the team can discuss them.

Verified timeline:
[paste]

Notes on impact:
[paste what you measured]
```

Asking for candidates tied to evidence, instead of a root cause, keeps the analysis with the people who understand the system.

## What does a worked example look like?

This is a fictional example, shown so you can see the level of detail. The company, systems and numbers are invented for illustration.

**Raw evidence (redacted, abbreviated):**

```
ALERTS (UTC)
14:02:11 Link/VLAN check failed: Branch-East to payments app
14:02:40 Packet loss alert: Branch-East WAN
14:09:03 Page sent to on-call network engineer

CHAT (US Eastern, UTC-4)
10:11 on-call: acknowledged, looking at Branch-East
10:19 on-call: carrier portal shows circuit up, not an ISP problem
10:31 service desk: 3 more branches reporting same thing
10:36 on-call: was there a change this morning?

CHANGE RECORD (UTC)
13:55 CHG-2291 started: trunk cleanup on distribution switches
14:20 CHG-2291 marked complete by implementer
```

**Resulting draft timeline (after the AI pass and a human check):**

| Time (UTC) | Event | Source | Confidence |
|---|---|---|---|
| 13:55 | Change CHG-2291 (trunk cleanup on distribution switches) begins | Change record | Measured |
| 14:02 | VLAN check from Branch-East to payments app fails | Alert export | Measured |
| 14:02 | Packet loss alert on Branch-East WAN | Alert export | Measured |
| 14:09 | Page sent to on-call network engineer | Alert export | Measured |
| 14:11 | On-call acknowledges, begins investigating Branch-East | Chat (10:11 ET converted) | Reported |
| 14:19 | On-call reports carrier portal shows circuit up | Chat (10:19 ET converted) | Reported |
| 14:20 | CHG-2291 marked complete | Change record | Measured |
| 14:31 | Service desk reports three more branches affected | Chat (10:31 ET converted) | Reported |
| 14:36 | On-call asks whether a change was made that morning | Chat (10:36 ET converted) | Reported |

**Gaps and conflicts the AI flagged:**

- The change began 7 minutes before the first alert, but nobody connected the two until 14:36. This is a detection and process question, not a person question.
- The page went out 7 minutes after the first alert. Reviewers should ask why.
- The record ends at 14:36. Evidence for mitigation and recovery is missing.

**What the team does next:** They add the rollback and recovery rows from the switch logs and the bridge call notes, then fill in section 5 as a group. A plausible finding: the cleanup removed a VLAN from an allowed list on a trunk, and the change had no pre-check that listed which services used that VLAN. The contributing factors would include no automatic link between active changes and alerts, and a 7-minute paging delay. Those become action items:

| # | Action | Type | Owner | Due |
|---|--------|------|-------|-----|
| 1 | Require a VLAN dependency check in the change template for trunk edits | Prevent | Network engineering lead | [date] |
| 2 | Show active change tickets in the alert view for on-call | Detect | Monitoring owner | [date] |
| 3 | Review paging rules for branch connectivity alerts | Reduce impact | On-call manager | [date] |

## What should you check in the AI's timeline?

Treat the AI output as a draft from a fast but unreliable assistant. Before it goes in the document:

- **Spot-check at least a third of the rows against the original source.** Check all of them for incidents with customer or regulatory impact.
- **Verify every time zone conversion.** Daylight saving changes and mixed zones are where errors hide. Check the first and last row of each source.
- **Look for invented rows.** Any row with no source, or a source you cannot find, goes out.
- **Look for hidden causation.** Phrases like "due to," "caused by" or "as a result" mean the model slipped analysis into a timeline. Remove them and discuss as a team.
- **Check that nothing important is missing.** Models tend to compress. Scan the chat for decisions, failed attempts and escalations that did not make the table.
- **Confirm the gaps are real.** A gap might mean no evidence, or it might mean the AI dropped something.

## Where should you not trust AI in a postmortem?

- **Root cause.** The model sees only what you pasted. It does not know your architecture, your history, or what the team tried off-chat. Use it to propose questions, not conclusions.
- **Impact numbers.** Never let it estimate users affected, dollars lost or hours of downtime. Take those from monitoring and finance data.
- **Anything sensitive.** Strip credentials, tokens, customer personal data, internal IP schemes and security vulnerability details unless your company has approved the tool for that data. When in doubt, ask your security team. For a security incident, check policy before pasting anything.
- **Tone about people.** Review for blame language. Models sometimes reintroduce it ("the engineer failed to...").
- **Action items.** It can suggest ideas, but owners and due dates must be agreed by humans who will do the work.

## How long should a postmortem take, and who should be in the review?

Hold the review within a few business days of resolution, while memory is fresh. Draft the timeline first, alone or with the incident commander, then bring it to the meeting for correction. The meeting is for the analysis: what the timeline shows, which factors contributed, and which actions are worth doing.

Invite the people who responded, the owner of the affected system, someone from the team that made any related change, and a manager who can commit time to the action items. For network outages, include whoever manages the carrier or vendor relationship if a third party was involved. Keep the document short enough to be read. Two to four pages with the appendix doing the heavy lifting works better than a long narrative.

Send it out afterward. A postmortem that only the response team reads wastes most of its value.

## Can I build my own incident and action-item tracker?

Most teams keep postmortems in a document and action items in a ticket system, and then lose track of whether the actions got done. If your current tools do not fit, you can describe a small internal app to [Remy](https://goremy.ai), which builds full-stack apps from a plain-English description: an incident log with severity and status, a form that captures the template fields, a table of action items with owners and due dates, and a dashboard showing which are overdue. Remy writes a spec, builds the app with a database and sign-in, and deploys it, which typically takes about an hour for an initial build. Pricing is a flat platform fee plus AI usage at cost, listed on the pricing page.

## Frequently Asked Questions

### What is the difference between a postmortem and a root cause analysis?

A root cause analysis is one part of a postmortem. The postmortem covers the whole incident: impact, detection, timeline, response, causes and follow-up actions. The root cause analysis is the section that explains why it happened, usually through contributing factors rather than a single cause.

### What does a blameless postmortem mean?

It means the review focuses on how systems, processes and information allowed the failure, rather than on who made a mistake. People are still accountable for completing action items. The goal is that engineers and operators report problems and near misses openly instead of covering them up.

### Which incidents need a full postmortem?

That is a company decision, but common triggers are customer-visible outages, security events, data loss, incidents over a set duration, and anything that needed an emergency change. Smaller incidents can use a shortened version: summary, short timeline, cause and action items. Whatever your rule is, write it down so it is applied consistently.

### Can I use ChatGPT or another AI tool for incident reports?

Often yes, if your company has approved the tool for the type of data involved. Redact credentials, personal data and sensitive security details first, and follow your company's AI policy. Use AI to organize evidence and draft wording, then verify everything against the original logs, chats and tickets before anyone signs off.
