Shift handoff workflow (SBAR-style)

What counts as a handoff here, and what this workflow skips on purpose

A handoff is a transfer of responsibility. Not a recap for the sake of it. The outcome we want is practical: the incoming shift can act without guessing, and without hunting through five places for the story.

• In scope: shift change, resident and provider sign-out, bedside report (where appropriate), scribe-supported notes, ops shift handoff (open issues, equipment status, next checks), and IT on-call handoff (active incidents, mitigations, next checks, paging thresholds). Also the "quick call" handoff that feels informal but carries real risk.
• Out of scope (for this workflow): full clinical documentation (H&P, discharge summary), deep troubleshooting sessions, and long training handovers. Link those. Don't stuff them into SBAR. SBAR is compression, not storage.

If the output you want is "current state, watch-outs, and what we do next," keep reading.

Who this workflow is for when missed context turns into scrambling

If you've ever watched two people argue about what was said in report, you already know why this matters. It rarely looks like a big error in the moment. It looks like confusion, backtracking, duplicate work, and somebody getting paged at the worst time.

This workflow reduces that variability by making the output predictable: SBAR, triggers, owners, and a current state card.

• Clinicians and healthcare teams: need SBAR clarity, explicit watch-outs, and clear escalation triggers. This maps directly to clinicians and healthcare.
• Scribes: need consistent formatting, fewer missing fields, and a structure that is easy to review and enter. See scribe workflows.
• Operations: need "what is open, what is risky, what is next" in one place. This fits operations teams.
• IT on-call: need incident status, mitigation, next checks, and thresholds that decide when to page. This matches IT on-call.

The post-handoff window where reality has not drifted yet

The trigger is not "shift change happened." The trigger is right after the handoff. Before the incoming shift starts improvising. Before the "one more thing" disappears. Before memory fills the gaps.

This is the moment to tighten the parts that cause chaos later: who owns what, what needs to happen when, and what exactly triggers escalation. No poetry. Just clarity.

• In-person handoffs: capture bedside or desk sign-out, then finalize the pack immediately.
• Phone handoffs: capture the call, because ambiguity multiplies over the phone.
• Last-minute add-ons: force "one more thing" into either a watch-out or an action.
• Questions time: reserve 60 seconds for the receiver to ask missing questions and repeat back essentials.

Prompt pack you can run right after every handoff:

• "Summarize this handoff in SBAR, keep it scannable."
• "Extract watch-outs and rewrite each into an if-then trigger with time window and escalation path."
• "Extract actions with owner, time window, and done definition."
• "Separate facts from assumptions and label uncertainty. Add the next check that resolves it."
• "Create a one-screen current state card for the next shift."
• "Draft a receiver read-back script from the current state card."

Why handoffs fail in real life (and why SBAR alone is not enough)

SBAR gives you the scaffolding. The misses usually happen in the gaps: triggers and thresholds never get stated, ownership stays implied, and uncertainty gets smoothed over because nobody wants to sound unsure at shift change.

• Background dumps: the decision-changing detail gets buried.
• Uncertainty gets hidden: a guess turns into "known fact" by the time it reaches the next person.
• Unowned work: tasks get mentioned and float into the void.
• Watch-outs are vague: "keep an eye on it" with no trigger and no escalation path.
• No confirmation loop: the handoff ends without read-back, so "heard" gets mistaken for "understood."
• No current state artifact: the incoming shift rebuilds the story from fragments.

If a watch-out has no trigger, it is not a watch-out yet. It is a worry. Rewrite it until it becomes actionable.

What changes with Omi: a baseline SBAR draft, cleaner actions, and a shift memory you can search

Used well, Omi helps you stop relying on whoever remembers the most. You capture the handoff, you get a baseline draft, then you tighten it into something the next shift can run. The win is not "more notes." The win is fewer follow-up questions at 2 a.m.

• Faster finalize: start from an SBAR draft instead of a blank page.
• Less variation: the note shape stays consistent even when people rotate.
• Cleaner action extraction: turn "we should" into owned, timed tasks.
• Watch list that behaves: triggers and escalation paths written explicitly.
• Searchable handoff history: "was this already flagged last shift?" becomes lookup, not debate.
• Automation options: route current state and actions using the apps marketplace, or build custom workflows via the developer docs (webhooks, notifications, integrations).

Practical note for healthcare: always follow your org policy and local rules on recording and storage. The workflow still works even if you only store the SBAR note and current state card.

The SBAR quality bar: what "good" looks like when you measure it by takeover success

The best SBAR note is the one that makes the incoming shift feel calm, not confused. It should answer "what is happening," "what matters," and "what do we do next" without forcing five follow-ups.

Rule: if you cannot write "if X, then Y" for a watch-out, it is not ready to hand off.

The watch list ledger: turn "keep an eye on it" into triggers and escalation paths

This is the part people skip when they are tired. It is also the part that prevents the worst surprises. A watch list ledger forces the uncomfortable questions: what are we watching for, exactly, and what do we do when it happens?

• Representative watch-outs: things that repeat on this unit, service, or rotation.
• High-stakes watch-outs: where delay is costly.
• Uncertainty flags: two plausible interpretations captured explicitly, plus the next check that resolves it.
• Receiver questions: missing details the receiver should ask before taking over.

Trigger table (this is what the next shift actually uses):

Omi prompt patterns that keep the ledger sharp:

• "List all watch-outs mentioned. Rewrite each into an if-then trigger with a time window."
• "For each trigger, add escalation path: who, how, when."
• "Flag vague phrases ('monitor', 'keep an eye on') and propose a measurable trigger."
• "Identify what is uncertain and write the next check that resolves it."

The operational playbook: handoff to current state in 9 steps

This is the loop. The baseline comes from SBAR. The reliability comes from triggers and read-back. The payoff is that the incoming shift starts from the same reality.

Deliverables: what you should have after every handoff

If you finish handoff and you do not have these, you are relying on memory and hope. This list is the minimum set that makes handoffs improve over time instead of repeating the same mistakes.

• SBAR handoff note (scannable, consistent).
• Watch list ledger (triggers, time windows, escalation paths).
• Action list (owners, time windows, done definitions).
• Current state card (one-screen takeover snapshot).
• Receiver confirmation (read-back captured as one line, when possible).

If you only improve one thing, improve triggers. Triggers turn risk into action.

Copy/paste templates: SBAR note, watch list ledger, current state card (plus on-call variants)

SBAR handoff note template

Handoff title:
Date/time:
Unit/service:
Sender:
Receiver:

Situation (one sentence, what is happening now and why it matters):
-

Background (only decision-changing context):
- Recent events:
- Constraints:
- Current baseline plan:

Assessment (your current read plus uncertainty):
- What we think is going on:
- What we are not sure about:
- What would change our mind (next check):

Recommendation (what to do next):
- Action:
  - Owner:
  - Time window:
  - Done definition:
- Action:
  - Owner:
  - Time window:
  - Done definition:

Watch list (risks to monitor):
- Watch-out:
  - Why it matters:
  - Trigger (if-then):
  - Time window:
  - Immediate action:
  - Escalation path (who/how/when):
  - Owner on shift:

Receiver confirmation (optional):
- Receiver read-back summary:
- Missing questions answered:

Watch list and escalation triggers template

Watch-out:
Why it matters:
Trigger (if-then, measurable when possible):
Time window:
Immediate action:
Escalation path (who/how/when):
Owner on shift:
What resolves uncertainty (next check), if applicable:

Current state card template (60-second scan)

Current state (read first)

Situation now (one line):
-

Top watch-outs (with triggers):
1) Watch-out:
   - Trigger:
   - Time window:
   - Immediate action:
   - Escalate to:
2)
3)

Top actions (owned, timed):
1) Action:
   - Owner:
   - By when:
   - Done:
2)
3)

Unknowns and next checks:
- Unknown:
  - Next check:
  - When:
  - Owner:

IT on-call handoff variant (incident-style)

On-call handoff (current state)

Current incident(s):
- Incident:
  - Impact:
  - Status:
  - Customer/user symptoms:
  - What changed recently:

What we tried (mitigations applied):
-

What is next (next checks):
- Next check:
  - Owner:
  - Time window:

Watch list (triggers and paging thresholds):
- Trigger (if-then):
  - Threshold:
  - Time window:
  - Immediate action:
  - Escalation path:

Links:
- Dashboard:
- Runbook:
- Ticket/incident doc:

Receiver read-back:
- Summary:
- Questions answered:

Operations shift handoff variant

Ops handoff (current state)

Status now:
- Site/area:
- Equipment status:
- Safety checks:

Open issues:
- Issue:
  - Risk:
  - Owner:
  - Next step:
  - Time window:

Watch list:
- Watch-out:
  - Trigger (if-then):
  - Immediate action:
  - Escalation path:
  - Time window:

Top actions:
1) Action:
   - Owner:
   - By when:
   - Done:
2)
3)

The shift memory library: stop re-learning the same lesson every week

Handoff problems repeat because teams rotate and context evaporates. A memory library fixes that by storing patterns plus what actually happened after escalation. It also stops "we always do it this way" from becoming your only safety net.

• Tag by theme: recurring watch-outs, common triggers, repeated unfinished actions.
• Tag by service or rotation: unit, on-call group, incident type.
• Keep outcomes attached: what escalated, what worked, what did not.
• Make it queryable: "have we seen this trigger before?" becomes a quick search.

Real examples: one clean SBAR, one uncertain assessment, one on-call takeover

The pattern stays consistent: SBAR for structure, triggers for action, owners for execution, current state for takeover.

Mistakes that kill trust (and keep the same problems repeating)

• Recommendation with no owner: it floats.
• Watch-outs with no trigger: the next shift cannot act on vague language.
• Assessment stated as certainty: uncertainty hides, then bites later.
• Background dumps: the important detail gets lost in the story.
• No time window: tasks drift across shifts and become "someone else's problem."
• No current state card: the incoming shift starts by digging instead of acting.
• No receiver loop: the handoff ends without confirming shared understanding.