# Incident Timeline Template: Alert to Fix, On-Call Handoff

> An incident timeline template from first alert to fix, how to join ticket, chat, change and outcome, and what on-call rotation and handoff records add.

Canonical: https://origindatapartners.com/guides/incident-timeline-template
By: Origin Data Partners
Status: Published
Published: 2026-11-17
Updated: 2026-11-17
Sources checked: 2026-11-17

## Quick answer

An incident timeline is the ordered list of what happened during an incident, from the first sign of trouble to the fix, each entry with a UTC timestamp, a source and a link. A good template has columns for time, event, who acted, source system and record ID, so the ticket, chat thread, config change and outcome can be joined. On-call schedules and handoff notes show who was responding and what they already knew.

## Key points

- Use one time zone (UTC) and record where every timestamp came from.
- Give each entry a record ID: ticket, alert, chat message, commit or pull request.
- The timeline starts when the problem began, not when someone noticed it.
- On-call schedules and handoff notes explain who acted and what they knew at each point.

## What is an incident timeline?

Atlassian defines it as "a complete real-time record of an incident. It often includes manual entries (chat), consolidated records of pages, alerts, and acknowledgements, and automatic system updates" ([Atlassian](https://www.atlassian.com/incident-management/postmortem/timelines)). During the incident it keeps everyone on the same page. Afterwards it becomes the spine of the [postmortem](https://origindatapartners.com/guides/incident-postmortem-examples).

Someone has to own it. In PagerDuty's process, "the purpose of the Scribe is to maintain a timeline of key events during an incident" ([PagerDuty](https://response.pagerduty.com/training/scribe/)). At Google, "the incident commander's most important responsibility is to keep a living incident document", and the SRE book says to "retain this documentation for postmortem analysis" ([Google SRE book](https://sre.google/sre-book/managing-incidents/)). Security teams have the same rule: CISA's playbook says to "create a timeline of all relevant findings" ([CISA playbooks (PDF)](https://www.cisa.gov/sites/default/files/2024-08/Federal_Government_Cybersecurity_Incident_and_Vulnerability_Response_Playbooks_508C.pdf)).


## Incident timeline template

Copy these columns into a spreadsheet or the incident document. One row is one event. Keep rows in time order and never edit a past row except to correct it with a note.

| Column | What to put in it | Example value |
| --- | --- | --- |
| Time (UTC) | When it happened, to the minute or second | 2026-03-14 14:07:12 |
| Phase | Cause, detection, response, mitigation, resolution, follow-up | Detection |
| Event | What happened, in one plain sentence | Page: checkout 5xx rate over 5% |
| Actor | Person (by role), team, system or tool | Paging tool; on-call 1 acknowledged |
| Source system | Where the evidence lives | Paging tool |
| Record ID | The ID that joins this row to its record | ALERT-88231 |
| Link | URL or path to the record | Link to the alert |

PagerDuty's template lists the times every timeline should hold: "(1) time the contributing factor began, (2) time of the page, (3) time that the status page was updated (i.e. when the incident became public), (4) time of any significant actions, (5) time the SEV-2/1 ended, (6) links to tools/logs that show how the timestamp was arrived at" ([PagerDuty template](https://response.pagerduty.com/after/post_mortem_template/)).


## How do you build an incident timeline from alert to fix?

Build it during the incident, then complete it from the records afterwards.

- During the incident, the scribe notes decisions and actions in the incident channel as they happen. PagerDuty scribes prefix follow-ups with "TODO" so they are easy to find later.
- After the incident, export the alerts and acknowledgements from the paging tool and add them as rows.
- Pull the changes: deploys, merged pull requests and config commits in the window before and during the incident.
- Walk back from the first alert to find when the cause actually began. That is the first row.
- Add the fix and the moment service was back to normal, then the follow-up tickets.
- Check every timestamp against its source, convert all of them to UTC, and add the record ID and link.

For security incidents, NIST's incident response guide adds that "actions performed during an investigation are recorded, and the records' integrity and provenance are preserved" ([NIST SP 800-61r3](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-61r3.pdf)). Provenance means where a record came from and how it was handled.


## How do the ticket, chat thread, change and outcome join?

Each system keeps its own part of the story. The timeline joins them through two things: a shared incident ID written into each record, and timestamps close enough to match. The more often responders paste the incident ID into commits, chat and tickets, the less guesswork the join needs.

| Record | Where it lives | Join key | What it adds |
| --- | --- | --- | --- |
| Alert and page | Paging or monitoring tool | Alert ID, incident ID, time | When the problem was seen and who was paged |
| Incident ticket | Ticket or service desk tool | Incident ID | Severity, status changes, owner, linked tickets |
| Chat thread | Incident channel | Channel name with the incident ID, message time | What people saw, tried and decided |
| Change | Git host, CI/CD or change tool | Commit, pull request or change ID quoted in the ticket | The exact diff that caused or fixed it, and its review |
| Outcome | Monitoring, status page, ticket closure | Incident ID, time | When service recovered and whether the fix held |
| Follow-up | Ticket tool | Action-item IDs listed in the postmortem | What was changed afterwards to prevent a repeat |


## What do on-call rotation and handoff records add?

An on-call rotation is the schedule of who answers pages. Atlassian describes it as team members who "take turns staffing an on-call rotation, either providing coverage around the clock or only outside of normal business hours" ([Atlassian](https://www.atlassian.com/incident-management/on-call)). Google notes that "many teams have both a primary and a secondary on-call rotation" ([Google SRE book](https://sre.google/sre-book/being-on-call/)), and PagerDuty's first scheduling advice is "always have a backup schedule" ([PagerDuty](https://response.pagerduty.com/oncall/being_oncall/)).

The on-call handoff is the note passed between shifts. Google's SRE workbook gives the rule: "at the start of each shift, the on-call engineer reads the handoff from the previous shift ... At the end of the shift, the on-call engineer sends a handoff email to the next engineer on-call" ([Google SRE workbook](https://sre.google/workbook/on-call/)). PagerDuty says that "when going off-call, you should provide a quick summary to the next on-call about any issues that may come up during their shift" ([PagerDuty](https://response.pagerduty.com/oncall/being_oncall/)).

For a timeline, these records answer questions the tools cannot: who was primary when the page fired, whether the issue was already known from the last shift, and whether an escalation went to the backup. A handoff note that says "disk on db-3 flapping, watch it" can explain why a responder acted in two minutes instead of twenty.


## Incident timeline example

The timeline below is an illustration written for this page. It is the fictional checkout outage INC-2291, filled into the template.

| Time (UTC) | Phase | Event | Actor | Record ID |
| --- | --- | --- | --- | --- |
| 13:58 | Cause | Load balancer health-check path changed and applied | Deploy pipeline | PR-812 |
| 14:07 | Detection | Page: checkout 5xx rate over 5% for 5 minutes | Monitoring; on-call 1 | ALERT-88231 |
| 14:09 | Response | On-call 1 acknowledges; handoff note mentioned no open issues | On-call 1 | ALERT-88231 |
| 14:15 | Response | Incident declared, commander named, channel opened | On-call 1 | INC-2291 |
| 14:31 | Response | Errors linked to the 13:58 change | On-call 2 | Chat message 14:31:40 |
| 14:44 | Mitigation | Rollback applied | On-call 2 | PR-815 |
| 14:48 | Resolution | Error rate back to normal | Monitoring | INC-2291 |
| 15:05 | Resolution | Incident resolved; postmortem owner named | Incident commander | INC-2291 |
| Next day | Follow-up | Four action items filed | Postmortem owner | TICKET-4410 to 4413 |


## Common mistakes with incident timelines

Most bad timelines fail in one of these ways.

- Mixing time zones, or copying times from screenshots with no zone at all.
- Starting at the page instead of at the cause, which hides how long the problem went unseen.
- Writing summaries ("we investigated") instead of actions with an actor and a record.
- No record IDs, so nobody can find the commit or ticket a row refers to.
- Editing earlier rows to match what was learned later, which erases what responders knew at the time.
- Leaving the chat export and paging data to expire before the timeline is finished.


## What should a sample of incident records include?

A joined timeline is also the format buyers of these records look for. AI data buyers have asked Origin for the records of companies that run and defend their own infrastructure: incidents joined to the change that fixed them (the ticket, the chat thread, the config diff or pull request, and the outcome), configuration and infrastructure-as-code history with commits and reviews going back years, logs or captures of what happened and what was done in order, and the runbooks, SOC tickets, on-call records and postmortems from the same period. The infrastructure must be the company's own (a client's only where that client has agreed), and the company must own the logs and be able to license them.

The first step buyers asked for is small: a sample of two or three incidents end to end, plus a slice of the configuration history around them. The illustrative manifest below shows one way to lay that out. It is an example, not a required format. For the configuration side see [infrastructure as code examples](https://origindatapartners.com/guides/infrastructure-as-code-examples) and [config drift](https://origindatapartners.com/guides/config-drift). For who holds these records, see [the hub page](https://origindatapartners.com/guides/license-infrastructure-incident-data-ai).

Origin is an independent data partner. Your company decides what is shared and signs any license itself, and a buyer may pay Origin when a deal closes.

- Secrets in configs, diffs and chat: scan, remove and rotate them before anything leaves ([remove secrets from git history](https://origindatapartners.com/guides/remove-secrets-from-git-history)).
- IP addresses, hostnames and payloads in logs and captures: anonymize them consistently ([anonymize pcap files and logs](https://origindatapartners.com/guides/anonymize-pcap-files-logs)). Captures belong only as part of an ordered incident record.
- People: replace names in chat, tickets and on-call schedules with consistent pseudonyms.
- Customers and clients: remove customer data, and leave out client environments unless the client has agreed.

Illustrative sample manifest: three incidents and a config slice:

```text
sample/
  README.md                 what each file is, time zone (UTC), ID formats, what was removed
  incidents/
    INC-2291/               outage: load balancer health-check change
      ticket.json           incident ticket with status history and links
      chat.jsonl            incident channel, names replaced by role labels
      alerts.jsonl          pages and acknowledgements from the paging tool
      timeline.csv          the joined timeline (template on this page)
      change/PR-812.diff    the change that caused it, with review comments
      change/PR-815.diff    the rollback that fixed it
      postmortem.md         the review, with action-item ticket IDs
    INC-2304/ ...           second incident, same layout
    SEC-118/  ...           third incident: security event, logs anonymized
  config-history/
    lb-config.git.bundle    18 months of load balancer config, commits and reviews
  oncall/
    schedule.csv            rotation by week, people as pseudonyms
    handoffs.md             shift handoff notes for the same weeks
  runbooks/                 the runbook versions in force on those dates
```

Does your company hold records like these? [See what your data is worth](https://origindatapartners.com/check-fit).


## Questions and answers

### What columns should an incident timeline template have?

At minimum: time in UTC, phase, a one-sentence event, the actor, the source system, the record ID and a link to the record. The record ID matters most later, because it joins each row to its ticket, alert, chat message or code change. Without it, nobody can check the timeline afterwards.

### Who should keep the incident timeline during an incident?

One named person, usually called the scribe, so responders can focus on the fix. PagerDuty gives the scribe the job of maintaining a timeline of key events. At Google, the incident commander keeps a living incident document. Either way, someone owns it from the start of the incident.

### What should an on-call handoff note include?

Open incidents and their ticket IDs, anything flapping or likely to come back, changes planned during the next shift, and any alerts that were silenced and why. Google's SRE workbook has engineers read the previous handoff at the start of a shift and send one at the end.

### How does a primary and secondary on-call rotation work?

Two people are on call at once. The primary takes the pages; the secondary is the backup when the primary misses a page or needs help. Some teams give the secondary the non-urgent work instead. Google's SRE book notes that many teams run both, and PagerDuty recommends always having a backup schedule.

### How do you link a code change to an incident?

Put the incident ID into the commit message, pull request and change ticket, and record the commit or pull request ID in the incident ticket and timeline. When that was not done, match by time window and by the systems the change touched, and note in the timeline that the link was inferred.

### What should a sample of incident data for an AI buyer include?

Buyers asked Origin for two or three incidents end to end, each with its ticket, chat thread, alerts, timeline, the change that caused or fixed it and the postmortem, plus a slice of the configuration history around those incidents. Secrets, personal data and client data come out before anything is shared.

## Sources

- [Atlassian: Creating better incident timelines](https://www.atlassian.com/incident-management/postmortem/timelines)
- [PagerDuty Incident Response Guide: Scribe](https://response.pagerduty.com/training/scribe/)
- [Google, Site Reliability Engineering, chapter 14: Managing Incidents](https://sre.google/sre-book/managing-incidents/)
- [PagerDuty Incident Response Guide: Postmortem Template](https://response.pagerduty.com/after/post_mortem_template/)
- [CISA: Cybersecurity Incident and Vulnerability Response Playbooks (PDF)](https://www.cisa.gov/sites/default/files/2024-08/Federal_Government_Cybersecurity_Incident_and_Vulnerability_Response_Playbooks_508C.pdf)
- [NIST SP 800-61 Rev. 3: Incident Response Recommendations and Considerations for Cybersecurity Risk Management](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-61r3.pdf)
- [Atlassian: On-call](https://www.atlassian.com/incident-management/on-call)
- [Google, Site Reliability Engineering, chapter 11: Being On-Call](https://sre.google/sre-book/being-on-call/)
- [PagerDuty Incident Response Guide: Being On-Call](https://response.pagerduty.com/oncall/being_oncall/)
- [Google, The Site Reliability Workbook, chapter 8: On-Call](https://sre.google/workbook/on-call/)

## Related reading

- [Incident Postmortem Examples: Outage, Security and Template](https://origindatapartners.com/guides/incident-postmortem-examples)
- [Runbook vs Playbook: Differences, Examples and a Template](https://origindatapartners.com/guides/runbook-vs-playbook)
- [Can a Company License Its Incident and Config Data to AI?](https://origindatapartners.com/guides/license-infrastructure-incident-data-ai)
- [Infrastructure as Code Examples: Terraform, Ansible, State](https://origindatapartners.com/guides/infrastructure-as-code-examples)
- [Can a security company license alerts and incident data to AI?](https://origindatapartners.com/guides/license-security-incident-data-ai)
- [Cybersecurity Incident Data: A Guide for MSSPs and IR Firms](https://origindatapartners.com/guides/cybersecurity-incident-soc-case-data)
- [AI SRE Agent Traces: Incident Runs as Training Data](https://origindatapartners.com/guides/ai-sre-incident-agent-traces)
- [Audit Log Examples: Fields, SIEM Logs and CloudTrail](https://origindatapartners.com/guides/audit-log-examples)
