🔄 Managing On-Call Handoffs in Slack So Nothing Falls Through the Cracks

The most expensive bug I ever chased was one that an outgoing on-call engineer knew about and never wrote down. The incoming engineer rediscovered it the hard way at 3am. That outage cost us a night and a customer apology, and it was entirely avoidable with a two-minute handoff note. In 25 years of running on-call rotations, I’ve learned that the handoff is the single most underinvested part of the whole process.

Slack is the right place to fix it, because that’s where the context already lives.

Why handoffs fail

Handoffs fail for boring reasons. The outgoing engineer is tired and wants to log off. The “note” is a one-liner in a DM that nobody can find next week. Open issues live in three people’s heads. There’s no consistent format, so each handoff is as good as whoever happens to be writing it.

The fix isn’t discipline — you can’t rely on a tired human at end of shift. The fix is structure plus automation: make the good handoff the easy handoff.

A structured handoff template

I drive every handoff through one slash command, /handoff, that opens a Block Kit modal with the same fields every time:

• Open issues — anything still degraded or being watched, with links.
• Recent incidents — what fired this shift and how it resolved.
• Deploys in flight — anything mid-rollout the next person inherits.
• Watch items — “if X alert fires, it’s probably Y, here’s the runbook.”
• Quiet? — an explicit “nothing notable” so silence isn’t ambiguous.

A consistent template matters more than the specific fields. When every handoff looks the same, the incoming engineer reads it in thirty seconds and knows exactly where to look for what.

Post it where both shifts can see it

The handoff gets posted to a dedicated #on-call-handoffs channel, never a DM. Two reasons: it’s searchable later (“what did we hand off last Tuesday?”), and it’s visible to the whole rotation, so the team builds shared awareness of recurring pain.

The bot stamps each handoff with the outgoing and incoming engineer and the shift window, so the channel becomes a clean log of rotation history.

Carry open issues forward automatically

Here’s the feature that pays for the whole system: open issues don’t reset. When the outgoing engineer marks an issue as still-open, the bot carries it into the next handoff’s pre-filled template. The incoming engineer can’t accidentally lose it, because it’s already there waiting for them to either resolve it or pass it on again.

app.view('handoff_submit', async ({ view, ack, body, client }) => {
  await ack();
  const vals = view.state.values;
  const openIssues = vals.open_issues.input.value;
  // persist openIssues keyed to the rotation
  await store.set(`carryover:${rotation}`, openIssues);
  // post the structured handoff to #on-call-handoffs
});

That carryover store is what stops the “engineer knew but never wrote it down” failure mode. The issue physically cannot vanish between shifts.

Tie it to the schedule

If you run PagerDuty or Opsgenie, hook the handoff to the actual rotation boundary. The bot can ping the outgoing engineer fifteen minutes before their shift ends — “your shift is wrapping up, here’s your pre-filled handoff” — and tag the incoming person when it’s posted. Removing the “did anyone remember to do the handoff?” question removes the main reason handoffs get skipped.

Add an AI recap

A tired engineer writing a handoff often forgets half of what happened. AI fixes this cleanly. The bot pulls the on-call engineer’s shift activity — alerts that fired, incident channels they were in, deploys they ran — and asks an LLM:

“Here’s everything that happened on this on-call shift. Draft a handoff: open issues, incidents and their resolution, anything the next engineer should watch. Be concise. Flag anything that resolved but might recur.”

The engineer gets a pre-filled draft they review and correct, instead of a blank modal at the end of a draining shift. Reviewing is far easier than recalling, and the draft routinely surfaces a flapping alert the human had already mentally filed away.

The boundary is the same one I hold everywhere: AI drafts the recap; the human confirms it before it’s posted. The model never marks an issue resolved or changes the rotation — it only proposes text.

A simple maturity path

1. The structured modal. Just getting every handoff into the same format is most of the win.
2. Post to a shared channel with shift metadata.
3. Open-issue carryover so nothing resets.
4. Schedule-triggered reminders so handoffs never get skipped.
5. AI-drafted recaps last, once the structure is in place.

You can ship step one this afternoon and feel the difference at the very next handoff.

The bottom line

On-call handoffs are cheap to fix and brutally expensive to neglect. A consistent template, a shared channel, automatic carryover of open issues, and an AI-drafted recap turn the handoff from an afterthought into the thing that keeps your nights quiet.

For the prompt I use to generate shift recaps, see our Slack on-call prompts and the broader prompt library.

The AI recap is a draft for a human to verify. Keep issue-resolution and rotation state in deterministic commands, not the model.