Coldcode Si Labs Library

Nobody Was Watching

Book · first edition · Courage Garikai
View-only edition. No download from this page.

Nobody Was

Watching

How founders run autonomous growth systems without harming strangers, their brand or themselves Theories, frameworks and one candid case for founders, growth leads and strategists

Courage Garikai

Funded by Coldcode Si Labs C O L D C O D E S I L A B S L I B R A R Y F I R S T E D I T I O N · 2 0 2 6

Contents

About this edition ............................................................................................................... PART I · The quiet machine 1 · The suite that passed ................................................................................................. 2 · Why autonomy got cheap ........................................................................................... 3 · Unwitnessed autonomy .............................................................................................. 4 · Strangers pay first ....................................................................................................... PART II · Anatomy of an unwatched pipeline 5 · The wrong recipients .................................................................................................. 6 · Borrowed identities ..................................................................................................... 7 · Duplicate clocks .......................................................................................................... 8 · Silent failure ................................................................................................................ 9 · Misreading the world ................................................................................................... 10 · Authority and the money path ................................................................................... PART III · Witnessing 11 · The witness map ....................................................................................................... 12 · The account inventory .............................................................................................. 13 · Reading the ledgers .................................................................................................. 14 · Dry runs and the defects that fixes create ................................................................ 15 · Health screens that tell the truth ............................................................................... PART IV · Building to be watched 16 · One clock, one voice, one identity, one surface ....................................................... 17 · Outreach that strangers can stop ............................................................................. 18 · Armed, not active .................................................................................................... 19 · Ceilings as design ................................................................................................... 20 · Stops and the human in the loop ............................................................................. PART V · Leading autonomous growth 21 · Metrics that hide harm ............................................................................................. 22 · Law, ethics and reputation ...................................................................................... 23 · Governing the builders ............................................................................................

About this edition

This book is written for founders, solo operators, growth leads, strategists and directors who run, or are about to run, growth systems that act without a person in the loop. Examples are a scheduled job that finds prospects, a runner that emails them, a module that posts to social accounts and a webhook that switches a customer's account on or off when a payment arrives. It is a discussion book. Each chapter sets out a question, the theory that helps answer it, a working case, a framework you can use, the limits of the evidence, the points on which reasonable people disagree, questions for discussion and a short exercise. The case is Tapstall, a shop-link service for informal and social-commerce merchants in Zimbabwe and South Africa. On 28 October 2026 its live version, 1.9.1, was audited and then rebuilt the same day as version 2.0.0. On the morning of the audit its own test suite passed 420 tests out of 420. In the same code, the outreach runner had already emailed 17 addresses, and 14 of them were not prospects at all. Tapstall belongs to the same owner who commissions the work of Coldcode Si Labs. The audit and the rebuild were carried out by the owner working with AI coding agents, and the same process produced the analysis in this book. It is therefore a bounded case, not an independent evaluation. At the time of writing Tapstall had no paying customers. Nothing in this book is evidence that its pipeline succeeds commercially. This book does not say how the first version of the pipeline was produced. Some of its defects resemble failure modes documented in AI-assisted work. They are equally consistent with one busy person wiring several products together on shared accounts. Where that question arises it is treated as open. Throughout, three kinds of statement are kept apart: Research findings are cited to their sources. Facts about the case come from the live deployment, its stored data, its sent mail, its account inventory and its commit history, as of October 2026. • •

First edition · 2026

Proposed frameworks, constructed examples and recommendations are labelled as such. They are proposals to test, not proven laws. The people and businesses who received messages from the system are not named. Neither are the three real small businesses it contacted. No professional biography, endorsement, ISBN or independent audit is claimed. The author and funding credits are those specified by the commissioning owner. AI tools assisted in drafting this

The promise of this book

Until recently, running a growth operation meant employing people to do it. Someone researched prospects, wrote to them, posted on social media and kept the books. Each of those people was also a witness. A researcher who found that a "prospect" was a weather service did not write to it. A salesperson who saw a reply saying "please stop" stopped. A bookkeeper who saw a payment that matched no customer asked about it. Most of the time these judgements were never written down, because nobody needed to write them down. They happened in someone's head on the way to doing the job. Automation removes the people, and with them the witnesses. A small venture can now run a lead hunter, an email runner, a social poster and a payment matcher on free cloud services, at no cost, around the clock. It can build all of that in days. What it does not get for free is anyone placed to notice when the system is doing something it should not. The machine does exactly what it was told. The effects land on strangers, on other ventures and on the founder's own reputation. No report of those effects comes back. This book calls that condition unwitnessed autonomy. It argues that founders who automate growth need a new habit to match. Before switching an action on, they should ask who will see its effects and how word of those effects will reach them. The title comes from the case. Every problem in Tapstall's growth pipeline was visible to someone: the magazine reviewer who received a sales email, the followers of another brand who saw Tapstall's posts, the merchant whose store was suspended without the warning email ever being sent. Nobody was watching on behalf of the business. • © 2026 Courage Garikai. All rights reserved. Published by Coldcode Si Labs Library, Harare. No part may be reproduced without written permission, except the frameworks and exercises, which are meant to be copied.

Who this book is for

Founders and solo operators who automate prospecting, outreach, posting or billing, and must decide what to switch on and what to watch. Growth leads and strategists who design pipelines, choose channels and set targets, and need to know which metrics hide harm. Operators of several products who share accounts, mailboxes and credentials across ventures, and need to see how one product can act in another's name. Directors, investors and advisers who are shown growth dashboards and need questions that get past them. Educators and consultants who want a contemporary case and frameworks to teach with. No programming knowledge is assumed. Technical details appear only where they change a decision, and are explained when they do.

How to use this book

Each chapter follows the same pattern: An opening question that the chapter tries to answer. Theory: the research and ideas that bear on the question, cited so that you can read further. The Tapstall case: what the case shows, and what it does not. A framework or tool you can apply. What the case does not show: the limits of the evidence for that chapter's claims. Points of debate: where the argument is contestable. Discussion questions for a reading group, a class, a leadership team or your own reflection. Apply it: a short exercise for your own systems. • • • • • 1. 2. 3. 4. 5. 6. 7. 8.
The chapters can be read in order or by part. Groups meeting weekly can take one part at a time over five sessions. Chapter 25 collects every framework in one place. Chapter 26 is a facilitator's guide, Chapter 27 is a glossary and Chapter 28 lists the references.

The structure

Part I · The quiet machine (Chapters 1–4) explains how a growth system can pass every test while harming people, defines unwitnessed autonomy, and shows why strangers bear the first costs. Part II · Anatomy of an unwatched pipeline (Chapters 5–10) dissects the forms the problem takes: wrong recipients, borrowed identities, duplicate clocks, silent failures, misread replies and leaks of authority on the money path. Part III · Witnessing (Chapters 11–15) sets out the witness map, the account inventory, reading the ledgers, dry runs that catch the defects that fixes create, and health screens that tell the truth. Part IV · Building to be watched (Chapters 16–20) describes how to build so that effects are seen: one clock, one voice, one identity and one surface; outreach that strangers can stop; distribution that waits for its own accounts; free-tier ceilings as design; and kill switches. Part V · Leading autonomous growth (Chapters 21–24) addresses metrics, law and reputation, governing the agents and tools that build these systems, and a ninety-day programme.

A note on the case

Tapstall gives a merchant a shop page: a menu, a WhatsApp ordering button, and a way for buyers to pay the merchant directly with a payment reference that the service matches. It costs US$60 a year after a 60-day free period, with card checkout through Whop, a third-party payment platform. It runs on a free serverless tier, with scheduled jobs on GitHub Actions. Its growth pipeline has five parts: a lead hunter that looks for small businesses; • • • • • •
a gate on the server that decides which leads may be contacted and assigns them; an outreach runner that sends the emails and reads the replies; sellers, independent people paid a 30% commission, who work the leads that reply; a press module that posts to social accounts three times a day. That is a typical shape for a small venture with ambition and no budget. Every problem described in this book arose in ordinary components doing ordinary jobs. That is the point. The case is not exotic, and the lessons are not about one product. The audit coded 24 defects: 11 found in the audit and 13 found during the rebuild, four of which the rebuild itself introduced. Sixteen of the 24 (67%) were what this book calls witness gaps. None of the 24 was found by the existing test suite. The working paper that accompanies this book, Unwitnessed Autonomy (Coldcode Si Labs Working Paper 2026-03), sets out the coding and the method in academic form. • • • •
PA R T I

The quiet machine

Nobody Was Watching

1 · The suite that passed

Opening question. If every test passes, what do you actually know about what your system did yesterday? On the morning of 28 October 2026, Tapstall's test suite ran 420 tests and passed every one. The tests checked the code that was live in production at that moment. By the standards most small teams use, the product was in good health. Its owner console showed a pipeline with leads in it, a press module posting three times a day and a growth runner sending emails on schedule. By the evening of the same day, an audit had found that, in that same code: the outreach runner had emailed 17 distinct addresses, and 14 of them were not prospects at all; those emails had gone out from the owner's personal mailbox, which was also the published support address of a separate venture; the press module had been posting into that other venture's social account for eight days; an old copy of the service was still running on the same cloud account, against live data, with a secret that should no longer have worked; every email the product promised to send to its own merchants had silently gone nowhere since launch. None of those problems was a test failure, and none of them could have been. This chapter is about why.

What a test can see

A test is a small experiment. It gives a piece of code an input and checks the output against an expectation. When it passes, it tells you that this code, given this input, in this test environment, produced the expected result. That is valuable knowledge. It is also narrow in four ways that matter for autonomous systems. • • • • •
A test sees the code, not the deployment. The test suite ran against the code in the repository. It could not see that an older copy of the service, built from older code, was still deployed under another name on the same account. Nor could it see that the credentials bound to the live service belonged to someone else. Those are facts about the deployment: about accounts, settings and secret stores. Code does not contain them. A test supplies its own inputs. The outreach tests fed the gate realistic-looking leads. They did not feed it a magazine's contact page, a weather service's footer or a literal placeholder address, because nobody imagined those would arrive. Yet those were exactly what the lead hunter was producing. The test inputs were plausible. Production's inputs were not. A test supplies what production lacks. The merchant-mail tests provided a mail sender, so the code that called it passed. In production, no mail sender was ever connected. The function ran, found nothing to send through and returned quietly. The test proved that the code would send mail if it could. Production never could. A test cannot see strangers. The most serious effects of the pipeline landed outside the system altogether: in inboxes, on social timelines, in merchants' accounts. No test observes a stranger's reaction, because no test has a stranger in it. The safety scientist Nancy Leveson (2011) argues that accidents in complex systems usually come not from failed components but from unsafe interactions among components that each work as designed, and from controllers that lack accurate feedback about the process they control. The Tapstall pipeline fits that description closely. Its parts worked. What failed was the feedback.

Normalised success

Diane Vaughan's (1996) study of the Challenger launch decision introduced the idea of the normalisation of deviance. An organisation repeatedly sees a warning sign without a disaster following, and gradually comes to treat the sign as normal. A passing test suite can produce something similar in reverse, which we might call normalised success. Each green run makes the next one feel like proof, until "the tests pass" stands in for "the system works". The suite was not lying. It was answering a narrower question than the one people heard.
Richard Cook's (1998) short essay "How Complex Systems Fail" makes a related point: complex systems run in degraded mode all the time, and the defences that hide that fact also hide the next failure. In Tapstall, the duplicate schedulers described in Chapter 7 were such a defence. They made the pipeline appear to run even while its main scheduler had been failing every night.

The Tapstall case

The audit did not set out to second-guess the tests. It began by reading the live state of the system: what was stored, what had been sent and what was deployed. In practice this meant four activities: listing the leads the system held, and reading them; reading the mail the runner had sent and the mailbox it had read; listing every deployment and credential on the accounts the owner used; walking through the product as an attacker would. The findings came from those activities, not from the code alone. Of the 24 defects eventually coded, reading live state and ledgers found six, inspecting sent mail and recipients found five, inventorying credentials and deployments across accounts found five, adversarial walk-throughs found three and live dry runs found two. Reading the code found eight, mostly after the other methods had pointed to where to look. Several defects were found by more than one method. The test suite found none. That does not make the tests useless. The rebuilt service has 421 tests, several of them written for problems the audit exposed: unsubscribe handling, retrying a failed dispatch, the door that rejects junk leads. Those tests now hold the fixes in place. But they were written after someone had seen the problem in the world. Tests protect what you already know. They do not tell you what you do not know.

Framework: the Four Blind Spots check

Before trusting a green test run as evidence about an autonomous system, ask four questions. Each corresponds to one of the limits above. • • • •
Blind spot Question Evidence that answers it Who can supply it Deployment What else is deployed, under what names and with which credentials? A current inventory of every deployment, schedule and secret on every account The operator, from the provider consoles Inputs What did the system actually receive in the last week? A sample of real inputs, read by a person Anyone with read access to stored data Absent dependencies Which functions depend on something the tests provide but production may not? A list of every external service a function calls, checked against what production has bound The builder, then the operator Strangers What did the system do to people outside it, and how would we know? Sent mail, published posts and changed accounts, read by a person, plus every channel by which those people can reply The operator The check is deliberately low-tech. It asks for an hour of reading rather than more tests. The point is not that tests are wrong, but that an autonomous system makes claims about the world, and only the world can confirm them.

What the case does not show

The case shows that one tested pipeline carried 24 defects its suite could not see. It does not show that tests are generally useless, or that every pipeline with a large suite hides similar problems. The suite in question was written alongside the product by the same process, and a suite written by someone else, with adversarial inputs and contract checks on the deployment, might have done better. The case also cannot say how long each defect had existed before the audit, except where dates were recorded, as with the eight days of posts into another account. What it does show is narrower and still useful: on one real system, on one day, a full pass and a large share of serious harm coexisted, and the harm was found by reading the world, not the code.

Points of debate

"Better tests would have caught this." Partly. A contract test could have checked that a mail sender was bound in production. A property test with adversarial inputs might have shown the hunter accepting junk. But the borrowed identities and duplicate deployments were not in the code at all. Asking tests to find them stretches the word "test" to cover something else: inspecting the deployment. That inspection is worth doing. It is better to call it what it is. "This is just monitoring." Monitoring usually watches the system's own health: errors, latency, uptime. Every one of those indicators was fine. What was missing was observation of the system's effects on others. That is a different discipline, and Part III describes it. "A small venture cannot afford this." The audit in this case took one day, including the rebuild. The cost of not doing it was falling on strangers and on a second venture, and would eventually have fallen on the owner's mail and social accounts. Chapter 19 returns to the economics.

Discussion questions

Which of your systems has a test suite that you treat as evidence that the system "works"? What, specifically, does it test? When did you last read a sample of the real inputs your automation received? What did you find? Which of your automated actions land on people outside your organisation? How would you learn that one had gone wrong? Have you seen normalised success in your own work, where repeated green signals came to stand for something they did not measure? Who in your organisation is responsible for what your automation does to strangers? Is it written down?

Apply it

Pick one automated action that touches people outside your business: a scheduled email, a social post, an account suspension. For that action alone, fill in the Four Blind Spots table above. Do not write any code. Spend no more than an hour, and 1. 2. 3. 4. 5.
spend most of it reading: the last 20 things the action did, to whom, from which account and on which schedule. Note anything that surprises you. If nothing surprises you, ask whether you looked at the actions themselves or at reports about them.

2 · Why autonomy got cheap

Opening question. What changed so that a one-person venture can now run a growth operation that once needed a team, and what did it lose in the process? A decade ago, a founder who wanted to email a few hundred prospects a week, post on social media daily and reconcile payments automatically would have needed staff, paid software or both. In 2026 the same founder can do it for nothing. Free serverless platforms run code on a schedule. Free continuous-integration services run longer jobs. Free mailboxes send through standard mail protocols. Social networks offer posting interfaces. Payment platforms send webhooks. AI coding agents can wire all of it together in days. Tapstall's entire growth pipeline ran on free tiers. That is a genuine achievement, and this book does not argue against it. It argues that something came out of the operation along with the cost: the people who used to notice.

Three things that got cheap

Execution got cheap. Serverless platforms charge nothing for small volumes. Tapstall's server ran on a free tier allowing 100,000 requests a day, with scheduled triggers included. Its longer jobs, like the lead hunter and the outreach runner, ran on GitHub Actions. A job that runs every hour costs the same as one that runs once a week: nothing. Integration got cheap. Mail, social posting, maps data and payments are all reachable through public interfaces. Connecting them once took specialist knowledge. Now it takes a credential and a few lines of code, and AI tools will write those lines. Building got cheaper, or at least feels cheaper. The evidence on how much AI coding tools speed up building is mixed. Peng and colleagues (2023) found that developers given an AI pair programmer finished a defined task about 56% faster
in a controlled experiment. Becker and colleagues (2025), in a randomised trial with experienced open-source developers working on their own repositories, found that developers using AI tools took 19% longer, while believing they had been about 20% faster. Whatever the true speed-up, the perception of cheap building is widespread, and it encourages founders to switch on more automation, sooner.

What did not get cheaper

Judgement about effects did not get cheaper. Deciding whether an address belongs to a real prospect, whether a post is going to the right account, or whether a payment matches the right customer still requires someone to look. Automation can apply rules. It cannot notice that the rules are producing nonsense unless someone has built a way for it to notice. Witnessing did not get cheaper. It disappeared. In a staffed operation, observation happens as a by-product of doing the work. A researcher sees the page before copying the address. A person scheduling a post sees which account is logged in. When the work is automated, that by-product vanishes. Nobody decides to remove the witness. The witness simply goes away with the job. Lisanne Bainbridge's (1983) classic paper "Ironies of Automation" made this argument about industrial control rooms over forty years ago. Automating a process leaves the human operator with the tasks that could not be automated, usually the hardest ones, such as noticing that something is wrong. At the same time it removes the routine contact that kept the operator's understanding of the process current. The more reliable the automation, the less practised the operator is at the moment they are needed. A founder whose outreach runs itself is in the position Bainbridge described: in charge of a process they no longer touch. Parasuraman and Riley (1997) distinguished four ways people relate to automation: use, misuse (over-reliance), disuse (neglect) and abuse (automating without regard for the consequences for operators). Small-venture growth automation invites a particular combination of the second and fourth: switching on automation because it is possible, and then relying on it because it seems to be running.

The Tapstall case

Tapstall's pipeline was built to be autonomous. That was a stated design goal: the owner would be involved only in decisions that mattered, and the system would do the rest. The lead hunter ran on a schedule, the gate allocated leads, the outreach runner sent messages and read replies, and the press module posted. Each part had been tested. Each was running. What the pipeline lacked was any point at which a person, or a mechanism acting for one, saw the effects. Three facts from the audit illustrate this: The hunter had filed 109 leads by the morning of the audit, 66 of them parked in a "research hold" for later review. No review mechanism existed. The held rows included dictionary entries, weather forecasts, homework-help pages, a pizza menu from the United States and an encyclopedia article. The outreach runner sent its messages through the owner's personal mailbox. Nothing in the console showed which mailbox was in use, so nobody could see that it belonged to another venture. The press module reported success each time it posted. It did not report where it posted. Each of those was invisible not because it was hidden but because nobody had been given the job of looking. In a staffed business, someone would have been sitting in each of those places.

Framework: the Lost Witness inventory

For any automated workflow, list the human jobs it replaced and the observations those jobs used to make as a side effect. Then ask whether each observation still happens anywhere. Replaced job Observation it made as a side effect Does anything make it now? If not, the cheapest way to restore it Prospect researcher "This page is not a business" No; hunter files anything with an address Gate at ingest and at contact; a person reads a weekly sample Salesperson writing emails "I am writing from the right address" No One named mailbox, shown on the console • • •
Replaced job Observation it made as a side effect Does anything make it now? If not, the cheapest way to restore it Salesperson reading replies "This person asked us to stop" Partly; keyword match Parse only the reply's own words; honour unsubscribe links Social media assistant "I am logged into our account" No Each rail shows the handle it posts as Bookkeeper "This payment matches nobody" No; unmatched payments filed silently Unmatched payments shown on the console The table is a constructed example drawn from the case. The method is general. It does not ask whether automation is good or bad. It asks what was lost when it arrived, and whether that loss was a decision.

What the case does not show

The case does not measure what automation saved Tapstall. There was no staffed version to compare with, and no record of how many hours the pipeline replaced. Nor does it show that a person doing the same jobs would have avoided every defect; people also email the wrong address and post from the wrong account. The claim is more modest. Each specific observation that a person would almost certainly have made, such as noticing a weather forecast filed as a lead or seeing which account they were logged into, was made by nobody, and nothing in the design had been built to make it instead. Whether that is typical of small-venture automation is a question for more cases, and Chapter 25 lists the propositions that would test it.

Points of debate

"The answer is just less automation." Not necessarily. The case's rebuild kept the pipeline autonomous. It restored witnesses to it instead: a gate at the point of contact, a console that shows identities and effects, a reply parser that reads only the sender's own words. Whether a given action should be automated at all is a separate question, treated in Chapter 20.
"AI tools make this worse." Perhaps. Cheap building lowers the cost of switching on more automated actions without lowering the cost of watching them. But nothing in the Tapstall case requires AI to explain it. Every defect is the kind a busy person could create. This book treats any special role for AI tools as a hypothesis. "Free tiers are the problem." Free tiers impose ceilings, such as daily write limits and caps on outgoing calls, that shaped several defects. They also shaped good design, as Chapter 19 shows. The ceilings are a constraint to design for, not a cause.

Discussion questions

List the automated actions your business runs. Which of them replaced a job a person used to do? For each, what did that person notice that nobody now notices? Have you experienced Bainbridge's irony, being responsible for a process you no longer touch closely enough to understand? How do you account for the perceived speed of AI-assisted building when you plan what to automate? Does the Becker and colleagues result change your view? Who decided, explicitly, that each observation you listed in question 2 could be dropped?

Apply it

Complete the Lost Witness inventory for one workflow. For every row where the answer in the third column is "no", decide one of three things: restore the observation cheaply, accept the risk explicitly and write down why, or stop automating that step. Put the decision and its date next to the row. The exercise is finished when no row is left undecided. 1. 2. 3. 4. 5.

3 · Unwitnessed autonomy

Opening question. What exactly is missing when an automated system harms people and nobody in the business finds out? The last two chapters described a gap between what a system's tests say and what it does, and showed how automation removes the people who used to notice. This chapter gives that gap a name and a shape, so that it can be looked for deliberately.

A definition

Unwitnessed autonomy is the condition of an automated system that takes consequential actions on parties outside its boundary when no party is placed to observe those actions' effects and report them to the operator. Each part of the definition matters. Automated. The actions start from a schedule, an event or a rule, not from a person deciding each one. Nothing sophisticated is required. A scheduled job and a mail library are enough. Consequential actions on parties outside its boundary. The concept covers actions with effects on others: an email in a stranger's inbox, a post on a social account, a payment matched or not, a merchant's store suspended. A job that rebuilds an internal index is not in scope, however badly it fails. No party is placed to observe. This is the core. The effects may be visible to someone. The people who received Tapstall's misdirected emails certainly saw them. What is missing is a channel from that observer back to the business. A magazine reviewer who receives an irrelevant sales email from what looks like a support address has no reason, and often no easy way, to tell the sender. Report them to the operator. The concept is about control. A system is unwitnessed when the person running it has no feedback about what it does to others, however much feedback they have about the system itself. • • • •
Leveson (2011) describes safety as a control problem: a controller acts on a process and needs feedback about the process's state. Unwitnessed autonomy is what happens when the feedback loop runs from the system to its own dashboards but never from the world back to the controller.

What it is not

Three neighbouring ideas are easy to confuse with this one. Ordinary bugs. A bug is a failure of computation that a test with the right input would reveal. Unwitnessed autonomy can involve perfectly correct computation. Tapstall's mail-sending code worked. That was the problem: it worked from the wrong mailbox, to the wrong people. Technical debt. Sculley and colleagues (2015) describe hidden technical debt in machine-learning systems: shortcuts whose costs the owner defers and later pays. Unwitnessed autonomy imposes costs on others, now. The owner may never pay them, unless a mail provider suspends the account, a social network bans the handle or a regulator acts. Spam. Spam is unsolicited bulk messaging, usually deliberate. Unwitnessed autonomy can produce spam without intent, as in this case. But it also covers posting under another brand's identity, failing to send mail you promised, mismatching payments and running duplicate copies of a service. None of those is spam.

The four witnesses

If a business wanted to witness every action its automation took on the outside world, it would need to know four things about each action. The recipient. Who received it, and should they have? What did they say back? The effect. Did the action actually happen and do what it was meant to? The identity. Whose name, account and credential did it use? The clock. What triggered it, and how many things are triggering it? 1. 2. 3. 4.
A witness gap is a defect that hides one of those four from the operator. Five kinds of defect in the Tapstall case were witness gaps: externalities and boundary misreadings hid the recipient; silent failures hid the effect; borrowed identities hid the identity; multiplicity hid the clock. Together they accounted for 16 of the 24 defects (67%). The remaining eight were ordinary engineering problems: three leaks of authority, two surfaces that sprawled, two dependencies that could not take the load and one build defect. They matter, and Chapter 10 covers the most serious of them. But they are not the subject of this book, because existing practice already knows how to find them. The proportion is the striking finding. Two-thirds of what was wrong with a working, tested, growing pipeline was not a fault in any computation. It was a gap in what the operator could see.

The Tapstall case through the four witnesses

Here is the audit's picture of the first version, organised by witness. Witness What the operator could not see Examples from the case Recipient Who was being contacted, and what they replied A weather service, a placeholder address and a games company were emailed; the runner read the system's own footer, quoted back in a reply, as an opt-out Effect Whether actions happened Merchant emails never sent; a nightly dispatch that failed but was marked done; posts queued for accounts that did not exist Identity Whose accounts were used Outreach sent from another venture's support mailbox; posts sent to another venture's social account Clock How many things were acting Outreach and hunting fired by two schedulers, doubling the daily cap from 20 to 40; three old copies of the service still running on their own schedules • • • •
Every item in that table was, in principle, discoverable. Each one was eventually discovered by someone reading the right thing. The problem was not that the information did not exist. It was that the system had been built with no place to put it in front of the operator.

Framework: the Witness Question

The working paper derives a full instrument from these four witnesses, the witness map, which Chapter 11 develops. Its core is a single question, asked of every automated action that touches the outside world:

"If this went wrong tomorrow, who would see it first, and how would we

hear from them?"

Three answers indicate a witness gap: "The recipient, and we wouldn't." The effect lands on someone with no channel back. "Nobody." The action could fail completely without any record. "We'd see it on the dashboard." Check whether the dashboard reports the effect or merely the attempt. In the case, the dashboard reported that posts were "sent", but not where. Good answers name a mechanism: a delivery confirmation, a bounce feed, an unsubscribe link, a console row that shows the account used, a person who reads a weekly sample.

What the case does not show

The 67% figure comes from one audit and one rebuild, coded by people with an interest in the case. Another coder might draw the boundaries between classes differently. A borrowed identity that also caused externalities, for instance, was coded once, under its primary class. The figure is therefore an indication, not a measurement. The case also cannot show that the four witnesses are the right four. They emerged from the defects found, and a different venture might reveal a fifth, • • •
such as a witness on timing or on the content of what is said. The concept is offered as a lens. Its value will be settled by whether it helps other founders find problems they would otherwise have missed.

Points of debate

"Every system has witness gaps; this is just risk." True in a sense. But risk you have not identified is not risk you have accepted. The point of the concept is to make the gaps visible so that the decision to leave one open is a decision. "The recipients could have complained." Some may have. But the system was sending from a mailbox it also read automatically, marking messages as read before any person saw them. Even a complaint would have been unlikely to reach anyone. That is part of the gap. "Is this really new?" The parts are old. Leveson, Bainbridge and Vaughan described them decades ago in high-hazard industries. What is new is the scale at which tiny ventures can now take autonomous actions on the public, and the absence of any professional discipline, like process safety, that would make them look.

Discussion questions

Choose one automated action in your business. Answer the Witness Question for it honestly. Which of the four witnesses (recipient, effect, identity, clock) is weakest in your systems? Why? Can you think of an action whose effects are visible to someone, but where there is no channel from that person to you? How would you distinguish a witness gap from an ordinary bug in your own work? Is 67% plausible for your systems? What would you need to find out to estimate it? 1. 2. 3. 4. 5.

Apply it

List every automated action your business takes on someone outside it. For each, write down one answer to the Witness Question. Mark each answer green (a named mechanism), amber (a person who might notice) or red (nobody, or the recipient with no channel). Count the reds. Keep the list. Chapter 11 turns it into a witness map.

4 · Strangers pay first

Opening question. When your automation makes a mistake, who bears the cost, and why is it usually not you? The first cost of an unwatched growth system is rarely paid by the business that runs it. It is paid by the people who receive its messages, by the platforms that carry them and by other businesses whose names are borrowed. Only later, if at all, does the cost come back to the founder. This chapter explains why, using some of the oldest ideas in economics, and why founders should care even when the cost seems to fall elsewhere.

Externalities

An externality is a cost or benefit that falls on someone who did not choose it and is not compensated for it. Pigou (1920) used the example of sparks from steam locomotives setting fire to farmers' fields: the railway did not pay for the damage, so it ran more trains, and ran them more carelessly, than it would have if it did. Coase (1960) reframed the problem. Externalities are reciprocal, he argued, and in a world without transaction costs the parties would bargain to an efficient result. In the real world, transaction costs are often too high for anyone to bargain at all. Unsolicited email is a textbook case of high transaction costs. Each recipient bears a small cost: a moment of attention, a decision to delete, perhaps a flicker of irritation. That cost is too small for any one recipient to seek compensation, and there is no practical way to bargain with the sender. So the sender never feels it. Herbert Simon (1971) observed that in an information-rich world, information consumes the attention of its recipients, so a wealth of information creates a poverty of attention. Every automated message spends someone else's attention.

The inbox as a commons

Hardin (1968) described the "tragedy of the commons": when a resource is open to all, each user gains the full benefit of using it more but bears only a fraction of the cost of depleting it, so the resource is overused. The shared inbox ecosystem works like a commons. The trust that recipients place in unknown senders is the shared resource, and so is the willingness of mail providers to deliver their mail. Every careless sender draws it down. Ostrom (1990) showed that commons do not always end in tragedy. Communities often govern shared resources through rules, monitoring and graduated sanctions. Email has developed exactly such institutions: standards, such as the unsubscribe headers described in Chapter 17; monitoring, such as the bounce reports and spam complaints that mail providers track; sanctions, such as Google's 2023 requirements that bulk senders authenticate their mail, offer one-click unsubscription and keep complaint rates low (Kumaran, 2023). A founder who runs automated outreach is entering a governed commons, whether or not they know its rules. Research on spam's economics shows how lopsided the costs are. Kanich and colleagues (2008) infiltrated a spam botnet and measured conversion directly: roughly one sale for every 12.5 million emails sent in one pharmaceutical campaign. Levchenko and colleagues (2011) traced the spam value chain end to end. They showed that a few payment and fulfilment points carried most of the business, which is why pressure on those points was effective. The lesson for a legitimate founder is not that they are a spammer. It is that the economics of unsolicited messaging work against the recipient by default, and that the institutions of the commons will eventually push costs back onto senders who ignore them. • • •

The Tapstall case

Tapstall's first version emailed 17 distinct addresses. Fourteen were not prospects. Between them they received 16 messages. The recipients included: a technology magazine's reviewer; a large platform's support desk; a financial data firm's support desk; the webmaster of a government weather service; privacy and reprints desks; a Japanese games company; an inventory software firm's support desk; an events listing site; a news editor, twice; a private individual, twice; a literal placeholder address of the kind found in documentation examples. Each received a sales pitch for a shop-link service aimed at informal merchants in Zimbabwe and South Africa. Not one was a plausible customer. Those emails cost Tapstall nothing directly. They cost the recipients attention. They cost the sending mailbox some of its reputation with mail providers, and that mailbox belonged to another venture's support desk, so the cost spread to a business that had nothing to do with Tapstall. The press module, posting three times a day into that same venture's social account, spent the attention of that venture's followers and some of its brand. Only three of the 17 addresses belonged to real small businesses. Even those three received mail from a support address that had no connection to Tapstall's brand. Note the shape of the harm. Strangers paid first, in attention. A second venture paid next, in reputation. Tapstall itself had paid nothing yet. Had the pipeline continued, though, the cost would have arrived: as a mailbox flagged by providers, a social handle reported, or a regulator's letter. Chapter 22 discusses the law. • • • • • • • • • • •

Framework: the Cost Path

For each automated action that reaches outside the business, trace the path a mistake's cost would take, and how long each step would take to reach you. Step Who pays What they pay How it reaches you Typical delay The recipient Attention, irritation, possible risk It usually does not; there is no channel Never, unless you build one The platform or carrier Abuse handling, reputation of the network Through spam complaints, deliverability and rate limits Days to weeks Any borrowed identity's owner Brand, deliverability, followers Through that owner, if they notice Variable; possibly never Your sender identity Reputation score, account standing As reduced delivery or suspension Weeks You Lost channel, legal exposure, reputation Directly, and often all at once Months The longer the path, the stronger the case for building a shortcut: a way for step 1's cost to reach you at step 1. That is what an unsubscribe link, a bounce handler and a reply parser are for. They are not courtesies. They are the cheapest feedback channels in the system.

What the case does not show

The case cannot measure the harm done to recipients. Nobody asked them, and none was known to have complained. It also cannot show whether the other venture's sender reputation or social standing was actually damaged; the effects of 16 misdirected messages and eight days of posts may have been small. The argument of this chapter does not depend on the harm being large. It depends on the direction of the cost path: whatever the harm was, it fell first on people who had no say and no channel back, and it would have grown for as long as the rules that produced it kept running. The case shows that path clearly. Its size remains unknown.

Points of debate

"A few misdirected emails are trivial." Individually, perhaps. But automated systems repeat. A runner that sends 20 a day to the wrong people sends over 7,000 a year. The defect is not the 16 messages; it is the rule that produced them, running indefinitely. "Recipients can just delete the email." They can, and most will. But Coase's point applies: the cost is real, it is simply too small for any one person to fight. A business that relies on its costs being too small to contest is relying on a commons it does not maintain. "Every growth channel imposes some cost on someone." True. Advertising spends attention too. The difference is consent and control: recipients of advertising chose the platform, and the platform governs the volume. Automated outreach has neither, unless the sender builds them in.

Discussion questions

Trace the Cost Path for your most active automated outreach. At which step would you first hear of a mistake? Do any of your automated actions use an identity, such as a mailbox, account or brand, that belongs to another business or person? Where in your systems do you rely on the costs you impose being too small for anyone to contest? Which institutions of the email or social "commons" are you subject to? Which do you comply with by design rather than by luck? Simon wrote that information consumes attention. How much attention does your automation consume per customer it wins?

Apply it

Take one week of your automated outreach. For each message, mark whether the recipient was a plausible prospect, a plausible prospect at the wrong address, or not a prospect at all. Compute the share in each category. Then estimate the attention 1. 2. 3. 4. 5.
cost (say, ten seconds per message) of the last two categories over a year at your current volume. Decide whether you would accept that cost if you had to pay it yourself.
PA R T I I

Anatomy of an

unwatched pipeline

Nobody Was Watching

5 · The wrong recipients

Opening question. How does a system designed to find small businesses end up emailing a weather service? Nobody designed Tapstall's lead hunter to email a government weather service. Nobody wrote a rule saying "contact magazine reviewers". Each of its rules was reasonable on its own. The harm came from how they combined. This chapter dissects that combination, because the pattern is common: externalities in automated outreach usually arise from the composition of sensible-looking rules, not from any decision about who to target.

How lead hunters go wrong

An automated lead hunter does three things. It finds candidate pages, extracts contact details from them and scores them to decide which to contact. Each step has a characteristic failure. Finding. Search results are not a list of businesses. A query for "bakery Harare" returns businesses, but also directories, news articles, recipe sites, dictionaries and pages that happen to contain both words. The hunter cannot tell which is which unless it is told how. Extracting. Many hunters take the first email address on a page. On a business's own site, that is often the business. On any other page, it is whoever owns the page: a magazine's reviewer, a platform's support desk, a webmaster. On documentation pages, it may be a placeholder that no one reads. Scoring. Hunters often count "signals" that suggest a real prospect: the page mentions a city, a product, a phone number. If the page's own address counts as a signal, as it did in Tapstall's first version, every page carries at least one signal by default.
Put the three together: search for a business type and a city, take the first email on each result, and contact anything with two signals. Every rule is defensible, and the composition sends sales pitches to whoever publishes pages about bakeries. Volunteered geographic data, such as OpenStreetMap, offers a better starting point. Goodchild (2007) described such data as "citizens as sensors", and Haklay (2010) found that OpenStreetMap's coverage of England was good in cities and patchy elsewhere. Map data at least records businesses, not pages. But it is thin in exactly the markets Tapstall serves. Medina and Schneider (2018) estimate that informal economies make up a large share of output in sub-Saharan Africa, and informal businesses rarely appear in any database, let alone with an email address.

The Tapstall case

The audit found three defects in this family. The hunter filed and emailed junk (audit finding C2, critical). The first version searched the web, took the first email address on each page and counted the page's own address as a signal. By the morning of the audit it had filed 109 leads. Nine had been contacted, 34 were queued and 66 were parked in a research hold. The held rows included thesaurus entries, weather forecasts, homework-help pages, an American pizza menu and an encyclopedia page. The contacted rows produced the misdirected mail described in Chapter 4. Legacy junk bypassed the new gate (R6). The rebuild added a gate at ingest: an address must belong to the business's own domain and the business must be in a served market. But rows already in the queue had been filed under the old rules. They would have flowed straight through to outreach, because the gate only checked new arrivals. The fix was to enforce the same gate at the claim door, the moment a lead is taken for contact, as well as at ingest. In practice the cleanup marked 32 junk rows as do-not-contact and deleted 89 research-hold rows. The rebuilt hunter found chain stores (R10, introduced by the rebuild). The new hunter drew on OpenStreetMap, one city at a time. Its first live dry run returned ten candidates, including branches of national chains. All three email addresses it found were corporate addresses for those chains. Those are not
Tapstall's customers, who are independent informal merchants, and a sales email to a chain's head office is another externality. A chain filter was added, and the second dry run returned ten independents. After the cleanup, the lead store held 16 queued leads, 3 contacted and 32 marked do-not-contact. The honest consequence is that the pipeline became much smaller. Most independents in the map data had a phone number but no email address. The hunter now produces roughly ten candidates per run, and many of those can only be reached by a seller with a phone. That is a commercial cost of doing it properly, and the owner accepted it.

Framework: the Recipient Gate

A recipient gate is a set of checks applied at the moment of contact, not only when a lead is filed. The working paper's proposition P5 holds that gates placed at the point of action reduce externalities more than tighter rules at any single earlier stage. The gate asks four questions of every address before a message is sent. Check Question Example rule Fails closed? Ownership Does this address belong to this business? The address's domain matches the business's own website, or the address was published by the business itself Yes: no send Market Is this business in a market we serve? Location in a served country and city Yes Fit Is this the kind of business we serve? Independent, not a chain or a branch; category on an allowed list Yes History Have we, or anyone, been told not to contact this address? Not on the do-not-contact list; no prior bounce; no prior unsubscribe Yes All four checks fail closed: if the gate cannot decide, it does not send. A lead that fails can be held for a person to review, but the gate never contacts on a guess. Two design points matter more than the specific rules. The gate sits at the door, not at the window. Checking at ingest is useful, but rules change, and old data does not re-check itself. The gate at the moment of contact catches everything. •
The gate's rejections are visible. A count of rejected leads, by reason, belongs on the console. A sudden rise in "ownership" failures means the hunter has found a new kind of junk.

What the case does not show

The case shows a hunter producing junk and a gate removing it. It does not show that the rebuilt gate is accurate. Its rules were checked on two dry runs of ten candidates each and on the existing lead store, which is a small sample. Some legitimate businesses will have been rejected, especially those that use personal mailboxes, and some junk may still pass in forms not yet seen. Nor does the case show that map data is the right source for every market; it was simply the best free source available for informal merchants in two countries. The durable lesson is structural, not statistical: the gate belongs at the point of contact, and its rejections belong on the screen.

Points of debate

"This throws away good leads." It does. Some businesses use a personal mailbox rather than one on their own domain, and the ownership check rejects them. The rebuild treated those as phone leads for sellers. Whether that trade-off is right depends on the market. But the default should be to contact fewer, better recipients, because the cost of a wrong recipient falls on someone else. "A human should review every lead instead." For a small volume, that is a reasonable choice. But review queues decay. Tapstall's research hold had 66 rows and no reviewer. A gate that runs automatically every time is more reliable than a review that depends on someone remembering. "Better AI extraction would solve this." A smarter extractor might pick the right address more often. It would not remove the need for a gate, because it, too, can be wrong, and its mistakes still land on strangers. A gate is a check on the extractor, whoever or whatever the extractor is.

Discussion questions

Describe your lead-finding process as three steps: find, extract, score. Where could each step produce a wrong recipient? • 1.
Which of your rules are reasonable on their own but could combine badly? Where do your checks run: at ingest, at contact or both? What happens to data filed under old rules? What share of your leads have only a phone number? How do you work them? Would you rather contact fewer leads with high confidence or more leads with lower confidence? Who bears the cost of each choice?

Apply it

Take your last 30 leads that were contacted or are about to be. Apply the four Recipient Gate checks by hand. Count how many would fail, and on which check. If more than a handful fail, move the gate to the point of contact before your next send. Then add a line to your console showing the rejection count by reason. 2. 3. 4. 5.

6 · Borrowed identities

Opening question. Whose name is your automation using when it speaks, and are you sure? Every automated message, post or payment request carries an identity: a sending address, a social handle, an account name. Recipients judge the message by that identity. Platforms judge the sender by it. When automation acts under an identity that belongs to someone else, it spends that someone's reputation. And because the identity "works", in that messages go out and posts appear, nothing in the system's own feedback suggests anything is wrong.

The confused deputy

In 1988 Norm Hardy described a problem he called "the confused deputy". A compiler service on a shared computer had permission to write to a billing file. A user asked it to write its output to a file name the user chose, and named the billing file. The compiler, acting on the user's behalf but with its own permissions, overwrote the billing records. The program was not malicious and its code was not wrong. It simply used authority it held for one purpose to serve another, because nothing tied the authority to the purpose (Hardy, 1988). Borrowed identities in growth automation are confused deputies at the scale of a business. A credential created for one purpose, such as a founder's personal mailbox, another venture's social account or a demo setup, is handed to a system built for a different purpose. The system uses it faithfully. The authority is real, so every action succeeds. But each action is taken in the wrong name. Saltzer and Schroeder (1975) set out design principles for protecting information that remain standard today. Two apply directly. Least privilege: every program should operate with the smallest set of privileges it needs. Separation of privilege: no single credential should unlock unrelated capabilities. A personal mailbox that is also a support desk, and also the outbound address for a sales runner, violates both.

Why founders borrow

Founders borrow identities for understandable reasons: Speed. Creating a new mailbox, social account or developer key takes time, sometimes verification and sometimes a phone number. An existing one works now. Free-tier limits. Free plans limit the number of accounts or projects, so new products are deployed onto old accounts. Testing that becomes production. A credential added "just to test the posting" stays after the test. Portfolio operation. A founder running several ventures often has one personal account that touches all of them. None of those is careless in the moment. The trouble is that the borrowing is rarely recorded, and the system has no way to report whose identity it is using.

The Tapstall case

The audit and rebuild found three borrowed-identity defects. The press posted into another venture's social account (H2, high). From 20 to 28 October, Tapstall's press module posted three times a day into the social account of STPi, a separate venture run by the same owner. The credentials for that account had been bound to Tapstall's server, probably during setup or testing. Each post succeeded. The console reported posts as sent. STPi's followers saw promotional posts for a product they had never heard of, under a brand they followed for something else. The outreach runner read the other venture's support inbox (R1). Tapstall's outreach went out from the owner's personal webmail account. That account was also the published support address of the same separate venture. To read replies, the runner opened that inbox and marked messages as read. STPi's support mail was being opened by a machine and flagged as seen before any person saw it. A customer of the other venture writing for help could have had their message silently marked as handled. • • • •
The registry still named the other venture's handle (R7). Once the borrowed credentials had been deleted, the press module's registry, its record of which accounts belonged to which identity, still listed the other venture's handle as Tapstall's owner account. Had anyone re-added a credential for that handle, posting would have resumed. The registry was rewritten so that the owner identity listed only rails waiting for Tapstall's own accounts. There is a further detail. The outreach emails were sent from that same personal mailbox, so recipients saw a support address with no connection to Tapstall's brand. Even the three real businesses that were contacted received a pitch from an identity that would not have made sense to them.

What the rebuild did

The rebuild's rule was simple: the system acts only under credentials created for

it.

Outreach moved to a dedicated mailbox used only for automated mail, connected with an app password limited to sending and reading. The runner's mailbox connection was made read-only, so it can no longer mark anything as seen. The borrowed social credentials were deleted from the server. The owner was advised to revoke the app password on the other venture's account as well. The social rails were re-registered as "armed": each rail now shows "on (waiting for account)" until a credential for Tapstall's own account is added. Chapter 18 describes this pattern. One gap remained open at the time of writing. The older outreach runner on the build service still had the personal mailbox configured as its sending account. Its mailbox access was cut to read-only, and moving it to an identity of its own was left as an explicit decision for the owner. A remaining coupling that is written down is a risk accepted. One that is not written down is a defect.

Framework: the Identity Ledger

Keep a single table listing every identity your automation uses. Fill it in from the deployment, the provider consoles and secret stores, not from memory. • • • •
Action Identity used Who owns that identity? Created for this system? Where is the credential stored? Who else uses it? Visible on the console? Outreach email Sending mailbox Reply reading Mailbox connection Social posting (each rail) Handle or page Payment webhook Platform account Scheduled jobs Repository and account Three rules govern the ledger: Any "no" in "created for this system" is a defect until the identity is replaced or the borrowing is explicitly accepted, in writing, by the identity's owner. Any entry in "who else uses it" is a coupling. A problem in one system can now harm the other, through reputation, rate limits or lockouts. "Visible on the console" should be yes for every row. An operator should be able to see, in one place, which name each action is using right now.

What the case does not show

The case cannot say how the borrowed credentials came to be bound to Tapstall's server. The likely explanations, such as setup convenience or a test that was never removed, are inferences, and the book does not claim to know. It also cannot show what the other venture's followers or support customers experienced; no complaints were recorded. And it does not show that dedicated identities are always worth their cost. For a founder with one product and one personal account, the coupling may be acceptable if it is known and recorded. What the case shows is how easily a borrowed identity becomes invisible once it works, and how much of the system's behaviour it can quietly redirect. 1. 2. 3.

Points of debate

"It's my own other business; there's no harm." The followers and customers of the other venture did not consent to Tapstall's messages, and the other venture's support mail was affected. Common ownership does not make the identities interchangeable to the people who rely on them. Brands are promises to their audiences, not just assets of their owners. "A personal address feels more authentic for outreach." There is evidence that personal-feeling messages get more replies, and a real person's name can be used on a dedicated mailbox. The problem is not personal tone; it is coupling one identity to several unrelated roles. "Separate identities multiply the work." They do, modestly. They also multiply the protection: a problem with one product's sender reputation no longer reaches the founder's personal mail or another venture's customers.

Discussion questions

List every identity your automation uses. How many were created for that purpose? Does any one credential in your business serve more than one role, such as personal mail, support and outbound sales? If one of your ventures' sender reputations collapsed tomorrow, which others would be affected? Where does your system record which identity each action uses? Could you answer that question from the console? Have any credentials added "for testing" become production credentials?

Apply it

Complete the Identity Ledger for your automated growth actions, working from your provider consoles and secret stores. For every row with a "no" or a coupling, choose one action: replace the identity, obtain written acceptance from its owner, or switch the action off. Then add each action's current identity to your console, so that the next borrowing is visible the day it happens. 1. 2. 3. 4. 5.

7 · Duplicate clocks

Opening question. How many things are running your pipeline right now, and how would you know if the answer were "more than one"? A scheduled action has a clock: something that decides when it runs. In a simple system there is one clock per action. In practice, clocks multiply. A job is scheduled on a server and also on a build service. An old version of the product keeps running after a new one replaces it. A copy deployed for a demonstration is never switched off. Each clock does its job faithfully, and the action runs twice, three times or more. Or, worse, one clock fails and another hides the failure.

Why clocks multiply

Lamport (1978) showed that in a distributed system there is no single, shared notion of time; separate processes have only their own clocks and the messages between them. Small ventures rarely think of themselves as distributed systems, but they usually are. A typical pipeline runs code on a serverless platform, scheduled jobs on a build service, payment events from a third party and perhaps a spreadsheet script. Each has its own idea of when things should happen. Kleppmann (2017) explains why distributed systems favour designs in which each piece of state has exactly one writer and each operation can safely be repeated (is idempotent). When two schedulers both believe they own an action, neither design holds. Counts double, limits are exceeded, and records disagree about what happened. Clocks multiply for ordinary reasons: Belt and braces. A builder adds a second schedule "in case the first one fails". Migration without removal. A job moves from one scheduler to another, and the old schedule stays. Copies that outlive their purpose. A demonstration copy, an old version kept "just in case", a deployment on a second account made while experimenting. • • •
Free-tier limits. Spreading work across accounts to stay within each one's limits creates copies that nobody tracks.

The Tapstall case

The audit and rebuild found three multiplicity defects, and a fourth problem that a duplicate clock had hidden. An old copy ran against production data (C3, critical). On the same cloud account as the live service, an older deployment running version 1.0.0 was still answering requests. It was connected to the production data store and accepted the previous owner secret, which had been replaced in the live service but not in the old one. Anyone holding the old secret could have changed live data through the old copy. The tests could not see this: the old copy was not in the repository at all. Two more copies on a second account (R4). On a second cloud account, two copies of version 0.9.1 were still deployed, each with its own data and a scheduled trigger firing four times a day. They were not touching production data, but they were running scheduled jobs under the product's name, and they held real merchant-like data of their own. Double scheduling (R3). The outreach runner and the lead hunter were each triggered from two places: their own schedule on the build service, and a dispatch from the server's nightly job. Outreach was capped at 20 messages per run. With two clocks, the cap became 40 a day. The limit was correct in the code, and doubled in practice. The masked failure (H3). The server's nightly job did several things, including dispatching the outreach and hunting workflows. On the free tier, a single invocation may make at most 50 outgoing requests. The nightly job exceeded that limit, so the dispatch failed. But the job recorded the dispatch as done anyway. Nobody noticed, because the build service's own schedules kept running the workflows. The duplicate clock produced exactly the outcome the operator watched for, "outreach ran today", while the primary clock had been failing every night. •
That last pattern is why the working paper's proposition P4 holds that a duplicate clock is worse than a missing one. A missing clock produces a visible absence. A duplicate clock produces a plausible presence that hides the primary's failure.

What the rebuild did

The old copies were replaced by permanent redirects to the live service. Their schedules were removed, their secrets deleted and their data exported and archived before removal. The workflows' own schedules were removed. The server became the single clock. Its dispatch now records the result of each call, not the attempt, and retries failed dispatches at the next opportunity. The nightly job was restructured to stay under the outgoing-request limit, and its health report shows the last dispatch result for each workflow.

Framework: the Clock Register

List every scheduled action and every thing that can trigger it. Fill this in from the deployment: every account, every scheduler, every copy. Action Trigger Trigger Other copies that could run it Records outcome or attempt? Retries on failure? Last confirmed run Lead hunt Outreach Press posts Renewal reminders Nightly maintenance Rules: Exactly one trigger per action. Any entry in "Trigger 2" or "Other copies" is a defect until removed. Not disabled; removed, or redirected. • • • 1.
Record outcomes, not attempts. "Dispatched" means the dispatch was accepted, not that the code tried. Retry rather than duplicate. Reliability comes from a single clock that retries failures, not from a second clock that runs regardless. The register includes every account. The defects in this case were on accounts the code did not mention.

Retiring a copy safely

The case suggests a short sequence for removing an old copy without losing anything: Export its data and archive the export where you can find it. Remove its schedules, so it stops acting. Delete its secrets, so it can no longer act even if something wakes it. Replace it with a redirect to the live service, so that any links to it still work and anyone using it is moved to the current version. Verify that the redirect answers, the schedule is gone and the secrets are absent.

What the case does not show

The case does not show that the old copies were ever used against production data. No evidence of misuse was found, and the stored data showed no sign of it. The critical rating of C3 reflects what was possible, not what happened. Nor does the case show how long the dispatch had been failing before the audit; the logs available covered only recent days. The masking argument in this chapter rests on the mechanism, which was observed directly, rather than on a measured duration. Proposition P4 predicts that duplicate clocks lengthen undetected failures in general. Testing it would need many pipelines and a way to date the start of each failure, which one case cannot supply. 2. 3. 4. 1. 2. 3. 4. 5.

Points of debate

"A backup schedule is good engineering." Redundancy is good engineering when the redundant parts coordinate, for example when a standby takes over only if the primary is confirmed down. Two independent schedulers that both run the action are not redundancy. They are duplication, and they hide failures. "The old copies weren't doing any harm." One accepted a superseded secret against live data. The others ran scheduled jobs under the product's name with data nobody was watching. Even when a copy does no harm, it is an action nobody is witnessing. "Tracking every account is impractical for a portfolio founder." It took the audit under an hour to list every deployment across the owner's accounts. The cost of the list is small. The cost of the copy you do not know about is unbounded.

Discussion questions

For each of your scheduled actions, how many things can trigger it? How sure are you? Do you have any deployment you would describe as "old, but still up just in case"? When did you last list every deployment across every account you control? Does your system record the outcome of scheduled actions or only the attempt? Can you think of a failure in your systems that was hidden because something else produced the expected result?

Apply it

Fill in the Clock Register from your provider consoles, covering every account you control. For every duplicate trigger or stray copy, follow the five-step retirement sequence. Then pick one scheduled action and confirm, from the outside, that it ran once yesterday and only once: from the sent mail, the published posts or the stored records, not from the scheduler's own log. 1. 2. 3. 4. 5.

8 · Silent failure

Opening question. How many of the things your dashboard says happened actually happened? A silent failure is an action that does not happen while the system records that it did, or at least records nothing that says it did not. It is the mirror image of the externality. An externality is an effect nobody intended. A silent failure is an intended effect that never occurs. Both escape notice for the same reason: the operator sees reports about actions, not the actions themselves.

Activity is not effect

Organisational researchers have long noted that formal structures can drift away from the work they describe. Meyer and Rowan (1977) called this decoupling: organisations adopt structures and reports that signal legitimacy, while the actual work goes on separately, unconnected to them. Dashboards in small ventures can decouple in a similar way. A row that says "sent" or "posted" or "warned" signals that the pipeline is working. Whether it describes anything that happened in the world depends on what wrote it, and when. Beyer and colleagues (2016), describing site reliability practice at Google, recommend monitoring user-visible symptoms rather than internal causes: measure whether users get what they asked for, not only whether processes are running. For a growth pipeline, the "users" include recipients and merchants. A useful monitor asks whether the email arrived, not whether the send function returned. Reason (2000) described organisational accidents using the "Swiss cheese" model: each layer of defence has holes, and harm passes through when the holes line up. A silent failure is a layer that reports itself as solid while being entirely hole.

The Tapstall case

Four defects in the case were silent failures.
Merchant mail went nowhere (H1, high). Tapstall promised merchants several emails: a welcome, a renewal reminder before their free period ended, and receipts. Since launch, none had ever been sent. The function that sent mail checked for a mail-sending connection, found none bound in production and returned without error. Worse, the renewal process stamped each merchant as "warned" after calling that function. A merchant reaching the end of the free period would have been suspended for non-payment with no warning, while the system's records showed a warning had been sent. No merchant had yet reached that point, because no one had paid or reached the end of a free period. The defect was found before it harmed anyone, but only just. Dispatch failed but was stamped done (H3, high). As Chapter 7 described, the nightly job exceeded the free tier's limit of 50 outgoing requests per invocation. The dispatch to the outreach and hunting workflows failed, and the job recorded it as done. The duplicate schedules hid the failure. Posts queued for accounts that did not exist (R8). The press module composed posts for every social rail in its registry and queued them, including rails with no account behind them. Nothing was ever published on those rails. But the module wrote to storage each time, using up part of the free tier's daily limit of 1,000 writes. The activity looked like distribution. There was no effect. The health screen was blind (R13). The operator's health screen reported on the server and the data store. It did not show whether mail could be sent, how many messages were waiting to be sent, whether the last dispatch had succeeded or whether any payments had arrived without matching a merchant. Each of the other silent failures would have been visible within a day on a health screen that showed effects. On the screen that existed, everything looked fine.

What the rebuild did

Merchant mail now goes through the dedicated mail lane, with a retry queue. The "warned" stamp is written only after the mail is accepted for delivery. If it is not accepted, the warning is tried again the next night. One gap remains, and the case should be candid about it. A store whose paid period runs out is still suspended on schedule, even if no warning ever got through. Holding the •
suspension until a warning has been delivered is the fail-safe design this chapter recommends. At the time of writing it had not been built. The dispatch records the response of each call, and failed dispatches are retried. The press module skips any identity with no armed rail. Nothing is composed or stored for an account that does not exist. The health screen now shows the mail lane's state, the queue length, the last dispatch result per workflow, unmatched payments and the state of every social rail. A mail-test lever lets the owner send one real message and see it arrive.

Framework: the Effect Receipt

For every action your system reports, ask what evidence the report is based on. An effect receipt is a record written only after the outside system confirms the effect. Action What the dashboard says Written when? Receipt that would confirm the effect Receipt available? Send email "Sent" After calling the send function The mail server accepted the message; later, no bounce Post to social "Posted" After queueing The network returned the post's address Renewal warning "Warned" After calling the mail function Mail accepted for delivery to the merchant Dispatch workflow "Dispatched" After the call The build service accepted the dispatch Match payment "Matched" After matching Payment tied to a verified customer; unmatched ones listed Two rules follow. Write the status after the receipt, not before the attempt. If the receipt never comes, the status should say so: "pending", "failed", "waiting for account". • • • 1.
Anything that gates a consequence must have a receipt. If "warned" leads to suspension, "warned" must mean the merchant was actually warned.

What the case does not show

No merchant was harmed by the silent mail failure, because none had reached the end of a paid period. The case therefore shows a latent harm, not an actual one. It also cannot say how many silent failures remain in the rebuilt system. The health screen now shows more, but a screen can only display what someone thought to measure. And the rebuild itself left one consequence ungated, the suspension at expiry, which shows how hard it is to close every link between a status and the consequence it triggers. The chapter's claim is that receipts make silent failures visible faster. The case supports that claim for the four failures it found, not for failures nobody has yet thought to look for.

Points of debate

"Returning quietly when a dependency is missing is graceful degradation."

Graceful degradation keeps a service usable when a part fails, and tells someone. Returning quietly and recording success is not graceful; it is concealment. The function should either fail loudly or record that nothing happened. "Receipts add complexity." They add a little. Most outside services already return a receipt: a message identifier, a post address, an accepted response. The extra work is in storing it and reading it before writing a status. That is less work than investigating a suspension that should never have happened. "The merchant mail defect harmed nobody." That is true, and fortunate. It harmed nobody because there were no paying merchants yet. A defect that would have suspended paying customers without warning is serious whether or not it has been triggered. Its timing was luck.

Discussion questions

Pick three statuses your dashboard shows. For each, when exactly is it written: before the attempt, after the attempt or after confirmation? 2. 1.
Which of your statuses gate a consequence, such as a suspension, a charge or a follow-up? Has any action in your system been reported as done when it was not? How did you find out? Does your health screen report the system's components or the effects the system is meant to produce? Where in your pipeline does activity, such as queueing, composing or logging, look like effect?

Apply it

Choose the one status in your system that gates the most serious consequence. Trace where it is written, and what evidence exists at that moment. If the status can be written without an effect receipt, change the order: obtain the receipt first, then write the status, and make the consequence wait for it. Add the receipt count to your health screen. 2. 3. 4. 5.

9 · Misreading the world

Opening question. When the outside world answers your automation, does your automation understand what it was told? An automated pipeline does not only act on the world. It also reads what comes back: replies, bounces, unsubscribe requests, payment notices, error messages. Each of those is a message from outside the system's boundary, written in the outside world's conventions. A boundary misreading is a defect in which the system misinterprets what comes back, so that it acts on something nobody said, or ignores something somebody did.

Messages across a boundary

Software engineers have known for decades that the interfaces between components are where misunderstandings live. Parnas (1972) argued that systems should be divided into modules that each hide one design decision, so that the assumptions each part makes about another are few and explicit. Conway (1968) observed that the structure of a system tends to mirror the communication structure of the organisation that built it. When the "organisation" includes strangers, mail servers and payment platforms, the boundaries multiply and the assumptions go unstated. Email is a particularly treacherous boundary because its conventions are informal and layered: Replies quote earlier messages. A reply typically contains the recipient's own words above a copy of the message they are replying to. Anything in the quoted part was written by the sender, not the recipient. Automatic replies look like human replies. Out-of-office notices and ticket acknowledgements arrive as ordinary mail. RFC 3834 (Moore, 2004) recommends that automatic responders mark their messages with a header so that other systems can recognise them, but many do not. • •
Bounces have a standard form, loosely followed. RFC 3464 defines a standard format for delivery status notifications, so that a system can tell that a message could not be delivered and why. Many servers send human-readable bounces instead, or both. Unsubscribe requests come in several forms. A recipient may click a link, use their mail client's unsubscribe button (which relies on the headers described in Chapter 17), or reply with a word like STOP. A pipeline that reads replies must sort through all of that, and the cost of a mistake falls on the recipient: someone who said stop and was not heard, or someone who never said stop and is excluded.

The Tapstall case

Two defects in the case were boundary misreadings, and both concerned what came back from outside. The system's own footer was read as an opt-out (R2). Tapstall's outreach emails ended with a line telling recipients they could reply STOP to opt out. When a recipient replied, their mail client quoted the original message below their reply, including that line. The runner searched the whole reply for the word STOP, found it in the quoted footer and marked the recipient as do-not-contact. Any reply at all, including "yes, tell me more", would have been treated as a refusal. The system was reading its own words as the recipient's. The fix was to read only the recipient's own words: strip quoted text, signatures and the standard reply markers before looking for an opt-out, and treat a reply that contains STOP in its own text, or arrives through the unsubscribe link, as the optout. This is a small change in code. It is a large change in whether the system can hear its recipients correctly. Legacy junk passed the new gate (R6). Described in Chapter 5, this was a misreading of a different kind. Rows filed under the old rules looked like valid leads to a gate that only checked new arrivals. The system read its own history as if it were trustworthy. • •
A related audit finding sits on the same boundary. Bounces were ignored and some messages had no opt-out (H4, high). The first version did not process bounce notices, so an address that did not exist would be contacted again on the next touch. Its messages carried no unsubscribe header, and the third message in a sequence had no opt-out at all. That finding is coded as an externality, because its main effect was on recipients, but it is also a failure to read what the world was saying. A bounce is the mail system saying "nobody is here". Ignoring it means sending again into the void, and to mail providers, repeated sends to dead addresses look like the behaviour of a spammer.

What the rebuild did

Replies are parsed for the recipient's own words only. Quoted text, signatures and reply headers are removed before any opt-out is detected. Automatic replies are recognised by their headers where present, and are not treated as human answers. Bounces move the address to do-not-contact immediately. Every message carries a one-click unsubscribe link and the standard unsubscribe headers. All three touches in a sequence carry them, not only the first. The mailbox connection is read-only, so reading a reply no longer changes its state for anyone else using the mailbox.

Framework: the Boundary Reading Table

For every kind of message that comes back from outside, write down how the system recognises it, what it does with it and what a misreading would cost. Incoming message How it is recognised What the system does Misreading risk Who bears the cost Human reply Not automatic; not a bounce Notify a person; record interest Quoted text treated as the reply The recipient (excluded wrongly) or the business (lost lead) • • • • •
message How it is recognised What the system does Misreading risk Who bears the cost Opt-out reply STOP in the recipient's own words Do-not-contact immediately Footer or quote triggers it; or a real STOP missed The recipient Unsubscribe link or header Signed link or one-click request Do-not-contact immediately Link not honoured; honoured late The recipient Automatic reply Auto-reply headers; known patterns Ignore for interest; keep sequence Treated as interest or as refusal Both Bounce Delivery status format; known patterns Do-not-contact; flag the lead source Ignored, so the dead address is mailed again Sender reputation Payment notice Signed webhook Match to a verified customer Matched on unverified data The customer (Chapter 10) The table's purpose is to make every reading rule explicit, so that someone can check it against real examples. Each row should be tested with real messages: an actual reply quoting the footer, an actual bounce from a large provider, an actual out-of-office.

What the case does not show

The case found the STOP misreading during the rebuild, before any real reply had been misclassified. As far as the records show, none had been. The defect is therefore known from the code and from a constructed test, not from harm in the world. The rebuilt reply parser has been tested with constructed examples and a small number of real messages. It has not yet faced the full variety of mail clients, languages and auto-responders that a larger pipeline would meet. Merchants in Zimbabwe and South Africa write in several languages, and an opt-out in one of them may not contain the English word the parser looks for. The case points to the problem without claiming to have solved it.

Points of debate

"Keyword matching is good enough for opt-outs." It is good enough only when it reads the right text. The case's defect was not the keyword. It was where the system looked. The safest rule is generous: when the recipient's own words are ambiguous, treat the message as an opt-out and let a person reverse it. Wrongly excluding an interested person costs a lead. Wrongly contacting someone who said stop costs their trust, and possibly breaks the law. "Bounce handling is the mail provider's job." The provider tells you about the bounce. Only the sender can stop sending to that address again. "Recipients should use the unsubscribe link, not reply." Many will reply. The rules of the commons, and in several jurisdictions the law, expect a sender to honour any clear request to stop, in whatever form it arrives.

Discussion questions

List the kinds of message that come back to your automation. Which ones does it read automatically? Where does your system look for an opt-out? Could your own words ever be read as someone else's? What happens in your system when an email bounces? When was that last checked with a real bounce? Does reading a reply in your system change its state, such as marking it read, for anyone else? When your system is unsure what a message means, what does it do by default? Who bears the cost of that default?

Apply it

Collect five real messages of each kind your system receives: replies, out-of-office notices, bounces and opt-outs. Run each through your system's reading rules, by hand if necessary, and record what the system would do. Count the misreadings. Fix the reading rule for any category with even one misreading, then keep the examples as tests. 1. 2. 3. 4. 5.

10 · Authority and the money

path

Opening question. What does it take for a stranger to act as one of your customers, and has anyone tried? Most of this book concerns witness gaps: places where an operator cannot see what the system does to others. This chapter covers the other kind of defect that the Tapstall audit found most often among its serious problems: leaks of authority. These are not witness gaps. Existing security practice knows how to find them. They belong in this book for two reasons. In autonomous pipelines they cluster on the money path, where payments are matched and accounts switched on and off. And they interact with witness gaps, because an authority hole is most dangerous when nobody is watching the actions that exploit it.

Authority in small systems

Saltzer and Schroeder's (1975) principles remain the foundation. Three matter here: Complete mediation. Every access to every resource should be checked for authority, every time. Fail-safe defaults. Access should be denied unless explicitly granted, so that a mistake leaves things locked rather than open. Economy of mechanism. Protection should be simple enough to inspect. Anderson (2020) adds the practical observation that most real security failures come not from broken cryptography but from broken assumptions about who knows what. A secret that is not secret, an identity that is not verified or a recovery process that trusts public information are typical examples. • • •
Jensen and Meckling (1976) analysed agency: the costs that arise when one party acts on behalf of another whose interests differ. Every automated system that acts on payments or accounts is an agent of the owner. Every authority leak is a way for a third party to make that agent act for them instead.

The Tapstall case

Three audit findings were leaks of authority. They were not found by tests, and they were not witness gaps. They were found by walking through the product as an attacker would. PIN reset store takeover (C1, critical). A merchant could reset the PIN protecting their store. In the first version, the reset relied on facts printed on the merchant's public storefront: enough to identify the store and request a new PIN. Anyone who could read the store page could take it over. No secret was needed, only patience and the storefront. The fix moved recovery to a secret channel: a one-hour reset link sent by email to an address the merchant had verified. For merchants without a verified address, the fallback holds the store for 24 hours and then rotates every credential, giving the real owner time to notice and object. Payments matched on unverified email (H5, high). When a buyer paid for a plan through the payment platform, the first version matched the payment to a merchant by the email address the buyer typed at checkout. That address was not verified by anyone. A person could, in principle, pay with someone else's address and attach the plan to the wrong account, or redirect a payment's benefit. Payments that matched nobody were filed silently, so the owner would not have seen them either. The first half of that defect is an authority leak. The second half is a witness gap. The fix matched payments only on the platform's verified email, or through a claim link sent to that address. Unmatched payments now appear on the health screen. A development secret as fallback (M2, medium). If the server's signing secret were ever unbound, for example by a careless redeployment, the code fell back to a fixed development value. Anyone who read the public code would then be able to
sign valid tokens. The secret was bound at the time of the audit, so the fallback was not active, but one configuration slip away. The fix removed the fallback: without the real secret, the server refuses to sign anything.

Why these sit on the money path

The three findings share a location. They govern who owns a store, who has paid and what counts as a valid credential. These are the points at which an autonomous system makes decisions with direct financial consequences: switching a merchant on, switching them off, attaching a payment to an account. In a staffed business those points had human checks. A person handling a PIN reset by phone would ask questions. A bookkeeper matching payments would notice one that fitted nobody. Automation removes those checks, just as it removes the witnesses described in Chapter 2. Authority leaks and witness gaps share a root: the system now makes decisions that used to involve a person, without replacing what the person contributed. The interaction matters. An authority hole that is exploited in a system with good witnesses gets noticed: unmatched payments show up, a takeover triggers an alert to the real owner. The same hole in an unwitnessed system can be exploited repeatedly and silently.

Framework: the Money Path Walk

Walk every path by which money or control changes hands, as an outsider with only public information. For each, ask the questions in the table. Path What an outsider knows What the system asks for Could the outsider supply it? What the real owner would see Fail-safe default Account recovery Storefront facts Hold, then rotate Payment matching Any email address Verified email or claim link only Plan change A logged-in session Re-confirm by email
Path What an outsider knows What the system asks for Could the outsider supply it? What the real owner would see Fail-safe default Suspension Nothing Only after a warning is confirmed delivered Credential signing Public code Refuse without the real secret Two columns do most of the work: "Could the outsider supply it?" If yes, the path is open. "What the real owner would see" is the witness column. Even a sound path should notify the real owner when it is used, so that misuse is seen.

What the case does not show

None of the three authority leaks is known to have been exploited. The case shows that each was reachable, by walking the path as an outsider, but not that anyone walked it. The fixes have been tested by the same process that made them, and an independent security review would be a stronger check. The case also cannot show that every money path was found. The walk covered recovery, payment matching and credential signing, the paths the audit thought of, and an attacker would look for others. The general point stands regardless: in an autonomous system the money path is where automated decisions have direct financial effects, and it deserves an outsider's walk before every significant change.

Points of debate

"Nobody would bother attacking a tiny product." Automated attacks do not choose targets by size; they scan everything. And the PIN reset required no skill, only reading. "Security is a separate discipline; this book is about growth." In an autonomous pipeline, growth and security meet at the money path. A pipeline that can be made to switch on accounts for free, or switch off paying customers, is a growth problem as much as a security problem. • •
"Fail-safe defaults hurt conversion." Sometimes. Holding a store for 24 hours delays a legitimate recovery. Requiring a verified email for payment matching adds a step for some buyers. These are business trade-offs. Make them deliberately, and write down which way each path fails.

Discussion questions

Which paths in your system change who owns what, who has paid or who has access? For each, what does an outsider with only public information know? Could they complete the path? Which of your payment or account events, if they matched nobody, would be filed silently? Does your code contain any fallback secret, default password or test credential that would activate if configuration failed? When a sensitive path is used legitimately, does the real owner get told?

Apply it

Perform the Money Path Walk for your product, alone, in an hour, using a fresh browser and only public information. Try to recover an account that is not yours (a test account you set up), attach a payment to the wrong account and find any credential in your public code. Record every success. Fix each one, and add a notification to the real owner on every sensitive path, whether or not you found a hole in it. 1. 2. 3. 4. 5.
PA R T I I I

Witnessing

Nobody Was Watching

11 · The witness map

Opening question. How can a founder find, in an hour, the places where their automation acts on the world with nobody watching? Part II described six ways an unwatched pipeline goes wrong. Part III turns to finding them. This chapter introduces the main instrument, the witness map. The working paper derives it from the case and proposes it for testing. It costs nothing to apply, needs no special tools and, for a pipeline of Tapstall's size, takes about an hour. Its one demanding requirement is access to the deployment, not only the code, because two of the four witness gaps are invisible in code.

Start from actions, not components

Most reviews of a system start from its components: the server, the database, the scheduled jobs. The witness map starts from actions on parties outside the system. These are the verbs: send, post, charge, suspend, notify, file, delete, match. Each verb names something that changes the world beyond the system's boundary. Starting from actions has two advantages. It directs attention to effects, which is where witness gaps live. And it is complete in a way component lists are not: if you list every verb your system performs on the outside world, you have listed every place it can do harm. Leveson's (2011) approach to safety, known as STAMP, models a system as a set of control loops and asks, for each control action, how it could be unsafe: provided when it should not be, not provided when it should be, provided at the wrong time or for the wrong duration. The witness map borrows that habit of going action by action, and asks a simpler question of each: could the operator see it go wrong?

The five questions

For every outward action, the map asks five questions. The first four correspond to the four witnesses of Chapter 3. The fifth asks how the action can be stopped.
What a good answer looks like Gap it closes Identity. Under whose credential and name does this act? A credential created for this system alone, named after it and held in one place Borrowed identity Clock. What fires it, and how many things fire it? Exactly one scheduler; every other copy redirected or removed; a failed fire retried, not stamped as done Multiplicity Effect. What evidence comes back that it worked? A record written after the outside system confirms the effect, and shown to the operator Silent failure Recipient. What evidence comes back about who received it and what they think? A check before acting that the recipient is right, and a channel back (unsubscribe, bounce, reply in the recipient's own words) Externality, boundary misreading Stop. What stops it, and who can use that? A per-action switch the operator can reach in one step, and an exit the recipient can use in one click All Each question has a characteristic bad answer: Identity: "whichever account it was set up with". Clock: "its schedule, and I think also the nightly job". Effect: "the log says sent". Recipient: "whoever the hunter found". Stop: "I would redeploy without it". Hearing those answers is the point of the exercise.

The Tapstall case

Applied to the first version, the map surfaces every witness gap the audit found. This retrospective application is a demonstration, not an independent test: the map was derived from the same case. • • • • •
Identity Clock Effect Recipient Stop Send outreach Owner's personal mailbox, also another venture's support inbox (R1) Server dispatch and the workflow's own schedule (R3) "Sent" written by the runner No ownership check; bounces ignored; footer read as a reply (C2, H4, R2) Disable the workflow by hand Post to social Another venture's account (H2, R7) Server schedule, three times a day "Posted"; also queued for absent accounts (R8) Other venture's followers Delete the credential Send merchant mail None bound Renewal job Nothing comes back; "warned" stamped anyway (H1) Merchants, unseen None needed: nothing was sent Dispatch workflows Repository token Nightly job The call's own return, stamped regardless (H3) Not applicable None Run the service Old secret still valid on an old copy (C3) Three other deployments (C3, R4) Not applicable Anyone with the old secret Not known to exist And applied to the rebuilt version: Action Identity Clock Effect Recipient Stop Send outreach Dedicated mailbox, read-only connection Server dispatch only, with retry Mail server's acceptance; bounces recorded Gate at the point of contact; unsubscribe link and headers; recipient's own words parsed Pause the lane; one-click unsubscribe
Identity Clock Effect Recipient Stop Post to social Tapstall's own accounts only; rails show "waiting for account" until armed Server schedule only Post address returned, or nothing composed Tapstall's own followers Remove the credential; the rail returns to waiting Send merchant mail Dedicated mailbox, reserved slot Renewal job; "warned" only after acceptance Acceptance recorded; retry queue Verified merchant address Pause the lane (suspension at expiry does not yet wait for a delivered warning) The second table is not perfect. The older runner's sending identity remained, as Chapter 6 noted, and is recorded as an accepted risk. But every cell now has an answer the operator can check.

How to run the map

The case suggests a simple procedure: List the verbs. Read the code, the schedules and the console, and list every action the system takes on anyone outside it. Expect to find more than you expected. Answer from the deployment. For identity and clock, look at provider consoles and secret stores, not at the code or your memory. The code says what should be bound. The deployment says what is. Answer from the records. For effect and recipient, read actual records: the last 20 messages, the last 20 posts, the last 20 matches. Mark each cell. Green: a named mechanism you have checked. Amber: a mechanism you believe exists but have not checked. Red: none. Fix reds before switching on new actions. Any new outward action enters the map before it goes live. Repeat after every change that adds or alters an outward action. Chapter 14 explains why. 1. 2. 3. 4. 5. 6.

What the case does not show

The witness map was derived from this case and then applied back to it, so its success here is circular. It shows that the map can describe the defects that were found, not that it would have found them first. A fair test would apply the map to other pipelines before an audit and compare what it finds with what a conventional review finds. The claim that the map takes about an hour is also specific to a pipeline of this size, with five outward actions. A larger system with dozens of actions, or several teams, would take longer, and would need someone with authority to answer the identity and clock questions across all of them.

Points of debate

"This is just a checklist." It is, and checklists work when they are short, specific and tied to real failure modes. The map's value is that its questions come from defects that slipped past a substantial test suite. Its limitation is that it is derived from one case. Other cases may reveal other witnesses worth adding. "Most actions will be amber." Probably, at first. Amber is honest: it says "I think this is fine but have not looked". The map's purpose is to turn amber into green by looking, or into red by finding out. "Why five questions and not more?" Every question added to a checklist reduces the chance that the checklist is used. Five is enough to cover the gaps the case found. A team that finds a sixth gap should add a sixth question.

Discussion questions

List every verb your system performs on the outside world. How many did you find, and how many surprised you? Which of the five questions is hardest to answer for your systems? Why? Where would you need to look, beyond the code, to answer the identity and clock questions? Which of your actions has no stop that you could reach in one step? Who in your organisation should own the witness map? How often should it be refreshed? 1. 2. 3. 4. 5.

Apply it

Build the witness map for your pipeline. Take the list of actions from the exercise in Chapter 3, add any you missed, and answer all five questions for each from the deployment and the records. Mark every cell green, amber or red. Pick the single reddest row and fix it this week. Put the map somewhere the whole team can see, and set a date to repeat it.

12 · The account inventory

Opening question. Can you list every place your products are running, every schedule that fires them and every credential they hold? Two of the four witness gaps, borrowed identity and multiplicity, live in accounts rather than code. They show up in provider consoles, secret stores and scheduling settings. No amount of reading the repository will reveal that a product is posting with another venture's credential, or that an old copy is still running on a second account. The account inventory is the practice of listing those facts directly. In the Tapstall case it found five defects, including one critical finding. The working paper's proposition P3 holds that such defects will generally be found this way rather than by reading code.

Why accounts drift

Founders, especially those running several products, accumulate accounts. A cloud account is opened for one product and reused for the next. A free tier's limits push a new experiment onto a second account. A demo is deployed, shown once and never removed. A credential is pasted into one product's secret store to test something and left there. None of this is unusual. The accumulation is invisible because each piece was added at a different time, for a different reason, and nothing in any one product's code records it. Dekker (2011) describes drift into failure: a gradual migration of practice towards the boundary of safety through a series of locally reasonable decisions, none of which looks dangerous at the time. Account drift is a small, concrete instance of it. Perrow (1984) distinguished systems by two properties: interactive complexity, in which parts can affect each other in unexpected ways, and tight coupling, in which effects spread quickly with little slack. Shared accounts create both. A credential shared between two ventures couples them tightly. A forgotten copy creates unexpected interactions with live data.

What the inventory covers

An account inventory lists, for every account the founder controls on every relevant provider: Deployments: every running service, its name, its version if known and what it is connected to. Schedules: every timed trigger and what it runs. Data stores: every database or key-value store, and which deployments can reach it. Secrets: the names of secrets bound to each deployment (not their values), and which identity each belongs to. Public pages: anything published under the founder's accounts that a stranger could find. For a small portfolio, the providers typically include a cloud platform, a code host with scheduled workflows, a mail provider, social networks and a payment platform.

The Tapstall case

The inventory of the owner's accounts covered two cloud accounts, the code host and the connected services. It found: On the production cloud account: the live service; an old copy running version 1.0.0 against production data with a superseded secret (C3); and several other products belonging to the owner, each with its own schedules. On a second cloud account: two copies of an earlier version, 0.9.1, each with its own data and a trigger firing four times a day (R4); and several more products and demo pages. In the live service's secret store: credentials for another venture's social account (H2) and the owner's personal mailbox, which was also that venture's support inbox (R1). In the press module's registry: the other venture's handle still named as an owner rail (R7). • • • • • • • • •
Several findings beyond the Tapstall pipeline itself were reported to the owner but are outside this book's scope. They included demonstration pages on the second account that used real business names and no longer worked, a proxy service whose terms-of-service risk should be reviewed, and a public page still carrying template placeholder text. The inventory is not only a debugging tool. It is the founder's first complete view of what is published under their name. The whole inventory took under an hour. It needed only read access to the consoles and the provider interfaces. It changed nothing.

Framework: the Account Inventory sheet

Keep one sheet per provider account. Fill it from the provider console or interface. Refresh it monthly and after any deployment that adds a new service. Item Name Product it belongs to Version or purpose Connected to Schedules Secrets bound (names only) Still needed? Action Deployment Data store Scheduled workflow Public page Rules: Fill it from the provider, not from memory. Memory is what drifted. Every secret name is traced to an identity. If a secret's owner is not this product, the row goes to the Identity Ledger of Chapter 6. Every "still needed: no" gets an action and a date. Use the retirement sequence of Chapter 7: export, remove schedules, delete secrets, redirect, verify. Never record secret values. The inventory itself becomes sensitive if it holds them. 1. 2. 3. 4.

The inventory as a map of the portfolio

For founders running several ventures, the inventory has a second use. It shows the coupling between them: which credentials, mailboxes, accounts and quotas they share. In the case, the inventory showed that one personal mailbox was the support desk for one venture, the outreach sender for another and the login for several services. A problem with that mailbox, such as a suspension for spam complaints, would have affected all of them at once. Seeing the couplings lets the founder decide which ones to keep. Some sharing is sensible. A single cloud account for several small products keeps costs and administration down. But each shared element should be a decision, recorded with its reason, not an accident discovered during an audit.

What the case does not show

The inventory in the case covered the accounts the owner disclosed and the tokens provided for the work. It cannot show that no other accounts existed, such as an old account opened years ago and forgotten. It also found problems in products outside Tapstall that this book does not analyse, and those findings were reported to the owner rather than coded. The case shows that, for one portfolio founder, an hour of listing found five defects that code reading had missed, including a critical one. Whether the same holds for teams with proper infrastructure management, where deployments are declared in code and reviewed, is an open question. Such teams may have fewer stray copies, or simply different ones.

Points of debate

"My accounts are a mess, but they work." They work until one coupling fails, and then they fail together. The inventory does not require tidying everything. It requires knowing what is there. "Provider consoles already show all this." They show it account by account, in different formats, without connecting a secret to the identity it belongs to or a copy to the product it duplicates. The inventory makes those connections.
"Inventories go stale immediately." They do, which is why the refresh rule matters. A stale inventory is still better than none, because it records what you believed was true at a known date, so you can see what changed.

Discussion questions

How many cloud, code-hosting and mail accounts do you control? Are you sure? When did you last remove a deployment you no longer needed? What made you remove it? Which credentials in your business are shared across products? What would happen if one were revoked? Is anything published under your accounts that you would not want a prospect to find? Who should own the inventory in a small portfolio, and how often should it be refreshed?

Apply it

Spend one hour building the account inventory for every provider account you control. Do not fix anything during the hour; only list. At the end, count the items marked "still needed: no" and the secrets whose identity is not the product they are bound to. Schedule a second hour, within the week, to retire the unneeded items using the five-step sequence. 1. 2. 3. 4. 5.

13 · Reading the ledgers

Opening question. When did you last read what your automation actually did, as opposed to what it reported? Every autonomous pipeline leaves records of its actions: sent mail, published posts, stored leads, payment events, job logs. These are its ledgers. Reading them, slowly and in the raw, is the cheapest and most productive audit method in the Tapstall case. Reading live state and ledgers found six defects, and inspecting sent mail and recipients found five more. Together, with some overlap, that was nearly half of everything the audit and rebuild found. The test suite found none. This chapter argues that reading ledgers should be a habit, not an emergency measure, and explains what to read and how.

Reports versus records

A report is a summary produced by the system about itself: "20 emails sent today", "3 posts published", "all jobs successful". A record is the thing itself: the actual email, with its recipient, sender and content; the actual post, with its account and text; the actual row in the lead store. Reports are designed to be read quickly, and they encode assumptions about what matters. A report saying "20 emails sent" assumes that the count is the interesting fact. It hides the recipients, the sender and whether the count includes messages to a weather service. Records hide nothing, but they take time to read. Weick and Sutcliffe (2007), studying organisations that operate reliably in hazardous conditions, identified a set of habits they called mindful organising. Two apply directly. Preoccupation with failure means treating small anomalies as possible signs of larger problems rather than as noise. Reluctance to simplify means resisting summaries that make things look tidier than they are. Reading ledgers practises both. A summary of the lead store would have said "109 leads". Reading the rows showed a pizza menu and a weather forecast.
Power (1997) warned that audit can become a ritual: a check that controls exist rather than that they work. Reading ledgers is the opposite of ritual. It is direct inspection of what happened.

What to read

For a growth pipeline, five ledgers matter most. Sent messages. Read the actual messages: recipient, sender address, subject, body and the time sent. Ask: would this recipient expect to hear from us? Is this the address we think we send from? Does every message carry a working exit? Received messages. Read the replies, bounces and automatic responses as they arrived, not as the system classified them. Ask: did the system classify each one correctly? Published posts. Look at each account the system posts to, from the outside, as a follower would. Ask: is this our account? Is the post what we meant? Stored leads and contacts. Read a sample of the rows: names, addresses, sources and statuses. Ask: is each one a real prospect in a market we serve? Money events. Read payment notices and the matches made. Ask: does each payment match the right customer? Are any unmatched?

The Tapstall case

The audit's first day was spent mostly reading. Each ledger showed something that no report had. Ledger What the report said What the records showed Defect Lead store 109 leads; 9 contacted, 34 queued, 66 held Held rows included thesaurus entries, weather forecasts, homework-help pages, a pizza menu and an encyclopedia page C2 Sent mail Outreach running 17 recipients, 14 not prospects; sent from another venture's support address C2, R1 Mail sequence Three touches per lead The third touch had no opt-out; no unsubscribe headers; bounces not processed H4
Ledger What the report said What the records showed Defect Received mail Replies processed The other venture's support mail marked as read by the runner; footer text read as STOP R1, R2 Social account Posts published Posts appearing on another venture's timeline H2 Job runs Outreach and hunt ran daily Each ran twice a day, once from each scheduler; the server's dispatch had been failing R3, H3 One further point is easy to miss. At the start of the audit, the lead store held 109 rows. By the time the rebuild began, it held 140, because a scheduled hunt running on the old code had added more during the audit. The pipeline does not stop while you inspect it. A reader of ledgers should switch off the actions being inspected, or at least note the time of each reading.

How to read

The case suggests a few practical rules. Read the raw form. Open the actual mailbox, the actual social account, the actual data rows. Not an export summarised by the system, and not a dashboard. Read a fixed sample, not a scroll. The last 20 of each kind, every time. A fixed sample makes changes visible from one reading to the next. Read as the recipient. For each message or post, imagine being the person who received it. Would it make sense to them? Write down every surprise. Each surprise is a possible witness gap. Most will be harmless. A few will be the most important findings of the month. Pause the actions first. Reading a moving ledger confuses the reading and lets the problem grow.

Framework: the Weekly Ledger Read

A standing ritual (in the good sense) for any founder running autonomous growth. It takes about 30 minutes a week. • • • • •
Sample Questions Red flags Sent messages Last 20 Right recipient? Right sender? Working exit? Any recipient you would not have chosen by hand Received messages Last 20 Classified correctly? Opt-outs honoured? An opt-out missed, or a reply treated as an optout Posts Last 10 per account, viewed from outside Right account? Right content? A post on an account you did not expect Leads 20 random rows Real prospect? Right market? Own address? Any row that is not a business Money events All since last read Matched correctly? Any unmatched? Any unmatched payment Record the date and the number of red flags each week. A rising count means something has changed.

What the case does not show

The case shows that reading ledgers found many defects on one day. It does not show that a weekly read would have found them sooner. That is an inference, plausible but untested. The audit's readers also knew they were looking for problems, which a routine weekly reader may not. A weekly ritual can decay into skimming, just as audits can decay into ritual. The 30-minute estimate assumes a pipeline of this size and a reader who knows what normal looks like. The case's strongest evidence is negative: every report the system produced looked healthy, and every ledger, read in the raw, showed something wrong. That contrast is the reason for the habit.

Points of debate

"Reading records doesn't scale." It does not need to. A fixed sample of 20 catches systematic problems, which are the dangerous ones, because a rule that is wrong produces wrong results at a steady rate. When 14 of 17 recipients are wrong, as in the case, any sample will show it.
"Automated anomaly detection would be better." It might complement reading. But anomaly detection learns what is normal from the data, and if the system has been wrong since launch, wrong is normal. A person reading as the recipient brings a standard the data does not contain. "I don't have time." The weekly read takes 30 minutes. The Tapstall pipeline had been mailing non-prospects, posting into another venture's account and failing its nightly dispatch for days or weeks. Thirty minutes a week would have found all three within seven days.

Discussion questions

Which of your ledgers have you read in raw form in the last month? What reports do you rely on instead? What do they assume is important? Have you ever found a problem by reading records that no report had shown? What was it? How would you read your ledgers as the recipient would see them? What should happen to the pipeline while you are reading its ledgers?

Apply it

Do the Weekly Ledger Read once, today. Pause any action whose ledger you are reading. Use the table above, and record every surprise. Then put a recurring 30minute slot in your calendar for the same read each week, and keep a simple log: date, number of red flags, and what you did about each. 1. 2. 3. 4. 5.

14 · Dry runs and the defects

that fixes create

Opening question. When you fix an autonomous system, what new problems does the fix introduce, and how will you find them? A repair is itself a change to how a system acts on the world. It can create new witness gaps as easily as it closes old ones. In the Tapstall case, four of the 13 defects found during the rebuild were introduced by the rebuild itself. None was caught by tests written at the same time as the fix. Three were caught by running the changed action for real, in its production environment, and reading the output. The fourth was caught by asking a plain question about the day after the change. The working paper's proposition P6 holds that repairs introduce new witness gaps at a rate that does not fall to zero, and that those defects are caught mainly by live dry runs and real-output inspection. This chapter explains the practice.

Why fixes create defects

Fixes create defects for structural reasons, not careless ones. A fix changes an interface with the outside world. A new data source, a new query or a new rule is a new way of touching systems the builder does not control.

A fix removes something, and the thing removed was doing a second job.

Every component in a working system may be holding up something nobody listed. A fix is tested against the problem it fixes. Its tests check that the old defect is gone. They rarely check what the new code does to everything else. Fixes happen under pressure. An audit that finds critical problems creates urgency, and urgency narrows attention. • • • •
Perrow (1984) argued that in tightly coupled, interactively complex systems, some accidents are "normal": not the result of any single error, but of unexpected interactions that the system's structure makes inevitable over time. Repairs are a rich source of such interactions, because they change parts of a system whose interactions were, at least, known to produce the old behaviour.

The four induced defects

Removing the spreadsheet left no place to work leads (R9). The owner's standing rule was to remove all spreadsheet-based tools: one fewer place for things to break. The first version had used a spreadsheet as a second control surface for leads (H6). The rebuild removed it. But the spreadsheet had also been where sellers looked at their leads and recorded their calls. Removing it left them nowhere to work. The defect was found by asking, "where will a seller work tomorrow morning?" The fix was a leads desk inside the product's own console, which has to exist before the spreadsheet can safely go. The rebuilt hunter found chain stores (R10). The new lead hunter drew on map data city by city, with a contact filter and a junk gate. Its first live dry run, on the production job runner, returned ten candidates. Several were branches of national chains, and the three email addresses found were all corporate. A chain filter was added and the second dry run returned ten independents. A test written alongside the new hunter would have used invented inputs. Only the real map data contained chains. The rebuilt hunter's query timed out (R11). The new hunter's first query to the public map service asked for 18 kinds of business in one request. It timed out on every public mirror. The query worked against a small test area. At city scale, on shared public infrastructure, it was too heavy. The fix split the query and added a fallback between mirrors. Only running it for real showed the problem. Removing a duplicate loop left a broken script (R12). While removing a duplicate deployment loop from a build script, the rebuild left a reference to a variable that no longer existed. The script ran in strict mode, in which an undefined variable stops execution. This one was caught before shipping, by running the script. It is coded as a build defect, not a witness gap, but it shows the same pattern: removal breaks what the removed thing was holding up.

The dry run

A dry run is an execution of a changed autonomous action, in its real environment, with its real inputs, that stops short of acting on the outside world. Instead it shows what it would have done. For a lead hunter, it lists the candidates it would have filed. For an outreach runner, it shows the messages it would have sent and to whom. For a poster, it shows the posts and the accounts. A good dry run has four properties: Same environment. It runs where the real action runs, with the same limits, permissions and network conditions. R11 would not have appeared on a developer's laptop. Real inputs. It reads the same data sources the real action will read. R10 depended on real map data. No outward effect. Nothing is sent, posted, charged or filed. Read by a person. The output is read by someone asking the recipient's question: "would I want this to happen?" The case adds a fifth element, for actions that do touch the world: one real effect, confirmed from outside. After the rebuild, one real test email was sent through the new mail lane and found in a real mailbox, checked through a read-only connection. That single message confirmed identity, effect and delivery in a way no dry run could.

Framework: the Change Witness Protocol

Apply this to any change that adds or alters an action on the outside world. Step What to do What it catches 1. Map Add or update the action's row in the witness map before shipping New witness gaps in the design 2. Ask the dayafter question "What did the thing I am changing or removing also do?" Removed functions that were doing a second job (R9, R12) 3. Dry run Run the changed action in production, with real inputs and no outward effect Real-input and real-environment surprises (R10, R11) 4. Read A person reads the dry run's output as the recipient would Wrong recipients, wrong content, wrong identity 1. 2. 3. 4.
What to do What it catches 5. One real effect Send one real message, publish one real post, and confirm it from outside Identity, delivery and effect 6. Watch the first live cycle Read the ledgers after the first real run Anything the dry run could not simulate The protocol takes from half an hour to half a day, depending on the change. In the case, the dry runs on the build service each took a few minutes of runner time.

What the case does not show

The case found four induced defects in a rebuild done in one day under some urgency. A slower, more deliberate rebuild might have induced fewer. The number is therefore a single observation, not a rate. The case also cannot show that the Change Witness Protocol would have caught all four in advance; it was assembled afterwards from how they were actually caught. One induced defect, R12, was caught by simply running the script, which is ordinary practice. The others depended on real data and real infrastructure. What the case does show is that the defects created by repairs were of the same kinds as those the repairs removed, and were found by the same methods: looking at real output.

Points of debate

"Good tests would make dry runs unnecessary." Tests and dry runs answer different questions. Tests check that the code does what the builder intended. Dry runs check that what the builder intended is right for the real world. The induced defects in the case were all of the second kind. "Dry runs in production are risky." They are designed to avoid outward effects, but that design must itself be checked. A dry-run flag that is ignored by one code path can send real mail. The step-4 reader should confirm that nothing was sent. "Some changes are too small to need this." R12 was a one-line removal. Size is not a good predictor of whether a change creates a gap. A better rule: any change to anything that touches the outside world gets at least steps 2 and 3.

Discussion questions

Think of the last fix you made to an automated system. What else did the thing you changed do? Can your outward actions run in a dry-run mode, in production, with real inputs? If not, what would it take? Which of your systems' failures would only appear at real scale or with real data? When did you last confirm a fix by observing one real effect from outside? How do you decide when a change is too small to need checking?

Apply it

Pick the next change you plan to make to any outward action. Before shipping it, write down your answer to the day-after question. Then run steps 3 to 5 of the Change Witness Protocol, and record what each step found. If your system has no dry-run mode for that action, building one is the change to make first. 1. 2. 3. 4. 5.

15 · Health screens that tell the

truth

Opening question. Does your dashboard tell you what your system is doing to the world, or only that it is running? Every operator of an autonomous system looks at some screen to decide whether things are fine. In a small venture it might be an owner console, a status page or a daily summary email. Whatever it is, it shapes what the operator believes. A health screen that reports configuration and activity will produce an operator who believes the system is working whenever it is running. A health screen that reports effects will produce an operator who knows. The working paper's proposition P7 holds that dashboards reporting configuration ("rail registered", "run successful") rather than effect ("post accepted", "outreach sent N") are associated with longer-lived witness gaps. It also holds that replacing configuration labels with effect labels, including an explicit waiting state, shortens them. This chapter turns that proposition into design guidance.

Labels and what they claim

Every label on a health screen makes an implicit claim. "Active" claims the thing is doing its job. "Sent" claims a message left. "OK" claims nothing is wrong. Each claim is only as good as the evidence behind it. Meyer and Rowan's (1977) idea of decoupling applies with particular force here. A label can be technically accurate, saying the rail is configured, while being decoupled from the reality the operator cares about, which is whether anything is being published. Goodhart's law, in the form popularised by Strathern (1997), says that when a measure becomes a target, it ceases to be a good measure. Health labels are not usually targets. But they become something close to it: the thing the operator looks at to feel reassured. Any label that can show green without the underlying effect is a label that will eventually show green while the effect is absent.
Beyer and colleagues (2016) propose four "golden signals" for monitoring a service: latency, traffic, errors and saturation. These are excellent for a service's own health. A growth pipeline needs an additional set: signals about its effects on others.

The Tapstall case

The first version's health screen reported on the server and the data store. Both were fine. It did not show: whether mail could be sent at all (it could not; H1); how many messages were waiting; whether the last dispatch to each workflow had succeeded (it had not; H3); whether any payments had arrived without matching a merchant; which account each social rail posted to (another venture's; H2). This blindness is coded as its own defect (R13), because each of the other problems would have shown up within a day on a screen that reported effects. The rebuilt health screen added a section for each of those signals. It shows: the mail lane's state, including whether it is parked after a login refusal; the mail queue length and the oldest waiting message; the last dispatch result for each scheduled workflow; unmatched payments, with a count and a list; every social rail's state, with the identity it belongs to. It also added a mail-test lever: one button that sends a real message through the live lane to a chosen address, so the owner can confirm delivery from outside.

The waiting state

One design decision from the rebuild deserves attention. The press module has rails for several social networks. Tapstall had no accounts on any of them yet: the borrowed credential had been removed and no new accounts had been created. How should the screen describe a rail that is switched on in the configuration but has no account behind it? • • • • • • • • • •
The obvious label is "active", and it is the label such screens usually show. The owner had already set a rule for the same situation in sister products, and the rebuild applied it here: a rail with no account shows "on (waiting for account)", not "active". The label tells the truth: the rail will post when, and only when, its own account is added. Until then nothing is published, and nothing pretends to be. The waiting state is a small idea with general use. Many automated actions depend on something that may not yet exist: an account, a credential, an approval, a customer. A label that distinguishes "on and doing it" from "on and waiting" from "off" gives the operator three truths instead of one ambiguity.

Framework: Effect Labels

Replace each configuration or activity label on your health screen with an effect label backed by a receipt. Where no receipt exists, use an honest waiting or unknown state. Area Configuration label (avoid) Effect label (use) Receipt behind it Honest nongreen states Outreach "Runner enabled" "Sent 6 today; 0 bounced; 1 reply" Mail server acceptance; bounce feed "Parked: login refused at 09:00"; "Queue: 4 waiting" Social rail "Rail active" "Last post accepted 14:02, as the brand's own handle" Post address returned "On (waiting for account)"; "Off" Scheduled job "Schedule configured" "Ran 02:00; dispatch accepted" Dispatch response "Dispatch failed; retrying at 03:00" Merchant mail "Mail configured" "Renewal reminders: 3 accepted" Acceptance per message "Lane down; suspensions paused" Payments "Webhook connected" "2 matched; 0 unmatched" Verified match "1 unmatched: review" Three design rules: Green requires a receipt. No receipt, no green. Every action has a non-green state that names what is missing. "Waiting for account", "parked", "retrying" and "unmatched" are more useful than "error". 1. 2.
Show the identity. Every outward action's row shows which identity it acts as. That single column would have revealed H2 and R1 on day one.

What the case does not show

The rebuilt health screen had existed for only a short time at the time of writing, so the case cannot show that it shortens the life of witness gaps in practice, as proposition P7 predicts. It shows only that each of the first version's silent failures would have appeared on the new screen. Nor can the case show how the owner will use the screen over months. Health screens that are not looked at protect nobody, and a daily summary may be needed. The waiting-state label was a rule the owner had already set for sister products. Its value here is plausible but unmeasured. The chapter's argument rests on the logic of receipts and on the observed blindness of the old screen.

Points of debate

"Effect labels are harder to build." They are slightly harder. Most outside services already return the receipt. The work is storing it and displaying it. That work is small compared with the cost of an operator who believes a false green. "Too many states confuse operators." Five honest states are less confusing than one misleading one. The confusion that matters is the operator's belief that something is happening when it is not. "Owners don't look at dashboards anyway." Then the dashboard's job is to come to them. A daily summary of effect labels, sent to the owner's phone, does the same work. What matters is that the summary reports effects.

Discussion questions

List the labels on your main health screen. Which report effects and which report configuration or activity? Which of your labels could show green while the effect it implies is absent? Do your outward actions show which identity they act as? Where would a "waiting" state make your screen more honest? 3. 1. 2. 3. 4.
If your health screen were the only thing you looked at for a month, what could go wrong without your knowing?

Apply it

Take your health screen and, for each label, write down the receipt that backs it. Where there is none, either add one or rename the label to say what it actually knows ("configured", "attempted", "waiting"). Add an identity column to every outward action. Then add one lever: a button that performs one real outward action and lets you confirm it from outside. 5.
PA R T I V

Building to be watched

Nobody Was Watching

16 · One clock, one voice, one

identity, one surface

Opening question. What simple design rules would make witness gaps hard to create in the first place? Part III was about finding witness gaps. Part IV is about building systems in which they are hard to create. The goal is not vigilance. Vigilance decays, and a founder running several products cannot watch everything. The goal is construction: design rules that close each gap by default, so that the system is easy to witness even when nobody is trying very hard. The working paper proposes four such rules, one for each witness. None of them is new. Each restates established engineering principles. What the case contributes is evidence that, in a small autonomous pipeline, these four together close the gaps that a passing test suite leaves open.

One clock

Every scheduled action is fired by exactly one scheduler. Other mechanisms that could fire it, such as a build-service schedule, an old deployment's trigger or a second account's copy, are removed, not merely left unused. The scheduler records the outcome of each fire, not the attempt, and retries a failed fire at the next opportunity. The principle behind it is Kleppmann's (2017) single-writer design: when one component owns a piece of state or an action, its history is consistent and its failures are visible. Lamport (1978) showed why multiple clocks cannot be trusted to agree. The rule's sharpest justification comes from the case. The duplicate schedules on the build service hid, for days, the fact that the server's dispatch had been failing every night. A duplicate clock is worse than a missing one, because it masks the failure of the primary.
In the rebuild, the server became the single clock. The workflows' own schedules were deleted. The server's dispatch records the response to each call, and a failed dispatch is retried on the next cycle. The three old copies were replaced by redirects, and their schedules removed.

One voice

A recipient hears from one sender identity for the life of a conversation. A follow-up goes only from the mailbox that sent the first message. Every message carries a working exit that the sender honours. The sender reads what comes back in the recipient's own words. One voice is partly courtesy and partly control. Hirschman (1970) distinguished two responses available to people dissatisfied with an organisation: exit, leaving, and voice, speaking up. A recipient of automated outreach needs both. Exit is the unsubscribe link. Voice is a reply that reaches someone who reads it. A conversation scattered across identities offers neither, because the recipient cannot tell who to answer and the sender cannot tell who has answered. The case found a defect in exactly this place: follow-ups could be sent from a different mailbox from the first message (R5). The rebuild ties every lead to the mailbox that first contacted it, sends at most three touches from that mailbox, and stops on any exit.

One identity

The system acts only under credentials created for it. Credentials borrowed from another venture, a personal account or a demonstration are removed even when they work. A rail with no credential of its own is shown as waiting, not active. This is Saltzer and Schroeder's (1975) least privilege applied to identity. It also guards against Hardy's (1988) confused deputy, described in Chapter 6: a system holding authority created for another purpose will use it faithfully in the wrong name.
In the rebuild, the outreach lane moved to a dedicated mailbox, the borrowed social credentials were deleted, and the social rails were re-registered to wait for the product's own accounts. The label matters as much as the credential. A dashboard that says "active" for a borrowed account is decoupled from the activity it describes.

One surface

There is one place where actions on prospects and customers are taken. Every action goes through one door, where the gate is enforced. A second surface that can propose or perform actions, such as a spreadsheet, a chat bot or a script, is either removed or routed through the same door. When a surface is removed, its replacement must exist before the removal ships. The rule has two halves, both learned from the case. The first version had a spreadsheet acting as a second control surface (H6). Actions could be taken there without passing the gate. The rebuild removed it. But removing it left sellers with nowhere to work (R9). So the second half of the rule is about sequence: build the replacement first. In the rebuild, the leads desk inside the product's own console became the one surface. Every lead claim goes through the same door, where the recipient gate of Chapter 5 is enforced.

How the rules interact

The four rules support each other. One clock and one identity make the witness map's first two questions trivially answerable: one scheduler, one credential. One voice makes the recipient channel work: replies go to a mailbox the system reads, from a sender the recipient recognises. One surface makes gates enforceable: there is only one door to guard. Together they reduce the number of things an operator must watch. The witness map for a system built on the four rules has short answers in every cell. • • •

Framework: the Four Rules Audit

Score each outward action against the four rules. Action One clock? (number of triggers) One voice? (sender stable for the conversation; exit honoured) One identity? (credential created for this system) One surface? (all actions through one door) Gaps to close Lead hunt Not applicable Outreach Follow-up Social posts Not applicable Merchant mail Lead claim by seller Any "no" is a gap. Any number greater than one in the clock column is a gap.

What the case does not show

The four rules are restatements of established principles, and the case does not test them against alternatives. It shows that, in one pipeline, breaking each rule produced a recognisable class of defect, and that applying each rule closed those defects. It also shows the rules being bent: one shared mailbox across five pipelines, by decision, and an older runner still sending under the owner's personal identity. The rules are therefore not presented as laws. They are defaults whose exceptions should be recorded. Whether they are sufficient, or whether a larger system needs further rules, cannot be settled by a case with five outward actions and no paying customers.

Points of debate

"One clock is a single point of failure." Yes, and that is the point. A single clock that fails is visible and can be retried. Two clocks that both run hide failures. If high availability is needed, use a primary with a standby that runs only when the primary is confirmed down. "One surface slows down operators who prefer spreadsheets." Possibly. The trade-off is between convenience and control. A spreadsheet that can trigger actions without the gate is a door without a lock. If operators need a spreadsheet's flexibility, give them a read-only export, and keep actions in the one surface. "These rules are too simple for real systems." They are deliberately simple, because simple rules get followed. Real systems will have exceptions. Each exception should be recorded, with its reason, in the witness map.

Discussion questions

Which of the four rules does your system break most often? Why? Do you have any action with more than one trigger? What was the reason for the second one? Can a recipient of your outreach always tell who is writing, and always reach a person who reads replies? How many surfaces can take actions on your prospects or customers? When you last removed a tool, did its replacement exist first?

Apply it

Complete the Four Rules Audit for your pipeline. For each gap, write the smallest change that would close it. Order the changes so that replacements come before removals. Make the change that closes the most serious gap this week, and add the rules to whatever checklist you use for new automated actions. 1. 2. 3. 4. 5.

17 · Outreach that strangers

can stop

Opening question. If someone you contacted wanted you to stop, how easily could they make it happen, and how sure are you that it would? Cold outreach is a legitimate way for a new venture to find customers, especially one with no audience and no budget. It is also an action on strangers who did not ask to hear from you. The difference between legitimate outreach and nuisance lies partly in targeting, covered in Chapter 5, and partly in control: whether the recipient can stop it and whether the sender reliably does. This chapter sets out what stoppable outreach looks like, using the standards that the email commons has developed and the rebuild of Tapstall's outreach lane.

The standards

Email's institutions, in Ostrom's (1990) sense, include several technical standards that make outreach stoppable. The List-Unsubscribe header (RFC 2369) lets a sender put an unsubscribe address or link in a message's headers, where mail clients can find it and show an unsubscribe button. One-click unsubscription (RFC 8058) lets a mail client unsubscribe the recipient with a single request, without opening a web page or sending a reply. Since 2024, Google has required bulk senders to support it, along with authentication and low complaint rates (Kumaran, 2023). Sender authentication (DMARC, RFC 7489) lets receiving servers check that a message really comes from the domain it claims. Delivery status notifications (RFC 3464) tell the sender, in a standard format, that a message could not be delivered. • • • •
Automatic-response headers (RFC 3834) let automatic replies identify themselves, so that they are not mistaken for human ones. The underlying transport is defined by the Simple Mail Transfer Protocol (RFC 5321). A small venture using a free mailbox sends through its provider's servers under that protocol, and inherits the provider's reputation and rules. Laws add further obligations. Chapter 22 covers them. In brief, the main laws relevant to the case, in South Africa, the United States and Zimbabwe, all require a clear way to stop unsolicited marketing, and require that requests to stop are honoured.

The Tapstall case

The first version's outreach broke several of these norms: no unsubscribe header; a third message in each sequence with no opt-out at all; no processing of bounces, so dead addresses were mailed again (H4); follow-ups that could come from a different mailbox from the first touch (R5); an opt-out detector that read the system's own quoted footer as a STOP (R2). The rebuilt outreach lane works as follows. These are design facts about the case, not recommendations for every venture. One dedicated mailbox, used only for automated mail and connected with an app password. Its connection for reading replies is read-only. A shared hourly cap. The mailbox is shared across five of the owner's pipelines, with a total cap of 15 messages an hour. Tapstall's lane may use two an hour, outreach at most one, and one slot is always reserved for account mail, such as PIN resets and renewal reminders, so that outreach can never crowd out a message a customer needs. Caution on refusal. If the mail server refuses a login, the lane parks itself for six hours rather than retrying and risking a lockout. Messages wait in a retry queue. At most three touches per lead, all from the same mailbox. • • • • • • • • • •
An exit in every message. A signed one-click unsubscribe link, the standard unsubscribe headers and a postal address. The recipient's own words. STOP is detected only in the text the recipient wrote, not in quoted material. Bounces stop the sequence. A bounce moves the address to do-not-contact immediately. The caps are low. One outreach message an hour is at most 24 a day. That is a deliberate choice for a venture that had sent mail to the wrong people, using a shared box with a modest limit. Volume can rise later, once the gate and the feedback loops have shown they work.

Framework: the Stoppability Standard

Any automated outreach should meet every line of this standard before it sends. Element Requirement How to verify Identity One dedicated sender, created for this outreach, used for the whole conversation Identity Ledger row; follow-up sender equals first-touch sender Exit in the message Visible unsubscribe link in every message, including the last Read the last message of a real sequence Exit in the headers List-Unsubscribe and one-click headers on every message View the raw headers of a sent message Honour Every exit (link, header, clear reply) moves the address to do-not-contact before the next send Unsubscribe a test address; confirm no further mail Bounce A bounce stops all further mail to the address Send to a known-dead address; confirm do-notcontact Reading Opt-outs detected in the recipient's own words only Reply "yes, interested" to a real message; confirm no optout Volume A cap below the mailbox's limit, with a slot reserved for customer mail Configuration plus one day's sent count Sequence A fixed, small maximum number of touches Configuration plus a real sequence • • •
Requirement How to verify Address A postal address in every message where the law requires it Read a real message The verification column matters most. Each line is checked by doing the thing a recipient would do, and observing the result.

What the case does not show

The rebuilt outreach lane had sent only a test message through its new path at the time of writing, confirmed in a real mailbox. The case cannot show its reply rates, complaint rates or deliverability in practice. Nor can it show that one message an hour is the right volume. It is a cautious starting point, chosen after a period of harm, not an optimum. The legal position of the outreach in each market is also unresolved, as Chapter 22 explains. The chapter's claims are about mechanism: the Stoppability Standard describes what the lane does, and each line can be verified by becoming a recipient. Whether stoppable outreach also converts better is a question the case cannot answer.

Points of debate

"Unsubscribe links reduce reply rates." Perhaps slightly. They also reduce spam complaints, which damage sender reputation for every future message. And where the law requires them, they are not optional. "Cold email is inherently intrusive." Some readers will hold that no unsolicited outreach is acceptable. Others will see it as a normal part of commerce. The case takes a middle position: outreach to well-targeted businesses, at low volume, with a working exit, is defensible. Outreach to anyone with an email address, without a working exit, is not. Readers should decide where they stand, and design accordingly. "Shared mailboxes across ventures contradict one identity." The case's lane is shared across the owner's pipelines, by explicit decision, as an interim measure. The sender name is set per product, and the cap is enforced across all of them. This
is a recorded exception to the one-identity rule, with a reason: the owner chose to reuse one existing dedicated box for now and replace it later. It is the kind of exception the rules should make visible, not forbid.

Discussion questions

Run through the Stoppability Standard for your outreach. Which lines would you fail today? How long does it take, in practice, from a recipient asking to stop to your system stopping? Has your outreach ever been sent from more than one identity to the same person? What does your system do when a mail server refuses its login? Where do you stand on the ethics of cold outreach, and does your design reflect that position?

Apply it

Become your own recipient. Put a test address into your outreach pipeline. Receive the first message, check its headers, reply "interested" and check that nothing marks you as opted out. Then click unsubscribe and confirm that no second message arrives. Finally, use a dead address and confirm that a bounce stops the sequence. Record each result against the Stoppability Standard. 1. 2. 3. 4. 5.

18 · Armed, not active

Opening question. How do you build distribution for channels you do not yet have accounts on, without borrowing someone else's or pretending? A venture with no audience wants as many channels as possible: several social networks, a newsletter, perhaps community sites. Building the posting machinery for all of them takes days. Creating, verifying and warming up an account on each takes weeks, and some require a phone number, an identity check or a waiting period. So founders face a gap between the system they can build and the accounts they can use. Two shortcuts fill that gap badly. One is to borrow: post through an account that already exists, such as a personal one, another venture's or a friend's. The other is to pretend: switch the channels on and let the machinery run with nothing behind it, so that the dashboard shows activity. Tapstall's first version did both. This chapter describes the alternative the rebuild adopted, which this book calls armed distribution.

What went wrong

The first version's press module had a registry of identities, each with a set of social rails. The owner's identity included a rail bound to another venture's social account (H2). Posts went out three times a day, for eight days, to that venture's followers. Other rails had no account at all, but the module still composed posts for them and queued them for delivery (R8). Each queued post used part of the free tier's limit of 1,000 storage writes a day, and nothing was ever published. Once the borrowed credentials had been deleted, the registry still named the other venture's handle (R7), ready to resume if anyone re-added a credential. Each problem had a witness dimension. The borrowed rail hid its identity. The empty rails hid their lack of effect. The stale registry hid a latent identity problem.

The armed pattern

An armed channel is one whose machinery is fully built, tested and switched on, but which acts only when its own credential exists. Until then it shows an honest waiting state and does nothing else. The pattern has four parts: Each rail has a state derived from its credential. No credential: "on (waiting for account)". Credential present: "active". Switched off by the operator: "off". Unarmed rails do nothing. No composing, no queueing, no storage writes. The press module skips any identity with no armed rail. Credentials are added in one place. Adding a channel's own credential to the secret store is enough to arm it. No code change or redeployment of logic is needed. A signup checklist. For each channel, a short document lists how to create the account, what credential to generate, what to call it and where to put it. In the rebuild, Tapstall's owner identity was re-registered with four rails, all showing "on (waiting for account)". The old registry was saved for reference and then rewritten. Optional rails for sellers, the independent people who work leads for commission, were supported in the design but left unregistered, since no seller had accounts to add. The same pattern was applied, at the owner's direction, to the distribution systems of the owner's other ventures. Its value is not specific to Tapstall.

Why "armed" rather than "off"

One might ask why the rails are not simply switched off until accounts exist. Three reasons favour arming. The machinery stays tested. Rails that are off tend to decay. Code changes break them unnoticed. Armed rails are part of the live system, exercised in every run up to the point of needing a credential. Adding a channel becomes an operator task, not an engineering task. The founder creates an account, adds its credential and the rail goes live. That is the 1. 2. 3. 4. • •
kind of "very important activity" a founder can do personally without calling a developer. The label tells the truth about intent. "On (waiting for account)" says the operator wants this channel and is missing one thing. "Off" says the operator does not want it. The difference matters when someone else reads the screen.

Distribution and the commons

Social networks are commons too, with their own rules on automation, identity and spam. Most allow automated posting through their official interfaces, under accounts that are clearly the poster's own. Most prohibit, or at least penalise, posting through borrowed or impersonated accounts. Some posting routes in the case go directly to a network's interface. Others go through a third-party scheduling service, which itself requires an account. Some networks in the design had no sender at all, so the rail could not post even when armed, and the screen says so. Armed distribution respects those rules by construction. A post can only appear on an account whose credential the operator deliberately added, for this product.

Framework: the Rail Readiness Sheet

Rail Sender route (direct, scheduler, none) Credential name expected Credential present? State shown Signup steps documented? Owner of the account Last post accepted Network A Network B Scheduler service Newsletter Rules: State comes from credentials, not configuration. If the credential is absent, the state is waiting, whatever the configuration says. Unarmed means inert. No work and no writes for a rail that cannot publish. • 1. 2.
The owner column names the product. If the account belongs to anyone else, the rail is a borrowed identity, not an armed one. "Last post accepted" is an effect label, backed by the post address the network returns.

What the case does not show

At the time of writing Tapstall had no social accounts of its own, so every rail was waiting. The armed pattern has therefore been shown to prevent posting under borrowed identities and to stop empty work. It has not yet been shown to work when accounts are added. The signup checklist has not been followed by the owner end to end. Some networks in the design have no sender at all, and others route through a scheduler service with its own account and limits. The case shows the pattern's honesty more clearly than its usefulness. Its usefulness will be tested when the first account is armed and the first accepted post appears on the screen.

Points of debate

"Waiting rails look unfinished to investors or customers." The health screen is for the operator, not the public. And an honest "waiting" is better than a false "active". A visitor who finds a social link that leads to another brand's account is worse off than one who finds no link. "Borrowing a personal account to start is normal." It is common. It couples the founder's personal reputation to the product's automation, and it makes the eventual separation harder. If a founder chooses to post as themselves, that should be a recorded decision, with the account named on the screen, not an accident discovered during an audit. "Arming every channel spreads effort thin." Arming costs little once the machinery exists. What spreads effort thin is warming up many accounts at once. Arming lets the founder add accounts one at a time, as they have capacity, without touching the code. 3. 4.

Discussion questions

Which of your distribution channels are live, which are waiting and which are borrowed? Does any part of your system do work, such as composing, queueing or writing, for a channel that cannot publish? How many steps does it take to add a new channel? Could you do it without a developer? Whose accounts do your posts appear on? How would you check from outside? When is it acceptable for a founder's personal account to carry a product's automated posts?

Apply it

Fill in the Rail Readiness Sheet for every channel your system posts to or could post to. For each rail whose owner is not your product, remove the credential and set the rail to waiting. For each rail that does work without a credential, make it inert. Then write a one-page signup checklist for the channel you most want to add next, and follow it. 1. 2. 3. 4. 5.

19 · Ceilings as design

Opening question. When you run on free tiers, are their limits your enemy, or are they the most honest specification you have? Tapstall ran entirely on free tiers. The serverless platform allowed 100,000 requests a day. Its key-value store allowed 1,000 writes, deletes or lists a day. A single invocation of server code could make at most 50 outgoing requests. The shared mailbox allowed 15 messages an hour across five pipelines. Scheduled jobs ran on a code host's free allowance of minutes. Those ceilings shaped several defects. They also shaped the design that fixed them. This chapter argues that, for a small autonomous pipeline, hard ceilings are a useful discipline: they force the system to count, and counting is a form of witnessing.

Constraints and design

Designers have long observed that constraints can improve work by narrowing choices and forcing explicit trade-offs. In software, the most practical version of this idea is the error budget. Beyer and colleagues (2016) describe how site reliability teams agree on an acceptable level of unreliability and spend that budget deliberately: when it is exhausted, releases slow down. The budget turns an abstract goal into a number that everyone can see. Free-tier ceilings are budgets imposed from outside. They cannot be negotiated, which makes them clearer than most internal targets. A system that runs close to them must know how much it is using, or it will fail unpredictably. A system that knows how much it is using has, by construction, a witness on its own activity.

How ceilings caused defects

The outgoing-request ceiling broke the nightly job (H3). The server's nightly job did too much in one invocation and exceeded the limit of 50 outgoing requests. Its last task, dispatching the outreach and hunting workflows, failed. The ceiling did
not cause the defect: the failure to record the outcome did. But the ceiling is what made the failure happen at all, and a system that counted its calls would have seen it coming. The write ceiling made empty activity expensive (R8). The press module queued posts for rails with no accounts, writing to storage each time. Against a limit of 1,000 writes a day, that waste competed with real work, such as recording leads, stamping deliveries and writing receipts. A public service's capacity broke the hunter twice (M1, R11). The first version queried a public map service for a whole country at once, which returned errors and timeouts. The rebuilt hunter's first query asked for 18 kinds of business in one request and timed out on every public mirror. Shared public infrastructure has ceilings too, often unpublished, and a polite client respects them.

How ceilings shaped the fix

The rebuild treated each ceiling as a design input. Outgoing requests. The nightly job was split so that each invocation stays under 50 calls, and the dispatch records its result and retries next cycle. Writes. Unarmed rails do nothing, so no writes are spent on them. Leads are written once at ingest and once at each status change. Junk is rejected before it is written. The mailbox. The shared hourly cap of 15 is allocated explicitly: two an hour for Tapstall, one of them for outreach, and one slot reserved for account mail. A login refusal parks the lane for six hours rather than hammering the server and risking a lock. The map service. The hunter queries two cities per country per day, splits its queries and falls back between mirrors. The result is about ten candidates per run. That is small, and honest. Job minutes. Removing the duplicate schedules halved the scheduled job runs. Dry runs each took a few minutes. • • • • •

Counting is witnessing

Each of those design responses requires the system to count something: calls made, writes spent, messages sent this hour, cities queried today. Counting produces a record of activity that is independent of any report about it. A system that knows it has sent one outreach message this hour, out of an allowance of one, also knows that it has sent exactly one. That is a witness on its own volume. The point generalises. Even a founder with paid infrastructure and no hard ceilings can benefit from imposing budgets on outward actions: so many messages an hour, so many posts a day, so many leads per city. A budget is a statement of intent that the system can check itself against, and an overrun is a signal that something has changed.

Framework: the Ceiling Budget

For each resource the pipeline consumes, record the ceiling, the share you allow yourself and how you count usage. Resource External ceiling Selfimposed budget How usage is counted What happens at the budget Shown on the health screen? Outgoing calls per invocation Counter in the job Defer remaining work to the next cycle Last run's count Storage writes per day 1,000 Counter per day Skip nonessential writes; alert Today's count Mail per hour (shared) 2 for this product; 1 for outreach Per-hour counter across products Queue; customer mail first This hour's sends; queue length Public map queries Unpublished 2 cities per country per day Per-day counter Stop; resume tomorrow Cities done today Job minutes per month Plan allowance A fixed fraction Provider usage page Reduce frequency Month to date
The self-imposed budget should sit well below the ceiling. The gap absorbs surprises and leaves room for the system's most important actions.

What the case does not show

The case shows ceilings causing some defects and shaping some fixes. It does not show that free tiers are a sound long-term basis for a growth business; Tapstall had no revenue to test that against. Some of the case's caution, such as one outreach message an hour, comes from the shared mailbox's limits and from the recent history of harm, not from any analysis of the right volume. And the claim that counting is a form of witnessing applies to volume, not content. A system can count perfectly and still send the wrong message to the right number of people. Budgets are one witness among several, not a substitute for the others.

Points of debate

"Free tiers are a false economy; pay for proper infrastructure." Paying removes some ceilings and replaces them with bills, which are ceilings of a different kind. For a pre-revenue venture, staying within free limits preserves runway. The case suggests the limits are workable if designed for. "Low caps throttle growth." One outreach message an hour is slow. But the case's outreach had been sending to the wrong people. Raising volume before fixing targeting multiplies harm, not growth. Caps can rise once the feedback loops show the gate works. "Self-imposed budgets are arbitrary." They are judgements, like any target. Their value lies less in the exact number than in the counting they require and the visible signal when they are exceeded.

Discussion questions

List the hard ceilings your pipeline runs under. Which do you count against, and which do you discover only when you hit them? Has a ceiling ever caused a failure in your system that was recorded as a success? What share of your write or call budget goes on activity with no effect? 1. 2. 3.
Where would a self-imposed budget on an outward action help you witness it? When would you choose to pay to remove a ceiling, rather than design within it?

Apply it

Fill in the Ceiling Budget for your pipeline. For each resource without a counter, add one. Set each self-imposed budget at no more than half the external ceiling, and decide what the system does at the budget. Put today's usage for each resource on the health screen, next to its budget. 4. 5.

20 · Stops and the human in the

loop

Opening question. Which decisions in your growth system should a person make, and how quickly can a person stop the rest? The fifth question of the witness map is about stopping: what stops this action, and who can use that? It differs from the other four. Identity, clock, effect and recipient are about seeing. Stop is about acting on what you see. A founder who sees a problem but cannot stop it quickly is a witness without power. This chapter covers two related design choices. The first is where to place people in an autonomous pipeline. The second is how to make every automated action stoppable, by the operator and by the people it affects.

Levels of automation

Parasuraman, Sheridan and Wickens (2000) proposed that automation is not a single choice between manual and automatic. It varies by function and by level. They divided any process into four stages: gathering information, analysing it, deciding and acting. Each stage can be automated to a different degree, from "the computer offers no help" to "the computer decides everything and acts without telling the human". The right level for each stage depends on the consequences of mistakes and on how reliable the automation is. Applied to a growth pipeline, the framework suggests a useful split: Gathering, such as finding candidate leads, can usually be highly automated, provided its output is checked. Analysis, such as scoring leads and classifying replies, can be automated with rules, provided the rules fail safe. Decision, such as whether to contact a lead or suspend a merchant, should be automated only when the gate is strong and the consequence reversible. • • •
Action, such as sending, posting or charging, should always be stoppable, and its effects witnessed. Bainbridge's (1983) irony returns here. If people are kept out of the loop until something goes wrong, they will be poorly placed to act when it does. Keeping a person in some routine part of the loop keeps their understanding current.

Where the human belongs

Tapstall's design goal was autonomy, with the owner stepping in only for important activities. The rebuild kept that goal and made the important activities explicit. Activity Automated? Where the person comes in Finding leads Yes Weekly ledger read of a sample Gating leads Yes, fail-closed Reviewing held leads, if they choose First outreach Yes, capped Reading replies; deciding on interested prospects Replies Parsed automatically for opt-outs and bounces Every human reply is worked by a person: the owner or a seller Sellers' calls No Sellers work phone-only leads by hand Social posting Yes, armed Adding each account; reading posts from outside Merchant mail Yes, with receipts None routinely Payment matching Yes, verified only Every unmatched payment Suspensions Yes, at expiry Recommended: any suspension where no warning was delivered (not yet built) The principle is that people handle conversations and exceptions. Machines handle volume and routine. Every human reply reaches a person. Every exception, such as an unmatched payment or a failed warning, is put in front of one. First touches into real inboxes run on their own, but nothing that a stranger says back is answered by a machine.

Stops

Every automated action needs two kinds of stop. •
The operator's stop. A switch the operator can reach in one step, per action, that halts it immediately without a redeployment. The rebuild went part of the way. A mail lane can be paused. A social rail returns to its inert waiting state when its credential is removed. The scheduled workflows can be disabled on the code host. Each is a single step, but they live in different places. Gathering them as switches on the same screen as the effect labels is the obvious next improvement, and the case is candid that it had not yet been made. The recipient's stop. An exit the affected person can use in one step: the unsubscribe link, a reply saying stop, or a one-click header. Chapter 17 covers these. A third stop is less obvious: the system's own stop. When something unexpected happens, the system should stop itself rather than continue. The rebuild's mail lane parks for six hours on a login refusal rather than retrying. The renewal job will not record a merchant as warned until the warning has been accepted for delivery. The signing code refuses to sign without its real secret. Each is a stop that requires no witness at all, because the system is designed to halt when its assumptions fail. Leveson (2011) describes safety constraints as rules that a controller must enforce. "Do not suspend without a delivered warning" and "do not send when the login is refused" are safety constraints in that sense.

Framework: the Stop Matrix

For each outward action, record all three stops and how long each takes. Action Operator's stop (how, how fast) Recipient's stop (how, how fast) System's own stop (condition) Last tested Outreach Pause the lane; immediate Link, header or reply; before next send Login refused: park 6h; bounce: do-not-contact Social posts Remove the rail's credential; inert at next cycle Not applicable (followers can unfollow) No credential: inert Merchant mail Pause the lane Merchant settings Lane down: hold suspensions
Action Operator's stop (how, how fast) Recipient's stop (how, how fast) System's own stop (condition) Last tested Suspension Manual override Pay, or contact support Recommended: no delivered warning, no suspension (not yet built in the case) Lead hunt Disable the workflow on the code host Not applicable Query timeout: fall back, then stop for the day The "last tested" column matters. A stop that has never been used is a stop you hope works.

What the case does not show

The case's stops were partly in place at the time of writing and partly not. Mail lanes could be paused and rails disarmed, but these levers lived in different places rather than on one screen. The suspension path did not yet wait for a delivered warning. The case therefore shows the Stop Matrix as a diagnostic, exposing what was missing, more than as a description of a finished system. It also cannot show where the right boundary between human and machine lies for other ventures. The split described here, with people handling conversations and exceptions, reflects one owner's preferences and one product's risks. Other founders, with different risks, may reasonably draw the line elsewhere.

Points of debate

"Keeping people in the loop defeats the point of automation." The case keeps people in a small number of places: conversations and exceptions. Those are where judgement matters and where mistakes are costly. Everything else runs unattended. "Fail-safe stops lose revenue." Holding a suspension when a warning fails means a non-paying merchant keeps service a little longer. That is a cost. Suspending a merchant who was never warned is a larger one, in trust and possibly in law. The case's rebuild had not yet made this choice in code. Its warnings are now real and retried, but expiry still suspends on schedule. That is the kind of open item a Stop Matrix exists to expose.
"Operators won't use per-action switches." They will if the switches are where they look. Put stops on the same screen as the effect labels, next to the action they halt.

Discussion questions

For each stage of your pipeline (gather, analyse, decide, act), what level of automation have you chosen? Was it a decision? Which conversations or exceptions in your pipeline are handled by a machine that should go to a person? How long would it take you to stop each automated action right now? Which of your actions stop themselves when their assumptions fail? When did you last test a stop?

Apply it

Fill in the Stop Matrix. For every action without an operator stop reachable in one step, add one. For every action without a system stop, write down the assumption it depends on and make the system halt when that assumption fails. Then test one stop of each kind today, and record the date. 1. 2. 3. 4. 5.
PA R T V

Leading autonomous

growth

Nobody Was Watching

21 · Metrics that hide harm

Opening question. Which of your growth numbers would go up if your system were doing something wrong? Growth teams live by numbers: leads found, messages sent, posts published, reply rates, pipeline value. Those numbers are meant to measure progress. In an autonomous pipeline they can also measure harm, because many of the defects described in this book increase the numbers that founders watch. A lead hunter filing junk raises the lead count. A runner with two clocks doubles the send count. A press module posting into another brand's account produces posts and engagement. Nothing in the metric distinguishes good growth from bad.

Goodhart and its variants

Strathern (1997) gave the most quoted version of Goodhart's law: "When a measure becomes a target, it ceases to be a good measure." Manheim and Garrabrant (2018) distinguished four ways the law operates: Regressional. Selecting for a measure also selects for noise in it. The leads with the highest scores include some whose scores are high by accident. Extremal. At extreme values, the relationship between measure and goal breaks down. Sending 40 messages a day is not twice as good as 20 if the extra 20 go to the wrong people. Causal. Acting on the measure does not act on the goal. Counting the page's own address as a signal raised scores without raising fit. Adversarial. Other agents exploit the measure. Spammers, scrapers and attackers all respond to what a system rewards. Amodei and colleagues (2016), writing about AI systems, described a closely related problem they called reward hacking: an agent optimising a specified objective finds ways to score well that the designers did not intend. A growth pipeline is not an AI agent in that sense. But a pipeline built to "find leads" or "send • • • •
outreach" optimises the stated objective and nothing else. A builder optimising for a working demo is in a similar position: the tests pass, the counts rise, and the unstated goals go unmet.

The Tapstall case

Consider the numbers the first version could report on the morning of the audit: Leads found: 109, rising daily (140 by the afternoon). Outreach sent: steady, every day, with a daily cap that was in practice doubled. Social posts: three a day, every day, for eight days, all accepted by the network. Tests passing: 420 of 420. Every one of those numbers looked healthy. Each one was raised, partly or wholly, by a defect: Leads rose because the hunter filed junk (C2). Outreach volume rose because of the duplicate clock (R3), and its recipients were mostly non-prospects. Posts were accepted because they went to an established account belonging to someone else (H2). Tests passed because they could not see the deployment or the recipients. After the rebuild, the numbers fell. The lead store went from 140 rows to 51, of which only 16 were queued and 3 had been contacted. The hunter produces about ten candidates per run. Outreach is capped at one an hour. Social posts stopped entirely, because Tapstall had no accounts of its own. Sales over 30 days were zero before and after. The rebuild made the pipeline smaller on every growth metric, and more honest on every one. A founder judging by the dashboard would have concluded that the audit made things worse. • • • • • • • •

Harm-aware metrics

The answer is not to abandon metrics. It is to pair every volume metric with a metric that would rise if the volume were harmful. These pairs can be called counter-metrics. Volume metric What it hides Counter-metric Leads found Junk, chains, wrong markets Share of a weekly sample that pass the Recipient Gate by hand Messages sent Wrong recipients, duplicate sends Bounce rate; unsubscribe rate; share of recipients who were plausible prospects Posts published Wrong accounts, empty rails Posts accepted on the product's own accounts, by account Reply rate Replies that are complaints or opt-outs Replies classified by a person: interested, not interested, complaint Tests passing Deployment and recipient gaps Witness map: red cells remaining Pipeline value Leads that will never convert Leads reachable by the channel you actually have (email versus phone) The rule is simple. No volume metric appears on a dashboard without its counter-metric beside it. If the counter-metric cannot be computed, the volume metric should be labelled as unverified.

What to reward

For founders who manage others, such as sellers, contractors or agents, the choice of metric is also a choice of incentive. Tapstall's sellers earn a 30% commission on sales. That aligns them with real customers, not with lead counts. A pipeline that paid for leads found or messages sent would have rewarded exactly the defects this book describes. The same applies to the builders of the pipeline, human or AI. A builder rewarded for "outreach is running" will deliver running outreach. A builder asked for "outreach reaches plausible prospects, from our own identity, and honours every exit, as shown by a sample of real sends" will deliver something closer to what the founder wants. Chapter 23 returns to this.

What the case does not show

The case cannot show that counter-metrics would have changed decisions. No one was managing Tapstall's pipeline by its volume numbers in a formal way; the owner was running several ventures at once. The point is illustrative. Every number the first version could report was inflated by a defect, and the rebuild deflated all of them. Whether the smaller, honest pipeline will produce more sales than the larger, noisier one is unknown; sales were zero before and after. The chapter rests on the general logic of Goodhart's law and on the observed pattern in this case, not on evidence that counter-metrics improve outcomes. That would require ventures to be followed over time.

Points of debate

"Counter-metrics slow growth." They slow apparent growth. Real growth, in paying customers, was zero in the case both before and after. The counter-metrics make visible what the volume metrics hid. "Small numbers are demoralising." They can be. But a founder who is cheered by a lead count full of weather forecasts is not well served by the cheer. The case's honest pipeline was smaller, and every lead in it was real. "Every metric can be gamed." Yes. Pairs are harder to game than single metrics, because gaming one usually moves the other the wrong way. And metrics that require a person to read a sample are hard to game automatically.

Discussion questions

Which of your growth metrics would rise if your system were behaving badly? For each volume metric on your dashboard, what is its counter-metric? Can you compute it? What do you reward your sellers, contractors or agents for? Could that reward encourage harm? Has a fix ever made your numbers look worse while making your business better? How did you explain it? Which Goodhart variant is most likely to affect your pipeline? 1. 2. 3. 4. 5.

Apply it

List the five numbers you look at most often to judge your growth. For each, write down how a defect could raise it. Then define a counter-metric and compute it this week, even roughly, by hand if necessary. Put each pair side by side on your dashboard. If any volume metric has no computable counter-metric, label it "unverified" until it does.

22 · Law, ethics and reputation

Opening question. If a regulator, a journalist or one of your recipients looked closely at what your automation did last month, what would they find? The costs described in Chapter 4 travel along a path: from strangers, to platforms, to borrowed identities, to the sender and finally to the founder. The last steps of that path are legal and reputational. This chapter sets out the main rules relevant to the case, discusses the ethical position underneath them, and considers what reputation means for a small venture whose automation speaks in its name. This chapter is not legal advice. Laws change and their application depends on facts. Founders should take advice for their own markets.

The legal landscape in the case

Tapstall serves merchants in South Africa and Zimbabwe and uses infrastructure based largely in the United States. Three bodies of law are relevant to its outreach. South Africa's Protection of Personal Information Act (POPIA, Act 4 of 2013) regulates direct marketing by electronic communication in section 69. In broad terms, it allows unsolicited electronic direct marketing to a person only with consent, or to an existing customer under conditions. The person may be approached once for consent. Every message must give the recipient a way to opt out. There is debate about how the section applies to messages addressed to businesses rather than individuals, and founders should take advice. But the direction is clear: consent and a working exit. The United States CAN-SPAM Act of 2003 permits commercial email without prior consent but requires accurate headers, a non-deceptive subject, identification as an advertisement where applicable, a valid postal address and a working opt-out honoured within ten business days.
Zimbabwe's Cyber and Data Protection Act of 2021 regulates the processing of personal information, including the requirement for a lawful basis, and gives data subjects rights over their data. Its specific provisions on direct marketing are less detailed than South Africa's, but it applies to data about people in Zimbabwe, which the lead hunter collected. Beyond statute, platform rules carry practical force. Google's requirements for bulk senders, announced in 2023, require authentication, one-click unsubscription and low spam-complaint rates (Kumaran, 2023). Social networks' terms prohibit impersonation and restrict automated posting to the account holder's own accounts.

The case against the rules

Measured against those rules, the first version's outreach had clear problems: Messages went to individuals and businesses in several countries, most of whom were not prospects, without consent. The third touch in each sequence had no opt-out. No message carried an unsubscribe header. Some messages had no postal address. Bounces were ignored, so dead addresses were mailed again. The sending identity was another venture's support address, which a recipient would not connect to the product being sold. Posts went out under another venture's social account. The rebuild addressed the mechanics: an exit in every message, standard headers, a postal address field, bounce handling, a dedicated sender, three touches at most and a gate restricting contact to businesses' own published addresses in served markets. The postal address itself was left as a setting for the owner to fill in. Whether the remaining outreach is lawful in each market depends on questions the case cannot settle, such as whether a business's published contact address counts as consent for a single approach under POPIA. The owner was advised to take advice.

The ethical position

Laws set minimums. The ethical question is what a founder owes to the people their automation reaches. • • • • •
The case suggests a position based on three commitments. These are proposals, not settled principles. Relevance. Only contact people for whom the message could plausibly be useful. The Recipient Gate is the mechanism. Recognisability. Speak in your own name, so recipients know who is writing and why. One identity and one voice are the mechanisms. Reversibility. Make it easy to stop, and stop immediately. The Stoppability Standard is the mechanism. These map onto the rules without depending on them. A founder who applies all three in a market with no applicable law will still be acting well. A founder who meets every legal requirement while ignoring relevance will still be spending strangers' attention without cause.

Reputation

For a small venture, reputation is fragile and slow to build. Automation changes how it is made. In a staffed business, the people who speak for the business are hired, trained and supervised. In an automated one, the system speaks, and nobody supervises each utterance. The case shows three ways automation can damage reputation: Directly, through irrelevant messages that associate the brand with nuisance. By contagion, when a borrowed identity spreads one venture's mistakes to another. STPi's followers saw posts they had not asked for, and its support address sent sales pitches. By provider judgement, when mail providers and social networks downgrade a sender or account based on complaints, bounces and behaviour, often without notice. Vaughan (1996) showed how organisations can drift into accepting risks through small steps, each normalised by the absence of immediate consequences. Reputational damage from automation usually arrives in exactly that way: weeks of quiet, then a suspended account or a public complaint. 1. 2. 3. • • •

Framework: the Close Look test

Imagine three people examining one month of your automation's actions. Answer as each would. Examiner What they would look at What would concern them Your evidence A regulator in each market you contact Consent basis, opt-outs, postal address, data held about individuals Messages without a lawful basis or exit; opt-outs not honoured A journalist The worst ten messages or posts Irrelevant contact; borrowed identities; anything embarrassing out of context A recipient The message they received Not recognising the sender; no way to stop; not being a plausible customer If any column would produce a story you would not want told, fix the cause before the next send.

What the case does not show

The case does not establish that any law was broken. No regulator examined the outreach and no complaint is known. The chapter describes how the first version's practices measured against the rules, as a reader can see them, not a legal finding. Interpretations of section 69 of POPIA, in particular, differ on business addresses, and Zimbabwe's law is newer and less tested. The ethical commitments proposed here are the author's, offered for discussion, and some readers will hold stricter or looser views. What the case shows without ambiguity is the reputational mechanism: one venture's automation speaking in another venture's name, to people who had no reason to expect it.

Points of debate

"Small ventures are too small for regulators to notice." Enforcement is uneven. Platforms, however, enforce constantly and automatically. A mailbox suspended for complaints is a real penalty, applied without a hearing.
"Business-to-business email is different." In some laws it is treated differently, and in others it is not. The ethical commitments do not depend on the recipient's legal status. "Shared ownership means no harm to the other venture." As Chapter 6 argued, the other venture's audience did not consent. Ownership does not transfer their consent.

Discussion questions

Which laws apply to your automated outreach, given where your recipients are? How confident are you? Which of the three commitments (relevance, recognisability, reversibility) does your system meet most weakly? What would a journalist find if they read your worst ten automated messages? Has any of your ventures' reputations been affected by another venture's automation? Where do your own ethical standards go beyond what the law requires?

Apply it

Run the Close Look test on one month of your automation's output. Read it as each examiner would and record what concerns them. For each concern, trace it to a mechanism in your system and fix the mechanism, not just the message. Then take legal advice for any market where you are unsure of your consent basis. 1. 2. 3. 4. 5.

23 · Governing the builders

Opening question. When an agent, a contractor or a tool builds your growth system, how do you make sure it builds one that can be watched? Founders increasingly do not build their own pipelines. They commission them: from contractors, from no-code platforms, from AI coding agents, or from some combination of these. The builder delivers something that runs. Whether it delivers something that can be witnessed depends on what the founder asked for and what the founder checked. This chapter is about governing builders so that witnessability is part of the brief, not a later discovery. It applies whether the builder is a person, an agency or an AI agent. As the front matter said, this book does not claim to know how Tapstall's first version was produced, and treats any special role for AI tools as a hypothesis.

What builders optimise

Every builder optimises what they are judged on. Conway (1968) observed that a system's structure mirrors the communication structure of the organisation that built it. A pipeline commissioned through a chat with a single founder, judged on whether it runs, will be structured around running. It will have a scheduler, a sender and a dashboard. It will not have a recipient gate, an identity ledger or an effect receipt unless someone asked. Sculley and colleagues (2015) showed how systems accumulate hidden debt in their configuration, dependencies and feedback loops, places that code review tends not to look. Agents and contractors who build quickly can accumulate the same debt quickly. The evidence on AI coding tools adds a specific caution. Peng and colleagues (2023) found large speed gains on a well-defined task. Becker and colleagues (2025) found that experienced developers working on real, complex repositories were slower with AI tools, while believing they were faster. Whatever the tools'
true effect on speed, the second finding points to a gap between perceived and actual progress, which is exactly the kind of gap that unwitnessed autonomy exploits. A founder who feels the pipeline was built quickly may also feel it was built well.

The case

The audit and rebuild of Tapstall were carried out by the owner working with AI coding agents, as the front matter discloses. That process is itself an example of governing a builder. Several of its practices are worth describing, because they are transferable. They are practices observed in the case, not evidence that they are sufficient. Read-only first. The audit began by reading live state, sent mail and account inventories without changing anything. Only after the findings were recorded did the rebuild start. Evidence for each finding. Each finding was tied to something observable: a stored row, a sent message, a deployed copy, a secret name, a request that should have been refused. Findings without evidence were not coded. Live confirmation. Fixes were confirmed by effects in the world: a real test email found in a real mailbox, dry runs on the production job runner, a redirect answering in place of an old copy. Standing rules from the owner. Several rules came from the owner, not the builder: remove every spreadsheet, label waiting rails honestly, keep within free-tier budgets, reuse one shared mailbox for now. The builder applied them. They were not the builder's to invent. Candour about remaining gaps. Items not fixed were recorded as open: the older runner still sending from the personal mailbox, the postal address setting still empty, suspensions at expiry not yet waiting for a delivered warning. The same AI-assisted process produced both the original defects' discovery and some new defects (R9–R12). That should temper any claim that the right tools alone prevent witness gaps. • • • • •

The witnessable brief

A founder commissioning any autonomous growth system can include witnessability in the brief. The following is a proposed template. Requirement What the builder must deliver What the founder checks Action list Every outward action the system takes, listed The list matches what the system does in a dry run Witness map Five answers per action (identity, clock, effect, recipient, stop) Each answer is checked against the deployment, not the code Own identities Every credential created for this system, named after it The Identity Ledger, filled from the secret store One clock Exactly one trigger per action; outcomes recorded; failures retried The Clock Register, across all accounts Effect labels Health screen shows effects with receipts, and honest waiting states Force a failure; see it on the screen Recipient gate Checks at the point of contact, failing closed Run 30 real leads through by hand Exits Stoppability Standard met Become your own recipient Dry-run mode Every outward action can run in production with no outward effect Run it; read the output Remaining gaps A written list of what is not done The list exists and is specific The last line is the most important. A builder who hands over a system with no list of remaining gaps is either unusually thorough or not looking. The founder should assume the second until shown the first.

Acceptance as evidence

Acceptance tests for a growth system should be evidence of effect, not demonstrations. A demonstration shows that the system can do something. Evidence shows that it did, in production, to the right people, under the right identity, and that the people could stop it. The difference matters most for autonomous actions, because once accepted they will run unattended.
The case suggests four pieces of evidence for any outward action before acceptance: A dry run in production, read by the founder. One real effect, confirmed from outside. The witness map row, checked against the deployment. A stop, tested.

What the case does not show

The case is one owner governing one set of AI coding agents on one day. It cannot show that the practices described would work for teams, contractors or agencies, or that they are better than alternatives. It also cannot attribute the first version's defects to any particular builder or tool; the book has said throughout that this question is open. The same process found defects and introduced new ones, which cuts against any claim that it is sufficient. The witnessable brief is therefore a proposal, assembled from what was needed afterwards. It has not yet been used to commission a system from the start, which is the test that would show whether it prevents gaps or merely documents them.

Points of debate

"Agents and contractors can't be expected to know about recipients they

never see." That is why the founder must ask. The brief makes the invisible visible to the builder. "AI tools will soon do this checking themselves." Perhaps. The case suggests caution: the same process that found defects also introduced new ones. Checking by a party with different incentives, or by the world itself through dry runs and real effects, remains valuable whatever the builder. "This brief is too heavy for a weekend project." A weekend project that sends mail to strangers is no longer a weekend project. The brief scales down: for a small system, each line takes minutes. 1. 2. 3. 4.

Discussion questions

What did you ask for the last time you commissioned an automated system? What did you check? Which items in the witnessable brief would your builders find hardest? Why? Have you accepted a system on the strength of a demonstration rather than evidence of effect? Which standing rules should come from you as the founder, rather than from your builders? Does your builder give you a list of remaining gaps? Would you trust a system that came without one?

Apply it

Take the witnessable brief and add it to your next commission, whoever the builder is. For an existing system, use the "what the founder checks" column as an acceptance audit: perform each check, record the result and ask the builder for a written list of remaining gaps. Compare their list with yours. 1. 2. 3. 4. 5.

24 · A ninety-day programme

Opening question. If you took this book seriously, what would you do on Monday, and what would your pipeline look like in three months? This chapter turns the book's frameworks into a programme. It is designed for a founder or a small team running an autonomous growth pipeline, with limited time and no budget for consultants. It assumes the pipeline is already live. A founder still building one can use the same steps as a design sequence. The programme is a proposal, not a tested method. It is assembled from the practices that found and fixed the defects in the Tapstall case, put in an order that respects the case's main lessons: look before you fix; fix identity and clock before effect and recipient; build replacements before removals; and repeat.

Weeks 1–2: Look

The first two weeks change nothing in the pipeline except pausing actions while their ledgers are read. Day 1–2: the account inventory (Chapter 12). List every deployment, schedule, data store, secret name and public page on every account you control. Do not fix anything. Day 3–4: the ledger read (Chapter 13). Read the last 20 sent messages, received messages, posts, leads and money events in raw form. Record every surprise. Day 5–7: the witness map (Chapter 11). List every outward action. Answer the five questions for each from the inventory and the ledgers. Mark each cell green, amber or red.

Week 2: the money path walk (Chapter 10) and the Close Look test (Chapter

22). Walk every path by which money or control changes hands, as an outsider. Read a month of output as a regulator, a journalist and a recipient would.
At the end of week 2 you should have four documents: the inventory, the ledger notes, the witness map and a list of findings. Code each finding by class (Chapter 3) and severity. Expect witness gaps to be a large share.

Weeks 3–4: Contain

Containment stops harm before repair begins. Stop the worst outward action. If any action is sending to wrong recipients, posting under a borrowed identity or running on a duplicate clock, pause it now. Mark junk. Move every lead that fails the Recipient Gate (Chapter 5) to donot-contact or delete it. Do this at the claim door as well as at ingest. Remove borrowed identities. Delete borrowed credentials from secret stores. Ask the owners of borrowed accounts to revoke access on their side. Retire stray copies. Follow the five-step sequence (Chapter 7): export, remove schedules, delete secrets, redirect, verify. Fix authority holes. Close any money-path leak found in week 2. Record what was contained and when. In the case, containment included 32 junk leads marked do-not-contact, 89 junk rows deleted, borrowed social credentials deleted, three old copies redirected and an owner secret rotated.

Weeks 5–8: Rebuild to be watched

Now apply the four rules (Chapter 16), in the order the case suggests. One identity. Create dedicated credentials for every outward action. Fill in the Identity Ledger (Chapter 6). One clock. Remove duplicate triggers. Make the remaining clock record outcomes and retry failures. Fill in the Clock Register (Chapter 7). Effect receipts. Rewrite every status that gates a consequence so that it is written after the receipt (Chapter 8). One voice and stoppable outreach. Meet the Stoppability Standard (Chapter 17). Parse replies for the recipient's own words (Chapter 9). • • • • • • • • •
One surface. Build the replacement surface before removing any second surface. Armed distribution. Re-register channels so that each waits for its own account (Chapter 18). Ceilings. Add counters and self-imposed budgets (Chapter 19). Health screen. Replace configuration labels with effect labels, add identity columns and waiting states, and add a one-real-effect lever (Chapter 15). Stops. Fill in the Stop Matrix and test each stop (Chapter 20). Apply the Change Witness Protocol (Chapter 14) to every change: map, ask the day-after question, dry run, read, one real effect, watch the first cycle. Expect the rebuild to create new defects. In the case, four of the 13 rebuild findings were introduced by the rebuild.

Weeks 9–12: Make it a habit

The last month turns the programme into standing practice. Weekly ledger read, 30 minutes, with a log of red flags. Counter-metrics beside every volume metric on the dashboard (Chapter 21). Monthly account inventory refresh. Witness map re-run after every change that adds or alters an outward action, and in full each quarter. The witnessable brief (Chapter 23) added to every commission. A written list of remaining gaps, reviewed monthly, with an owner and a date for each.

What to expect

The case suggests some honest expectations. • • • • • • • • • • •
The numbers will fall. Leads, sends and posts will drop as junk, duplicates and borrowed channels are removed. In the case, the lead store shrank from 140 rows to 51, the outreach cap fell to one message an hour and social posting stopped until the product had its own accounts. Plan to explain this to anyone who watches the dashboard. Some leads will need people. A gate that requires a business's own address will leave many small businesses reachable only by phone. Those are leads for sellers, not for automation. Gaps will remain. At the end of the case's rebuild, the open list included an older runner still sending from a personal mailbox, a postal address setting not yet filled in and suspensions that did not yet wait for a delivered warning. A programme that ends with no open list has probably stopped looking. Sales may not change quickly. Tapstall had no sales before the audit and none in the days after. Witnessability is not a growth hack. It is the condition under which growth does not harm strangers, the brand or the founder.

Framework: the Ninety-Day Plan on one page

Weeks Theme Key outputs Done when 1–2 Look Inventory, ledger notes, witness map, coded findings Every outward action has a witness-map row 3–4 Contain Paused actions, junk removed, borrowed credentials deleted, copies retired, authority holes closed No known harm is ongoing 5–8 Rebuild to be watched Four rules applied; receipts; Stoppability Standard; armed rails; budgets; effect labels; stops Witness map has no red cells, or each red is a written decision 9–12 Habit Weekly read, counter-metrics, monthly inventory, briefs, remaining-gaps list Each habit has run at least twice

What the case does not show

The programme has not been run by anyone as written. It is assembled from what happened in one day of audit and rebuild, spread over 90 days to suit a founder with other work. The case's own timeline was far shorter, and it used tools and help
that not every founder has. The phases may need different lengths in other ventures, and some founders will need to contain harm on day one rather than wait two weeks. The programme's order is its most defensible feature, being drawn directly from the case's mistakes: look before fixing, replace before removing, and expect fixes to create new problems. Its timings are suggestions.

Points of debate

"Ninety days is too long when harm is ongoing." If any action is harming people now, containment should start on day one. The two weeks of looking assume that nothing urgent is found. When something is, pause it at once and keep looking. "Ninety days is too short to change habits." Perhaps. The programme aims to start habits and run each at least twice, not to make them permanent. The remaining-gaps list, reviewed monthly, is the mechanism for keeping them alive. "A founder should hire someone to do this." An outside reviewer brings fresh eyes and different incentives, which the case lacked. But the inventory, the ledger read and the witness map need the founder's access and knowledge of intent. The most useful arrangement may be a founder who runs the programme and an outsider who checks the evidence.

Discussion questions

Which phase of the programme would be hardest for your organisation? Why? Who would own each phase? Is that one person? How would you explain falling growth numbers to an investor, a co-founder or yourself? What would you put on your remaining-gaps list today, before starting? Which habit from weeks 9–12 is most likely to lapse? How would you prevent that? 1. 2. 3. 4. 5.

Apply it

Put the four phases in your calendar now, with the first day of each phase blocked out. Do Day 1 of the programme, the account inventory, this week. At the end of the 90 days, run the witness map in full again and compare it with the one from week 1.
T O O L K I T

Frameworks, guide,

glossary and

references

Nobody Was Watching

25 · Framework compendium

This chapter collects every framework in the book in one place, with the question each answers, when to use it and where it is explained. All are proposals derived from one case, offered for testing. None is a validated instrument.

The core idea in one paragraph

Unwitnessed autonomy is the condition of an automated system that takes consequential actions on parties outside its boundary when no party is placed to observe those actions' effects and report them to the operator. A controller would need four witnesses for each action: the recipient (who received it and what they said), the effect (whether it happened), the identity (whose name it used) and the clock (what fired it, and how many things did). Defects that hide one of these are witness gaps. In the Tapstall case they were 16 of 24 defects (67%), and none of the 24 was found by the test suite. The fifth question, stop, asks how the operator and the recipient can halt each action.

Seeing the problem

1. The Four Blind Spots check (Chapter 1). Question: what does a green test run not tell me? Use: before treating tests as evidence about an autonomous system. Asks: what else is deployed; what real inputs arrived; which dependencies tests supply but production may lack; what happened to strangers. 2. The Lost Witness inventory (Chapter 2). Question: what observations disappeared when I automated this job? Use: when automating any job a person used to do, and for existing automations. Columns: replaced job; observation it made as a side effect; whether anything makes it now; cheapest way to restore it. 3. The Witness Question (Chapter 3). Question: "If this went wrong tomorrow, who would see it first, and how would we hear from them?" Use: for any outward action, as a quick screen. Bad answers: "the recipient, and we wouldn't"; "nobody"; "the dashboard" when the dashboard reports attempts, not effects.
4. The Cost Path (Chapter 4). Question: who pays for a mistake, and how long until the cost reaches me? Use: when deciding how much feedback to build into an outward action. Steps: recipient; platform; borrowed identity's owner; your sender identity; you.

Recognising the forms

5. The Recipient Gate (Chapter 5). Question: should this address receive this message? Use: at the moment of contact, not only at ingest. Checks, all failing closed: ownership (the address belongs to the business); market; fit (independent, allowed category); history (not on do-not-contact, no bounce, no unsubscribe). 6. The Identity Ledger (Chapter 6). Question: whose name is each action using? Use: filled from secret stores and consoles; refreshed after any credential change. Rules: any identity not created for this system is a defect until replaced or explicitly accepted by its owner; any shared identity is a coupling; every action's identity is visible on the console. 7. The Clock Register and the retirement sequence (Chapter 7). Question: how many things fire each action? Rules: exactly one trigger per action; record outcomes, not attempts; retry rather than duplicate; cover every account. Retirement: export; remove schedules; delete secrets; redirect; verify. 8. The Effect Receipt (Chapter 8). Question: is this status backed by confirmation from outside? Rules: write the status after the receipt; any status that gates a consequence must have a receipt. 9. The Boundary Reading Table (Chapter 9). Question: does the system read correctly what comes back? Rows: human reply; opt-out; unsubscribe; automatic reply; bounce; payment notice. Rule: test every row with real examples; when unsure about an opt-out, treat it as one. 10. The Money Path Walk (Chapter 10). Question: could an outsider with public information change who owns what or who has paid? Key columns: "could the outsider supply it?" and "what the real owner would see".

Witnessing

11. The witness map (Chapter 11). Question: for every outward action, can the operator see identity, clock, effect and recipient, and stop it? Procedure: list the verbs; answer identity and clock from the deployment; answer effect and recipient from the records; mark green, amber or red; fix reds before adding actions; repeat after changes. Question Good answer Gap closed Identity A credential created for this system alone, held in one place Borrowed identity Clock One scheduler; other copies removed; failures retried Multiplicity Effect A record written after outside confirmation, shown to the operator Silent failure Recipient A check before acting and a channel back Externality, boundary misreading Stop A one-step operator stop and a one-click recipient exit All 12. The Account Inventory sheet (Chapter 12). Question: what is running under my accounts? Use: monthly, from provider consoles, never from memory; never record secret values. 13. The Weekly Ledger Read (Chapter 13). Question: what did the system actually do this week? Sample: last 20 sent and received messages; last 10 posts per account viewed from outside; 20 random leads; all money events. Time: about 30 minutes. 14. The Change Witness Protocol (Chapter 14). Question: what new gaps did this change create? Steps: map; ask the day-after question ("what did the thing I am changing also do?"); dry run in production; read as the recipient; one real effect confirmed from outside; watch the first live cycle. 15. Effect Labels (Chapter 15). Question: does the health screen report effects? Rules: green requires a receipt; every action has named non-green states, such as "on (waiting for account)", "parked" or "retrying"; every outward action shows its identity.

Building to be watched

16. The Four Rules Audit (Chapter 16). One clock: one scheduler per action, recording outcomes and retrying. One voice: one sender identity per conversation, with a working exit and replies read in the recipient's own words. One identity: only credentials created for the system. One surface: one door for actions on prospects and customers, with replacements built before removals. 17. The Stoppability Standard (Chapter 17). Lines: dedicated identity; exit in every message; exit in the headers; honour every exit before the next send; bounces stop mail; opt-outs read in the recipient's words; volume cap with a reserved slot for customer mail; small fixed number of touches; postal address. Verify by: becoming your own recipient. 18. The Rail Readiness Sheet (Chapter 18). Question: is each distribution channel live, waiting or borrowed? Rules: state comes from credentials; unarmed means inert; the account owner is the product; "last post accepted" is an effect label. 19. The Ceiling Budget (Chapter 19). Question: how much of each limit am I using, and what happens at my budget? Rule: set self-imposed budgets well below external ceilings, count usage and show it on the health screen. 20. The Stop Matrix (Chapter 20). Question: how can each action be stopped by the operator, by the recipient and by the system itself? Rule: test each stop and record the date.

Leading

21. Counter-metrics (Chapter 21). Question: which numbers would rise if the system were doing harm? Rule: no volume metric appears without its countermetric; if the counter-metric cannot be computed, label the volume metric "unverified". 22. The Close Look test (Chapter 22). Question: what would a regulator, a journalist and a recipient find in a month of output? Commitments underneath: relevance, recognisability, reversibility.
23. The witnessable brief (Chapter 23). Question: what must a builder deliver so the system can be watched? Lines: action list; witness map; own identities; one clock; effect labels; recipient gate; exits; dry-run mode; a written list of remaining gaps. Acceptance evidence: dry run; one real effect; checked witness-map row; tested stop. 24. The Ninety-Day Plan (Chapter 24). Weeks 1–2: look. Weeks 3–4: contain. Weeks 5–8: rebuild to be watched. Weeks 9–12: make it a habit.

The seven propositions

The working paper states seven propositions for testing in other ventures. They are summarised here because several chapters rely on them. Prevalence. In autonomous growth pipelines run by one person, witness gaps make up the majority of consequential defects. Test blindness. A pipeline's own test suite will detect few or no witness gaps, however extensive the suite. Deployment locus. Borrowed-identity and multiplicity defects will be found by inventorying deployments and credentials, not by reading code. Masking. A duplicate clock prolongs the life of a failure in the primary clock. Composition. Externalities in outreach arise more from the composition of reasonable rules than from decisions about volume; gates at the point of action reduce them most. Repair induces. Repairs introduce new witness gaps at a rate that does not fall to zero; live dry runs catch them more often than tests. Label honesty. Dashboards reporting configuration rather than effect are associated with longer-lived witness gaps; effect labels with a waiting state shorten them.

How the frameworks fit together

A founder with one hour should use the Witness Question (3) on every outward action. A founder with one day should build the account inventory (12), do a ledger read (13) and draw the witness map (11). A founder rebuilding should apply the 1. 2. 3. 4. 5. 6. 7.
Four Rules (16), the Stoppability Standard (17) and Effect Labels (15), with the Change Witness Protocol (14) on every change. A founder leading others should add counter-metrics (21), the witnessable brief (23) and the ninety-day plan (24).

26 · Facilitator's guide

This guide is for anyone leading a group through the book: a founders' circle, an accelerator cohort, a leadership team, a university class or a consultancy workshop. It suggests a five-session format, session plans, activities that use the reader's own systems, and notes on handling the discussions the book tends to provoke.

Format

Five sessions, one part each, of about two hours. Participants read the part before each session and complete at least one "Apply it" exercise on their own systems. Session 5 includes the toolkit. A one-day workshop can cover the core by using Chapters 1, 3, 5, 6, 7, 8, 11, 16 and 24, with the exercises done live. Group size. Six to twelve participants works best. Larger groups should split into tables of four for activities. Materials. Printed copies of the witness map (Chapter 11), the Identity Ledger (Chapter 6), the Clock Register (Chapter 7) and the Stoppability Standard (Chapter 17). Participants need access to their own provider consoles, mailboxes and dashboards for the live exercises. Remind them never to share secret values with the group.

Session 1 · The quiet machine (Chapters 1–4)

Aim. Participants recognise that their systems act on strangers and that their tests cannot see it. Opening (15 minutes). Ask each participant to name one automated action their business takes on someone outside it. Write the verbs on a board: send, post, charge, suspend, file and so on.
Case discussion (30 minutes). Present the Tapstall morning: 420 of 420 tests passing; 17 addresses mailed, 14 not prospects; posts on another venture's account. Ask: "Which of these would your tests catch?" Then: "Which would your dashboard show?" Activity (45 minutes). In pairs, each participant applies the Witness Question to the action they named. Partners push back on vague answers. Each participant marks their answer green, amber or red. Debate (20 minutes). Use the Chapter 4 debate: "A few misdirected emails are trivial." Split the room and argue it. Close (10 minutes). Assign the Chapter 3 exercise: list every outward action and its Witness Question answer.

Session 2 · Anatomy (Chapters 5–10)

Aim. Participants can recognise each form of witness gap in their own systems. Opening (15 minutes). Review the action lists from Session 1. How many actions did people find? Who was surprised? Gallery (40 minutes). Put six posters on the walls, one per chapter: wrong recipients, borrowed identities, duplicate clocks, silent failure, misreading and authority on the money path. Each poster carries the case defects and a blank area. Participants write anonymous examples from their own work on sticky notes. Deep dive (40 minutes). Choose the poster with the most notes. As a group, apply that chapter's framework to two of the examples. Debate (15 minutes). "It's my own other business; there's no harm" (Chapter 6). Close (10 minutes). Assign the Identity Ledger and Clock Register for each participant's own accounts.

Session 3 · Witnessing (Chapters 11–15)

Aim. Participants produce a first witness map for their own pipeline.
Opening (10 minutes). Share one finding from the Identity Ledger or Clock Register. Ask how many found an identity not created for the system, or an action with more than one trigger. Live exercise (60 minutes). Each participant builds the witness map for their pipeline, using their inventory and their own consoles. The facilitator circulates, asking "Where did you get that answer: the code, the deployment or the records?" Pair review (25 minutes). Partners exchange maps and challenge every green cell: "Show me the evidence." Close (25 minutes). Discuss the Chapter 14 question: "What did the last thing you fixed also do?" Assign the Weekly Ledger Read.

Session 4 · Building to be watched (Chapters 16–20)

Aim. Participants plan the changes that would close their reddest gaps. Opening (15 minutes). Report the results of the first ledger read. Count red flags across the group. Become your own recipient (40 minutes). Where possible, participants put a test address into their own outreach and check it against the Stoppability Standard: headers, exit, honouring, bounce handling and the recipient's own words. Where this cannot be done live, walk through it on paper. Design (40 minutes). Each participant writes the three smallest changes that would close their three reddest witness-map cells, ordered so that replacements come before removals. Debate (15 minutes). "One clock is a single point of failure" (Chapter 16), or "Waiting rails look unfinished" (Chapter 18). Close (10 minutes). Assign the Stop Matrix with at least one tested stop.

Session 5 · Leading (Chapters 21–25)

Aim. Participants leave with a ninety-day plan and the habits to sustain it.
Opening (20 minutes). Each participant names their most-watched growth number and how a defect could raise it. Build counter-metrics together. Close Look role play (30 minutes). In threes, participants take the roles of regulator, journalist and recipient, and examine one participant's anonymised sample of automated messages. Brief writing (30 minutes). Each participant drafts a witnessable brief for their next commission. Plan (30 minutes). Each participant fills in the one-page ninety-day plan and names who will own each phase. Close (10 minutes). Agree a follow-up date in 90 days to compare witness maps.

Handling difficult discussions

Defensiveness. Participants may feel the book accuses them of spamming or negligence. Emphasise that every defect in the case arose from ordinary components doing ordinary jobs, and that the case owner commissioned the analysis of their own work. The point is to find gaps, not to assign blame. Ethics of cold outreach. Some participants will reject all unsolicited outreach. Others will see it as normal commerce. Do not try to settle the question. Ask each participant to state their position and check whether their design matches it. The AI question. Participants will ask whether AI tools caused the defects. The book deliberately treats this as open. Redirect the discussion to governance: what would you ask any builder to deliver, and what would you check? Confidentiality. Participants will be looking at real systems, real mailboxes and real data. Establish at the start that no secret values, personal data of recipients or customer names are shared in the room.

Assessment ideas for courses

Witness map assignment. Students map an automated system they use or run, with evidence for each cell. •
Case memo. Students write a two-page memo to Tapstall's owner prioritising the remaining open gaps. Proposition test. Students choose one of the seven propositions and design a small study to test it in other ventures. Brief critique. Students critique a real or constructed commissioning brief against the witnessable brief. • • •

27 · Glossary

Account inventory. A list, drawn from provider consoles, of every deployment, schedule, data store, secret name and public page on every account a founder controls. Chapter 12. Armed (channel or rail). A distribution channel whose machinery is built and switched on, but which acts only when its own credential exists. Until then it shows "on (waiting for account)" and does nothing else. Chapter 18. App password. A password generated by a mail or social provider for a single application, usable without the account's main password and revocable on its own. Authority leak. A defect that lets a party act with authority they should not have, such as taking over an account using public information. Not a witness gap, but often found near one. Chapter 10. Borrowed identity. A witness gap in which an automated action uses a name, account or credential belonging to someone else, such as another venture, a personal account or a demo setup. Chapter 6. Bounce. A notice from a mail system that a message could not be delivered. A standard format exists (RFC 3464), loosely followed. Boundary misreading. A witness gap in which the system misinterprets what comes back from outside, such as reading its own quoted footer as an opt-out. Chapter 9. Ceiling. A hard limit imposed by a provider, such as daily writes, outgoing requests per invocation or messages per hour. Chapter 19. Claim door. The point at which a lead is taken for contact. The book recommends enforcing the recipient gate here as well as at ingest. Chapter 5. Clock. Whatever decides when an automated action runs: a schedule, a trigger, a dispatch. One of the four witnesses. Chapter 7.
Commons. A shared resource open to many users, such as the trust recipients place in unknown senders. Governed, in Ostrom's sense, by rules, monitoring and sanctions. Chapter 4. Confused deputy. A program that uses authority it holds for one purpose to serve another, because nothing ties the authority to the purpose. Hardy's term. Chapter 6. Counter-metric. A metric that would rise if a paired volume metric were rising for harmful reasons. Chapter 21. Decoupling. The separation of formal structures or reports from the activity they describe. Meyer and Rowan's term. Chapters 8 and 15. Do-not-contact. A status that permanently prevents automated contact with an address, set by an opt-out, an unsubscribe, a bounce or a decision that the address is junk. Dry run. An execution of a changed autonomous action, in its real environment with real inputs, that stops short of acting on the outside world and shows what it would have done. Chapter 14. Duplicate clock. A second mechanism that fires the same action. The book argues it is worse than a missing clock because it masks the primary's failures. Chapter 7. Effect. What actually happened in the world as a result of an action. One of the four witnesses. Chapter 8. Effect label. A health-screen label backed by a receipt from outside, as opposed to a label reporting configuration or activity. Chapter 15. Effect receipt. A record written only after an outside system confirms the effect, such as a mail server's acceptance or a post's address. Chapter 8. Externality. A cost or benefit that falls on someone who did not choose it and is not compensated. In the book, a witness gap in which an action lands on the wrong party. Chapter 4. Fail closed / fail open. Whether a check, when it cannot decide, denies (closed) or allows (open). The book recommends failing closed for outward actions. Chapter 5. Free tier. A provider's no-cost plan, usually with hard ceilings.
Induced defect. A defect introduced by a repair. In the case, four of 13 rebuild findings (R9–R12). Chapter 14. Ledger. A raw record of a system's actions: sent mail, posts, stored leads, money events. Chapter 13. Lead hunter. An automated job that finds candidate businesses and their contact details. List-Unsubscribe. A message header, defined in RFC 2369, that lets mail clients find an unsubscribe address or link. RFC 8058 adds one-click unsubscription. Chapter 17. Multiplicity. A witness gap in which an action runs on more than one clock, or a superseded copy runs alongside the live one. Chapter 7. One clock, one voice, one identity, one surface. The four design rules of Chapter 16. Outward action. Any action a system takes that changes something outside its boundary: send, post, charge, suspend, notify, file, delete, match. Parked. A mail lane state in which sending is suspended for a fixed period after a login refusal, to avoid lockouts. Chapter 17. Press module. In the case, the component that composes and publishes social posts on a schedule. Recipient. Whoever receives an outward action, and what they say back. One of the four witnesses. Chapters 5 and 9. Recipient gate. Checks applied at the moment of contact (ownership, market, fit, history), failing closed. Chapter 5. Rail. In the case, one social network or channel that the press module can post to. Research hold. In the case's first version, a status for leads awaiting review. No review mechanism existed. Seller. In the case, an independent person paid a 30% commission to work leads that reply or that can only be reached by phone.
Silent failure. A witness gap in which an action does not happen while the system records that it did, or records nothing. Chapter 8. Stop. How an action can be halted: by the operator, by the recipient or by the system itself. The fifth question of the witness map. Chapter 20. Surface. A place where actions on prospects or customers can be taken, such as a console, a spreadsheet or a script. Chapter 16. Surface sprawl. A defect class in which more than one surface can take actions, or a surface is removed without a replacement. Chapter 16. Unwitnessed autonomy. The condition of an automated system that takes consequential actions on parties outside its boundary when no party is placed to observe those actions' effects and report them to the operator. Chapter 3. Waiting state. A label such as "on (waiting for account)" that distinguishes a switched-on action missing a prerequisite from one that is active or off. Chapter 15. Witness gap. A defect that hides the recipient, effect, identity or clock of an outward action from the operator. In the case, 16 of 24 defects. Chapter 3. Witness map. The audit instrument of Chapter 11: five questions (identity, clock, effect, recipient, stop) for every outward action. Witnessable brief. A commissioning template requiring a builder to deliver a system that can be watched, including a written list of remaining gaps. Chapter 23.

28 · References

Works are cited in the text by author and year. Digital object identifiers (DOIs) were checked against Crossref, and arXiv identifiers against the arXiv service, in October 2026. Standards, regulatory and industry sources are as published at the dates shown. Facts about the Tapstall case come from its live deployment, stored data, sent mail, account inventory and commit history, as of 28 October 2026. The coding of the case and its method are set out in the companion working paper, Unwitnessed Autonomy: Externalities, borrowed identities and duplicate clocks in an autonomous growth pipeline 2026-03, by the same author).

Research and books

Amodei, D., Olah, C., Steinhardt, J., Christiano, P., Schulman, J., & Mané, D. (2016). Concrete Problems in AI Safety. arXiv:1606.06565. https://doi.org/10.48550/ arXiv.1606.06565 Anderson, R. (2020). Security Engineering: A Guide to Building Dependable Distributed Systems (3rd ed.). Wiley. Bainbridge, L. (1983). Ironies of automation. Automatica, 19(6), 775–779. https://doi.org/ 10.1016/0005-1098(83)90046-8 Becker, J., Rush, N., Barnes, E., & Rein, D. (2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. arXiv:2507.09089. https:// doi.org/10.48550/arXiv.2507.09089 Beyer, B., Jones, C., Petoff, J., & Murphy, N. R. (Eds.). (2016). Site Reliability Engineering: How Google Runs Production Systems. O'Reilly Media. Coase, R. H. (1960). The problem of social cost. Journal of Law and Economics, 3, 1–44. Conway, M. E. (1968). How do committees invent? Datamation, 14(4), 28–31. Cook, R. I. (1998). How Complex Systems Fail. Cognitive Technologies Laboratory, University of Chicago. Dekker, S. (2011). Drift into Failure: From Hunting Broken Components to Understanding Complex Systems. Ashgate. Goodchild, M. F. (2007). Citizens as sensors: The world of volunteered geography. GeoJournal, 69(4), 211–221. https://doi.org/10.1007/s10708-007-9111-y (Coldcode Si Labs Library Working Paper
Parasuraman, R., Sheridan, T. B., & Wickens, C. D. (2000). A model for types and levels of human interaction with automation. IEEE Transactions on Systems, Man, and Cybernetics – Part A: Systems and Humans, 30(3), 286–297. https://doi.org/ 10.1109/3468.844354 Parnas, D. L. (1972). On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15(12), 1053–1058. https://doi.org/ 10.1145/361598.361623 Peng, S., Kalliamvakou, E., Cihon, P., & Demirer, M. (2023). The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. arXiv:2302.06590. Perrow, C. (1984). Normal Accidents: Living with High-Risk Technologies. Basic Books. Pigou, A. C. (1920). The Economics of Welfare. Macmillan. Power, M. (1997). The Audit Society: Rituals of Verification. Oxford University Press. Reason, J. (2000). Human error: Models and management. BMJ, 320(7237), 768–770. https://doi.org/10.1136/bmj.320.7237.768 Saltzer, J. H., & Schroeder, M. D. (1975). The protection of information in computer systems. Proceedings of the IEEE, 63(9), 1278–1308. https://doi.org/10.1109/ proc.1975.9939 Sculley, D., Holt, G., Golovin, D., Davydov, E., Phillips, T., Ebner, D., Chaudhary, V., Young, M., Crespo, J.-F., & Dennison, D. (2015). Hidden technical debt in machine learning systems. In Advances in Neural Information Processing Systems 28 (pp. 2503– 2511). Simon, H. A. (1971). Designing organizations for an information-rich world. In M. Greenberger (Ed.), Computers, Communications, and the Public Interest (pp. 37–72). Johns Hopkins Press. Strathern, M. (1997). 'Improving ratings': Audit in the British University system. European Review, 5(3), 305–321. Vaughan, D. (1996). The Challenger Launch Decision: Risky Technology, Culture, and Deviance at NASA. University of Chicago Press. Weick, K. E., & Sutcliffe, K. M. (2007). Managing the Unexpected: Resilient Performance in an Age of Uncertainty (2nd ed.). Jossey-Bass.

Platform, standards and legal sources

Klensin, J. (2008). Simple Mail Transfer Protocol (RFC 5321). Internet Engineering Task Force. https://doi.org/10.17487/RFC5321