advanced32 min studyLesson 79 in Engineering

Production readiness and runbooks

Build evidence-based launch gates and executable operational guidance that remain useful when the normal system is failing.

On this page

What you’ll understand

  • Convert a readiness checklist into claims backed by repeatable evidence.
  • Calculate a launch exposure scenario and compare it with a defined impact limit.
  • Write diagnostic and recovery steps with preconditions, verification, and a safe stopping point.

A readiness review should answer whether a specific service can be operated under its intended workload and failure conditions. A checked box saying monitoring exists provides little evidence that a human can distinguish overload from data corruption at three in the morning. Good launch gates connect claims to reproducible tests, named owners, and operational decisions. Runbooks then turn that evidence into short procedures that help an operator act safely when time and attention are limited.

Turn each claim into a reviewable artifact

Start from the service contract, dependency graph, and expected workload. For each material risk, identify the evidence needed before launch: a representative load test, a rollback exercise, an access check, or a restoration report. Record the version, configuration, date, and limitations of the evidence. A capacity number from a different model size or request mix is not proof for this deployment. Readiness is specific to a change and environment; it is not a permanent certification earned once when the service was small.

Define ownership of alerts, quotas, data, and dependencies, including out-of-hours contact paths and escalation. Verify that an operator can obtain required access without relying entirely on the failing service. Name unresolved risks with a mitigation, owner, and review date rather than hiding them behind a passed aggregate score. A weighted checklist can help prioritize review, but a high numerical score must not compensate for an unresolved catastrophic invariant such as duplicate financial effects or an untested destructive migration rollback.

Ebad,scenario=λfe TcontainE_{\mathrm{bad,scenario}}=\lambda f e\,T_{\mathrm{contain}}
For constant original-operation rate λ, exposed launch fraction f, scenario bad fraction e, and time Tcontain until containment, this estimates bad operations. Shared dependencies or growing exposure can make this simple launch model underestimate impact.↔ Scroll wide equations horizontally.

Write runbooks as bounded decisions

Begin a runbook with the symptom, affected service, prerequisites, and immediate containment options. Provide commands or observations that distinguish likely causes, explain expected output, and state what to do when output differs. Mark destructive operations, their scope, and required preconditions clearly. Prefer a small decision tree over a long page of possible commands. An operator should know when to stop and escalate rather than improvising a new recovery protocol because a step failed.

Each action needs a verification step at the user boundary. Restarting a process may restore a health probe while a queue remains blocked or state becomes inconsistent. Include rollback or containment conditions and specify how to preserve diagnostic evidence before changing state when feasible. Keep runbooks accessible during identity, network, and documentation outages using an approved independent path. Remove stale commands through periodic rehearsals with someone other than the author; a fresh operator exposes assumptions that the original developer may no longer notice.

Tcontain=Tdetect+Tdiagnose+Tact+TverifyT_{\mathrm{contain}}=T_{\mathrm{detect}}+T_{\mathrm{diagnose}}+T_{\mathrm{act}}+T_{\mathrm{verify}}
This sequential scenario decomposes time to verified containment. It is not a universal incident model: parallel work, escalation, and repeated attempts require a critical-path timeline. Measure the full interval rather than only command execution.↔ Scroll wide equations horizontally.

Rehearse the launch and the failed launch

A launch plan should include staged exposure, absolute user-outcome limits, comparison with a suitable control, and a tested way to stop expansion. Comparing only candidate and control can miss a shared dependency failure affecting both. Observe enough representative traffic to challenge the risky behavior, and acknowledge that a small canary can miss rare cases or scale-dependent contention. For state changes, verify compatibility between old and new versions before relying on binary rollback; reversing code does not necessarily reverse a schema migration.

After the rehearsal, update the evidence and runbook from what actually happened. Measure detection, decision, action, and verification separately to find the real delay. The queue lab can make a launch-recovery claim concrete: when service rate falls below arrival rate, backlog grows; after rollback, spare capacity determines drain time. Its deterministic fluid model and separate M/M/1 readout do not evaluate release quality. Use it to expose why an apparently quick rollback may still leave users waiting and why recovery headroom belongs in readiness evidence.

Budget a failed launch before expanding it

A fictional launch serves 5,000 original operations/s. The initial candidate receives 2% of traffic. A severe-defect scenario assumes 50% of candidate operations are bad. Detection takes 20 s, diagnosis 10 s, containment action 15 s, and verification 5 s, sequentially.

  1. Verified containment time is 20 + 10 + 15 + 5 = 50 seconds under the stated sequential scenario.

  2. Candidate volume is 5,000 × 0.02 = 100 operations/s, of which the scenario assumes 50 bad operations/s.

  3. Scenario impact is 50 × 50 = 2,500 bad operations. If the agreed initial-launch impact limit is 1,000, this plan exceeds it by 1,500.

The result

Reduce exposure or containment time and retest the plan. For example, 0.8% exposure gives 5,000 × 0.008 × 0.5 × 50 = 1,000 scenario failures, assuming isolation and constant traffic.

Explore the model

Interactive lab

Interactive lab · queue

Rollback is followed by backlog recovery

Compare separate fixed-rate runs with μ below or above λ, resetting each to the initial four backlog units. Changing a slider recalculates the constant-rate trajectory; it does not preserve an earlier backlog. The separate M/M/1 mean readout is not a deployment success estimate.

Rollback is followed by backlog recoveryFluid backlog starts at 4 and follows max(0, 4 + (λ − μ)t). The separate M/M/1 residence-time formula assumes Poisson arrivals, exponential service and λ < μ. Current readings: Fluid backlog: 4; Net rate · λ − μ: −1 /s; M/M/1 mean residence: 1 s. All parameters are adjustable with the labeled controls below.02.557.51001.534.56Elapsed time · sFluid backlogλ < μ
Fluid backlogCurrent time
Fluid backlog
4
Net rate · λ − μ
−1 /s
M/M/1 mean residence
1 s
t = 0 s

Fluid backlog starts at 4 and follows max(0, 4 + (λ − μ)t). The separate M/M/1 residence-time formula assumes Poisson arrivals, exponential service and λ < μ. Parameter changes pause playback and recompute the model at the current elapsed time. Reset restores both parameters and returns time to zero. Playback starts paused. Adjust either parameter, then choose Play or Step.

Look forReadiness evidence should cover time to useful recovery, including deferred work after rollback.

Check your understanding

Which runbook instruction is most operationally complete?

Try it yourself

A candidate receives 1% of 8,000 original operations/s. Assume a defect makes 25% of candidate operations bad for 40 seconds until verified containment. Compute scenario impact. Name one reason an otherwise passing canary may still miss a full-launch failure.

Take a moment to make a prediction or work it out on paper. Open a hint when you need one.

Give me a hint

Multiply original rate by exposed fraction, bad fraction, and duration. Consider shared effects and scale.

Compare with the solution

Scenario impact is 8,000 × 0.01 × 0.25 × 40 = 800 bad operations. A small canary may miss a rare request type, scale-dependent resource contention, or a shared dependency effect that impacts both candidate and control. The passing result supplies bounded evidence, not proof for all full-launch conditions.

Take it with you

  • Readiness claims need versioned, representative, repeatable evidence.
  • Runbooks connect preconditions, actions, verification, and escalation.
  • Launch safety includes shared effects and the full containment and recovery path.

Read further

Original sources and deeper explanations to follow at your own pace.

Optional progress, saved in this browser when available. Revisit any lesson at any time.

Lesson not marked complete.