Why rollouts are an AI-PM problem

In your last PM life, "ship it" was a binary verb. Engineering merged the PR, the deploy pipeline ran, the new code reached 100% of users by lunch. If a bug slipped through, your error monitor lit up and you reverted. The tooling absorbed almost all of the risk for you.

An AI feature breaks that pipeline at exactly the moments you most need it. The model behaves differently on real prompts than on your eval set. Latency creeps up under load. Cost per task is fine in dev and ruinous in prod. The thumbs-down rate climbs only after the fifth percentile of users — the angry ones — actually find the feature. None of this shows up in your error monitor, because nothing crashed. The system is "working." It's just working worse.

Lesson 13 ended with you writing a production-grade PRD whose section 6 was "Rollout plan." This lesson is what goes in that section: the rollout ladder. Five rungs — shadow, 1% canary, 10%, 50%, 100% — separated by launch gates, each gate an explicit, written contract that says "we advance only if these numbers hold." Build the ladder once and you stop holding your breath every time you ship.

One-line takeaway:
A non-AI rollout is one decision (deploy or don't). An AI rollout is five decisions, each gated on metrics — pass rate, latency, cost, refusal rate, thumbs-down — that you decide before traffic ever reaches a real user.

The rollout ladder — five rungs, four gates

Read the ladder left to right. Each box is a rung — a percentage of real traffic that sees the new version. Each amber note below is a launch gate — the specific numeric contract that has to clear before you advance.

Shadow 0% user-facing runs on real prompts Canary 1% ~5k Nairobi sessions live thumbs & logs 10% cost holds in budget no P0 incidents 50% A/B vs baseline sig. lift confirmed 100% all gates clear ship + monitor BORAPAY FRAUD EXPLAINER · ROLLOUT LADDER · KWAME, NAIROBI ↑ gate 0: golden ≥85% ↑ gate 1: thumbs ≥80% ↑ gate 2: cost ≤₹0.40 ↑ gate 3: deflection +6pp Any gate fails → freeze traffic, diagnose, fix or rollback. The ladder is one-way — you do not advance on hope.
What Kwame does with this: writes the five rungs and four gates into the v1 PRD before he books the first eng standup. The ladder becomes the timeline. "We will be at 10% by Wednesday" is a real plan; "we will launch on Tuesday" is not.

What you watch at every rung

A rollout dashboard isn't six metrics dumped on a Grafana board. It's six metrics that each answer a different question — quality, speed, cost, safety, sentiment, escalation. Lose track of any one and a regression slips past the gate.

🎯
Eval pass rate
Live golden-set scoring on a rolling sample of real prompts. The quality floor — drops mean the model is drifting on the actual distribution.
⚡
p50 / p95 latency
Median and tail. Median lies — p95 is where users notice. Anything past 4s for chat answers and abandonment climbs.
💸
Cost per task
Token spend per resolved session, in shillings or rupees, not in dollars. Compare against the unit-economics ceiling from your PRD.
🛑
Refusal rate
Fraction of sessions where the bot punts to "I can't help with that." Too low = it's answering things it shouldn't. Too high = it's broken.
👎
Thumbs-down rate
User-facing dissatisfaction signal. Cheap, lossy, but the only opinion that matters. Spikes here precede churn by about a week.
🆘
Escalation rate
Fraction of sessions that route to a human agent. The trust metric. If it doesn't drop vs baseline, your AI is theatre, not deflection.
Why six and not three:
a single number can lie. Pass rate up but latency up means the model is bigger and slower — net user value may be flat. Cost down but refusal rate up means you saved money by quietly answering fewer questions. PMs read the dashboard like a chord, not a single note.
💳
Real-world scenario
Kwame at BoraPay Nairobi — fraud explainer v1, 10 weeks to ship

Kwame is the AI PM on BoraPay's fraud-and-disputes pod in Nairobi. The team's v1 is a chat feature that explains why a transaction was flagged — "We blocked KSh 1,400 to MERCH-77541 because the device is new and the merchant just registered" — and offers next steps. The CEO wants it live across all 2.4M Kenyan customers in 10 weeks. The compliance officer wants it to never mislabel a legitimate merchant as fraudulent.

Kwame's PRD section 6 is due Friday. He has a v0 behind a flag, used by 800 internal staff. The eval pass rate is 87% on the golden set of 200 disputed transactions. He is tempted to write "deploy on week 8 to all users." That single sentence is what this lesson exists to prevent.

Instead, Kwame writes a five-rung ladder, defines four gates, and locks in a rollback plan. By the end of this lesson you'll have walked the same plan with him.

The stage-by-stage contract

The table below is the one Kwame pastes into the PRD. Five rows, one per rung. Three columns — what he watches, the gate to advance, the trigger that pulls him back. If the row can't be filled in, the rung doesn't ship.

Stage What Kwame watches Gate to advance Rollback trigger
0. Shadow
duration: 5 days
Live golden-set pass rate on a mirror of real prompts; p95 latency on the inference path; cost per simulated session. Pass rate ≥ 85% on shadowed real traffic, p95 latency ≤ 3.5s, cost ≤ ₹0.40 / KSh 0.65 per session. Pass rate < 80%, or any P0 factual error in the shadowed sample (e.g. naming a real merchant as fraud).
1. Canary 1%
duration: 3 days, ~5k sessions
Thumbs-down rate, escalation rate to human agent, refusal-rate distribution, top-10 lowest-rated transcripts read manually. Thumbs-up ≥ 80%, escalation rate not worse than baseline, zero compliance-flag transcripts. Thumbs-up < 70%, or any single transcript that confidently misclassifies a real merchant.
2. 10%
duration: 5 days, ~50k sessions
Cost per task at scale (token bills, retrieval calls), p95 latency under load, refusal-rate stability across regions. Cost ≤ ₹0.40 per session at 10x traffic, p95 ≤ 3.5s, refusal-rate within ±20% of canary value. Cost spike > 2x budget, or p95 > 5s for > 30 minutes, or a regional pocket showing > 3x baseline thumbs-down.
3. 50%
duration: 7 days, randomized A/B
Deflection lift vs holdout 50%, NPS delta, time-to-resolution on disputes, spend per resolved ticket. Statistically significant deflection lift ≥ +6 percentage points vs holdout. NPS not down. Deflection lift < +2pp, or NPS down ≥ 4 points, or time-to-resolution up.
4. 100%
ongoing
All six metrics, weekly. Eval re-run on a refreshed golden set every two weeks. Drift watch on prompt mix. (No further gate — this is steady state.) Any single metric crosses its rollback threshold for ≥ 1 hour, or an external incident (vendor outage, model swap by provider) shifts the distribution.

The columns matter as much as the rows. Without a written rollback trigger, "rollback" is a vibes call you'll lose at 11pm on a Friday. With it, your on-call engineer has a number, and you can sleep.

Triage by severity × user impact

Halfway through the canary Kwame's dashboard will start firing alerts. Not all of them mean rollback. The 2×2 below is the cheat sheet he tapes to his standup wall — read severity (low/high) on the Y-axis, user impact (narrow/broad) on the X-axis. Different quadrants get different responses.

↑ Severity (high) Severity (low) ↓ Narrow ← → Broad Factual error misclassified merchant → FREEZE traffic, hot-fix narrow but bleeds trust Refusal regression bot answers banned topics → ROLLBACK now compliance + scale Slow latency p95 spike, one region → MONITOR, ticket don't pause the ladder Cost spike tokens 30% above budget → HOLD at current % tune prompt, then advance
What Kwame does with this: a Slack alert at 2am no longer triggers panic. He maps the incident to a quadrant, picks the matching action — FREEZE, ROLLBACK, MONITOR, HOLD — and the on-call engineer doesn't have to wait for him to call back. The matrix is the on-call runbook.

What the canary dashboard actually looks like

Day three of the 1% canary. Kwame opens the dashboard before standup. Three tiles for the at-a-glance numbers, four bars for gate progress. Five seconds of looking tells him whether to advance, hold, or pull the lever.

BoraPay · fraud-explainer v1 · canary 1% · day 3 of 3
● live
Eval pass rate
88%
gate ≥ 85% · holding
Thumbs-up
82%
gate ≥ 80% · clear
p95 latency
3.7s
gate ≤ 3.5s · creeping
Cost / session
₹0.31
Refusal rate
9%
Escalation
14%
Thumbs-down
7%

Five of six metrics green. Latency is amber — past the gate but not catastrophic. The bar chart of gate vs actual makes the call visible. Kwame doesn't advance to 10% yet. He pings the inference team, asks if a recent retrieval-cache change is the culprit, and gives himself 24 hours to clear the amber before re-evaluating. That conversation costs him an afternoon. Skipping it would have cost him the rollout.

When to pull the lever
Rollback is a feature, not a failure.

The biggest mistake new AI PMs make is treating rollback as a personal verdict. It isn't. It's the documented response to a metric crossing a documented line. Kwame doesn't ask permission — the runbook gives it. He posts in the on-call channel, flips the feature flag back to the previous version, snapshots the dashboard, and writes the post-mortem the next morning.

Rolling back a canary is cheap — 5,000 users see a flicker. Rolling back from 100% is expensive. That asymmetry is the whole reason the ladder exists.

The AI connection

Every serious AI team — Anthropic, OpenAI's deployment teams, Google DeepMind, frontier labs at scale — runs some version of this ladder. The vocabulary varies (shadow / mirror / dark-launch are synonyms; canary / dogfood / preview overlap), but the structure is identical: zero-impact trial, narrow live trial, broader live trial, A/B confirmation, full launch, with explicit gate metrics between them. The ladder is also how vendor releases work — your foundation-model provider canaries new model versions to a small slice of API traffic before flipping the default. You inherit their ladder whether you know it or not, so build yours on top. shadow-mode canary-release launch-gate rollback feature-flag

⚡ 20-minute drill — design your own ladder

1. Pick the feature.

Take a real AI feature from your team (or an imagined one — say a TaxSetu refund-tracker bot, or a NaijaCart product-search rerank). Write the v1 release sentence in 12 words: what ships to who, by when.

2. Draw the five rungs.

Sketch shadow → 1% → 10% → 50% → 100% on a Notion page or a napkin. For each rung, write one line: how long it lasts and roughly how many user sessions it covers. Stop if you can't size the canary in real numbers — that's the signal that you don't know your traffic yet.

3. Fill the gate + rollback for one rung.

Pick the 10% rung and write its gate (advance to 50% if X) and its rollback trigger (revert to 1% if Y), both in numeric form. Show it to one engineer. If they push back on a number, that's the conversation the rollout was supposed to force.

Interview prep — 5 questions you'll get asked

EasyShadow vs canary — what's the difference?
+
Shadow runs the new version on real production prompts but never shows the output to users — it logs results in parallel for evaluation. Zero user impact, zero risk, but no thumbs-up data because no human ever sees the answer. Canary actually serves a small slice of users (1%, sometimes less) and collects live behavioral signal — thumbs, escalations, abandonment. The right framing: shadow tests the model against the world, canary tests the world against the model. You almost always want both, in that order.
EasyWhat's a launch gate?
+
A launch gate is a written, numeric contract that has to be true before traffic advances to the next rung of the rollout ladder. Not a vibe, not a meeting — a number. "Eval pass rate ≥ 85% over the last 24 hours and p95 latency ≤ 3.5s and cost per session ≤ ₹0.40, otherwise we hold." The point of writing it down is so that on the day of the decision nobody is improvising. Anyone — eng, PM, on-call — can check the dashboard and apply the rule. Gates also force you to know your numbers at PRD time, which is when changing them is cheap.
MediumWhy not just A/B test at 50/50 from day one?
+
Three reasons. First, regressions: a 50/50 split exposes half your users to a feature that might be quietly worse, and the AI failure modes (hallucinations, refusal regressions, latency spikes) hurt trust faster than they hurt KPIs, so the damage shows up after the experiment ends. Second, cost: at 50% you're already paying enterprise-scale token bills, and AI features are notorious for being 2–3x cheaper in dev than at production load. Third, statistical power isn't your bottleneck early on — small samples are enough to spot a 20-point drop in pass rate. The rollout ladder isn't anti-experimentation, it's pre-experimentation: you de-risk to 10% first, then run a real A/B at 50%.
MediumWalk me through writing a rollback plan that doesn't get used as a panic button.
+
Three properties. (a) Mechanical — flip a feature flag, no code change. If rollback requires a deploy, it isn't really rollback, it's a hotfix. (b) Pre-authorized — the runbook names exactly which metric thresholds trigger which response, so the on-call engineer can act without waking the PM at 2am. (c) Rehearsed — at least once before launch, deliberately roll back in staging during a fire-drill, time it. The first time you've ever flipped the rollback flag should not be in a real incident. Properties (a) and (b) make rollback fast; property (c) makes it boring, which is the goal.
HardYour canary metrics are mixed: eval up, latency up, cost flat. Do you advance?
+
No, not on those numbers alone — but the answer interviewers actually want is the diagnosis, not the verb. Eval up + latency up is the signature of a model that got bigger or a chain that got longer. The question is: did latency cross the gate, and if it did, can you trade some quality for speed? Pull p95 by region, by intent, by prompt length. If latency is up uniformly, you have a model-tier choice — accept the trade or downgrade. If it's up only on long prompts, you have a context-window or retrieval problem you can fix without a model swap. Cost flat is the giveaway clue: usually bigger model = higher cost, so if cost didn't move, the change probably wasn't a model swap, it was an orchestration change (maybe a re-rank, an extra retrieval call, or a longer system prompt). The answer to "do you advance?" is "I hold at 1%, ask the inference team what changed in orchestration last sprint, and either revert that change or accept the latency hit explicitly." Advancing on hope is how you build a 50% canary that everyone now agrees was rolled out too early.

Quiz — pressure-test the rollout ladder

Question 1 of 5
Kwame's shadow run shows 88% pass rate but the eval set is 200 transactions from one quarter. He's about to advance to canary. What's missing?
Question 2 of 5
Which of the following is the cleanest definition of a canary in an AI rollout?
Question 3 of 5
At the 10% rung, Kwame sees thumbs-up holding at 81% but cost per session is suddenly 2.3× the budget. The 2×2 incident matrix points him to which response?
Question 4 of 5
Which property is NOT a requirement of a healthy rollback plan?
Question 5 of 5
A vendor pushes a new default model version to its API. Kwame's feature is at 100%. What should the runbook say happens?
0
/ 5
You think in rungs and gates now.

Five rungs, four gates, one rollback lever — that's the spine of every safe AI ship.

Common mistakes — what gets new AI PMs in trouble

Skipping shadow because "we already evaled"
Eval set ≠ real traffic. The distribution at BoraPay's 9pm peak doesn't look like the golden set. Shadow is free risk insurance — running it costs nothing but logging.
Gates as targets, not contracts
"We're aiming for 85% pass rate" is a target. "We will not advance below 85%" is a contract. The first lets you talk yourself into shipping at 82%. The second doesn't.
No named owner on each metric
Latency is "engineering's problem," cost is "finance's problem," refusal rate is "legal's problem" — and so when one drifts, no one notices. Every metric on the dashboard needs one human's name on it.
Rollback never rehearsed
The first time you flip the rollback flag should be a Tuesday afternoon staging drill, not a real Saturday-night incident. PMs who skip the drill discover, mid-incident, that the flag toggles the wrong cohort.

Key takeaways

  • An AI rollout is five decisions, not one — shadow, 1%, 10%, 50%, 100% — each gated on numeric contracts written before launch.
  • Watch six metrics together: eval pass rate, p95 latency, cost per task, refusal rate, thumbs-down, escalation rate. A single number always lies.
  • A launch gate is a written numeric contract; a rollback trigger is its mirror. Both go in the PRD, both are ratified before the first user sees the feature.
  • Use the severity × user-impact 2×2 to triage canary alerts: factual error → freeze, refusal regression → rollback, slow latency → monitor, cost spike → hold.
  • Rollback is a feature, not a failure — make it mechanical, pre-authorized, and rehearsed. Boring rollback is the goal.
Africa & India's Best AI Academy
🤖 AI-first 🎓 Placement Assistance

You can now ship AI without holding your breath.
Next — price what you've built.

Join the Best AI Program: The AI-Era Agentic Engineer — 5 months, fully online, with placement assistance. Week 1 is free.

Explore The AI-Era Agentic Engineer →