Know a company with years of records? Refer it and earn up to $100K
Operations records

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.

Template columns on this page
7Time, phase, event, actor, source, record ID, link
Timestamps PagerDuty asks for
6 kindsFrom cause to end, plus the links that prove them
Handoffs per shift (Google SRE)
2Read one at the start, send one at the end
A server rack with blue patch cables and a laptop showing a ticket queue
Short 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.

  • 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). During the incident it keeps everyone on the same page. Afterwards it becomes the spine of the postmortem.

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). 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). Security teams have the same rule: CISA's playbook says to "create a timeline of all relevant findings" (CISA playbooks (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.

ColumnWhat to put in itExample value
Time (UTC)When it happened, to the minute or second2026-03-14 14:07:12
PhaseCause, detection, response, mitigation, resolution, follow-upDetection
EventWhat happened, in one plain sentencePage: checkout 5xx rate over 5%
ActorPerson (by role), team, system or toolPaging tool; on-call 1 acknowledged
Source systemWhere the evidence livesPaging tool
Record IDThe ID that joins this row to its recordALERT-88231
LinkURL or path to the recordLink 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).

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). 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.

RecordWhere it livesJoin keyWhat it adds
Alert and pagePaging or monitoring toolAlert ID, incident ID, timeWhen the problem was seen and who was paged
Incident ticketTicket or service desk toolIncident IDSeverity, status changes, owner, linked tickets
Chat threadIncident channelChannel name with the incident ID, message timeWhat people saw, tried and decided
ChangeGit host, CI/CD or change toolCommit, pull request or change ID quoted in the ticketThe exact diff that caused or fixed it, and its review
OutcomeMonitoring, status page, ticket closureIncident ID, timeWhen service recovered and whether the fix held
Follow-upTicket toolAction-item IDs listed in the postmortemWhat 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). Google notes that "many teams have both a primary and a secondary on-call rotation" (Google SRE book), and PagerDuty's first scheduling advice is "always have a backup schedule" (PagerDuty).

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). 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).

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)PhaseEventActorRecord ID
13:58CauseLoad balancer health-check path changed and appliedDeploy pipelinePR-812
14:07DetectionPage: checkout 5xx rate over 5% for 5 minutesMonitoring; on-call 1ALERT-88231
14:09ResponseOn-call 1 acknowledges; handoff note mentioned no open issuesOn-call 1ALERT-88231
14:15ResponseIncident declared, commander named, channel openedOn-call 1INC-2291
14:31ResponseErrors linked to the 13:58 changeOn-call 2Chat message 14:31:40
14:44MitigationRollback appliedOn-call 2PR-815
14:48ResolutionError rate back to normalMonitoringINC-2291
15:05ResolutionIncident resolved; postmortem owner namedIncident commanderINC-2291
Next dayFollow-upFour action items filedPostmortem ownerTICKET-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 and config drift. For who holds these records, see the hub page.

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).
  • IP addresses, hostnames and payloads in logs and captures: anonymize them consistently (anonymize pcap files and 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
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.

Common questions

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 and further reading

What is your company’s data worth?

AI companies pay $20K to $5M for company records. Six questions, no files.