Operator SOPs and Automation: Make Repetition Observable

For two years, Priya ran Friday billing by hand from billing-roster.csv: seat counts, tier codes, a mental note that rows tagged 'L' were legacy customers grandfathered onto a flat rate years ago. She never wrote that down. Everyone just knew.

Six weeks ago the team shipped weekly_biller.py, built by watching Priya work twice and asking her to describe the steps. It reproduced her clicks. It did not reproduce her knowledge of what 'L' meant.

weekly_biller.py wasn't a bad implementation of Priya's process. It was a faithful implementation of a *transcript* of Priya's process, and transcripts drop the exceptions nobody thinks to say out loud because they're too obvious to the person who's been handling them for two years.

An SOP is the artifact that forces those exceptions into the open before code gets written. It names the inputs, the steps, the known exceptions, and what 'done' looks like — as a document a second person can read and a machine can be checked against.

Here's the SOP that should have existed before anyone touched a keyboard:

Every automation candidate climbs the same four rungs, and skipping one is exactly how weekly_biller.py happened. Repetition is just a person noticing they've done the same task three times. A procedure is that noticing written down as steps, inputs, and named exceptions — an SOP anyone can read and run.

An instrumented procedure is the same SOP, still run by a person, but now logging each step as it happens: what was read, what decision got made, what got escalated. This is the rung everyone skips because it feels like busywork. It's actually the rung that turns the SOP into a spec an automation can be graded against.

Automation with receipts is the last rung, not the first. It's the instrumented procedure with a machine doing the steps instead of a person — same log format, same escalation rule, same evidence a reviewer can open afterward. If a step was never observable when a human did it, it doesn't get to be silent just because a script does it now.

This is weekly_biller.py rebuilt against the SOP: Tier is a named input, legacy rows price from legacy-rates.csv, anything unrecognized escalates instead of defaulting. Run it clean first, then try to make it fail silently the way the original did.

Everything above ran in the page. Now build a small version of it where it counts — your machine, real files, an SOP you write yourself first. Pick any recurring task you can fake with fixtures: a weekly report, an onboarding checklist, a billing run. Write the SOP before you write a line of automation code.

When your run produces a receipt, try the three injections from Break it against your own build: an unrecognized case, a duplicate trigger, and an attempt to skip logging. If your escalation and idempotency checks catch all three, you've shipped the chapter's artifact.

What the receipt does not prove matters as much as what it does: it proves this run followed this SOP on these fixtures, escalating what it didn't recognize instead of guessing. It says nothing about next month's data, a Tier value nobody has invented yet, or whether the SOP itself still matches how the business actually works — that's a review a human still has to do, on a schedule, not something the receipt can certify for you.

You watched an automation quietly overbill customers for six weeks because a tribal-knowledge exception never made it into writing, wrote the SOP that would have named it, and built a version that escalates instead of guessing and rejects duplicate runs instead of doubling work. The next chapter turns this same discipline on the automation's own retries and timeouts — what happens when the SOP is right but the infrastructure underneath it isn't.