Designing constraint-native digital businesses Theories, frameworks and one working case for founders, directors and strategists
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
About this edition ............................................................................................................... PART I · The new economics 1 · The bucket and the flood ............................................................................................ 2 · When building is cheap, what is scarce? .................................................................... 3 · Business models as activity systems .......................................................................... 4 · Constraints as design material ................................................................................... PART II · The value engine 5 · Proof before pitch ....................................................................................................... 6 · The zero price and the free tier ................................................................................... 7 · One engine, four audiences ........................................................................................ 8 · Pricing architecture ..................................................................................................... 9 · Borrowed commerce ................................................................................................... PART III · Distribution without an audience 10 · Be the flower ............................................................................................................. 11 · Inbox physics ............................................................................................................ 12 · Armed but dormant ................................................................................................... 13 · Outbound with proof, replies by hand ....................................................................... 14 · Loops and partners ................................................................................................... PART IV · The operating model 15 · The autonomy boundary ........................................................................................... 16 · Quota-bounded autonomy ........................................................................................ 17 · Unit economics at the meter ..................................................................................... 18 · Verification debt ...................................................................................................... 19 · Tenancy at purchase ............................................................................................... 20 · The cockpit .............................................................................................................. PART V · Learning and strategy 21 · Experiments without vanity ...................................................................................... 22 · Strategy as choice under constraint ....................................................................... 23 · Risk and dependence in borrowed infrastructure ...................................................
This book is written for digital entrepreneurs, SaaS founders, company directors and anyone responsible for business model design, strategy or the direction of a digital business. 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 points on which reasonable people disagree, questions for discussion and a short exercise for your own business. The case is TightBucket, a website "revenue-leak" auditing service built in three days in October 2026 by its owner working with AI coding agents. TightBucket was commissioned by the same owner who commissions the work of Coldcode Si Labs. It is therefore a bounded case, not an independent evaluation. At the time of writing TightBucket had not launched commercially: it had taken no payments and has no customer results to report. Nothing in this book should be read as evidence that its business model succeeds commercially. What the case offers is unusual visibility into how a business was designed and governed under hard constraints, recorded in its code, documents, defect log and usage data. Throughout, three kinds of statement are kept apart: Research findings are cited to their sources. Measured facts about the case come from its repository, its usage data and its providers' published terms as of October 2026. Design targets, constructed examples and proposed frameworks are labelled as such. They are recommendations and propositions, not proven laws. Prices, quotas and platform terms change. Figures quoted from providers are as published in October 2026. No professional biography, endorsement, ISBN or independent audit is claimed. The author and funding credits are those specified by the commissioning owner. The case venture was built with AI coding agents, and AI tools assisted in drafting • • •
For most of the history of software businesses, the hard part was building. You needed engineers, months and money before anyone could judge whether the idea deserved them. Strategy was largely about deciding what to build with scarce engineering capacity. That constraint is weakening fast. A single owner working with AI agents can now produce a working, tested, multi-audience product in days. Cloud providers' free tiers are generous enough to run it. Merchant platforms will handle checkout, tax and payouts for a percentage of each sale. The cash cost of starting is approaching zero. This does not make business design easier. It moves the difficulty. When building is cheap, the scarce things are attention (yours and your prospects'), trust, reputation in borrowed channels, and the ability to check that what was built behaves as intended. When infrastructure is free, its rules (quotas, sending limits, platform terms) become the real boundaries of the business. A founder who ignores them finds out about them in production. The central argument of this book is that such constraints should be the starting material of a business model, not obstacles discovered later. We call a business designed this way constraint-native. The image in the title is the bucket that holds what it catches: a business that leaks nothing it has earned (no wasted attention, no burned reputation, no surprise bills) because its limits were designed in from the start.
Founders and solo operators who can now build almost anything and need to decide what to build, how to sell it and how to run it without a team. SaaS founders and product leaders designing free tiers, pricing ladders and acquisition systems. • • © 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.
Directors and board members overseeing products that are increasingly built and operated by AI, who need ways to ask the right governance questions. Strategists, consultants and educators who want a contemporary case and a set of frameworks to teach with. No programming knowledge is assumed. Technical details appear only where they change a business decision, and are explained when they do.
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 TightBucket case: what the case did, and what it shows and does not show. A framework or tool you can apply. 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 business. The chapters can be read in order or by part. Groups meeting weekly can take one part at a time over five sessions, or one chapter at a time over a semester. 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.
Part I · The new economics (Chapters 1–4) explains what changes when building is cheap, and introduces constraints as design material. Part II · The value engine (Chapters 5–9) covers proof-first offers, free and freemium, serving several audiences with one engine, pricing architecture and selling through borrowed commerce. • • 1. 2. 3. 4. 5. 6. 7. • •
Part III · Distribution without an audience (Chapters 10–14) covers inbound pull, the physics of the inbox, dormant capacity, honest outbound and growth loops. Part IV · The operating model (Chapters 15–20) covers where autonomy should stop, governing an autonomous business against quotas, unit economics at the level of the meter, verification debt, customer tenancy and the owner's cockpit. Part V · Learning and strategy (Chapters 21–24) covers experiments, strategy as choice under constraint, the risks of borrowed infrastructure and a ninety-day programme.
TightBucket audits a business's public website for "revenue leaks": slow pages, unclear pricing, broken forms, missing email authentication. Given an address, it scores the site out of 100 and ranks the fixes. It serves four audiences under one brand (e-commerce merchants, SaaS founders, sales directors and agencies), each with its own audit page and free tools, ten free tools in all. Its paid ladder runs from free use with no sign-up, through a free account and paid plans at $39 and $149 a month, to done-for-you remediation from $300. A store plan at $19 a month is sold inside an e-commerce platform's app store. The owner set the constraints before anything was built: zero budget; checkout entirely on a merchant platform; email through a free mailbox; four audiences under one roof; autonomous operation with a human only for important work; no automation of a professional network whose terms forbid it; no existing audience; customers who seek the business out; and no more than 20% of any free cloud quota or free automation minutes, "so that I never need to worry about quotas". • • • • • • • • • • • •
The result, built between 26 and 28 October 2026, is a single serverless application on a free plan with about 7,800 lines of application code, about 6,450 lines of distribution code and 396 automated tests. It has: a quota governor that measures every database row and AI unit and crosschecks the provider's own figures; two email lanes; an owner's cockpit; automatic team workspaces for paying customers; a distribution engine of more than thirty publishing channels, built and waiting for accounts. Two line-by-line reviews found and fixed 43 defects. At its observed peak it used less than 2% of any free quota. At the end of the observation window it had 19 audits on record, 9 outreach messages prepared for the owner, no sales and one member: the owner. That is the whole case. The rest of the book asks what it teaches. • • • • •
PA R T I
The Tight Bucket
Opening question. If almost anyone can now build a working software product in days, what still separates a business from a pile of software? In October 2026 one owner, working with AI coding agents, built a complete multiaudience software business in three days. It had a scoring engine, ten free tools, a paid ladder, two email systems, a customer portal, team workspaces, an owner's console and a distribution engine for more than thirty channels. It had 396 automated tests. It had taken no money and spent none. Ten years earlier that list would have described a funded start-up's first year. The question this chapter asks is what such a capability does to business design. Our short answer is that it creates a flood, and that the businesses which last will be the ones that behave like a good bucket.
The evidence that AI changes the cost of building is now substantial, though uneven. In a controlled experiment, programmers given an AI pair-programmer completed a bounded coding task 55.8% faster than those without (Peng et al., 2023). In professional writing tasks, access to a chat assistant cut the time taken and raised the assessed quality of the work (Noy & Zhang, 2023). In a large customer-support operation, an AI assistant raised the number of issues resolved per hour by 14% on average, and by 34% for novice and less-skilled workers (Brynjolfsson, Li & Raymond, 2025). The gains are not universal. A field experiment with management consultants found large improvements on tasks inside the AI's capability "frontier", but worse performance on a task just outside it. The authors call this a "jagged technological frontier" (Dell'Acqua et al., 2026). The tool is excellent at some things and confidently wrong at others, and the boundary is not visible from the outside.
Infrastructure has followed the same path. Serverless computing lets a developer run code without provisioning or managing servers, paying only for what is used (Jonas et al., 2019). Many providers now give away enough capacity to run a small business at no charge. The provider used in our case, for example, allows 100,000 requests and 100,000 database row writes a day on its free plan. Put the two together and the cash cost of starting a software business approaches zero.
Herbert Simon made the essential point decades before any of this: "a wealth of information creates a poverty of attention" (Simon, 1971). What information consumes, he observed, is the attention of its recipients. When building is cheap, products, features, landing pages, cold emails and social posts all multiply. The supply of things competing for attention rises much faster than the attention available to absorb them. Every inbox, feed and marketplace fills up. That is the flood. Information goods have long had high fixed costs and near-zero marginal costs, which pushed their economics towards versioning, bundling and lock-in (Shapiro & Varian, 1999). What is new is that the fixed cost of creating the good is falling too. When both fixed and marginal costs fall, the price of the product is no longer the main barrier between a buyer and a seller. The barrier is the buyer's attention and trust.
A bucket is a modest image for a business, chosen deliberately. A bucket does not make water. It holds what it catches, and its quality is judged by what it does not lose. A leaky bucket can be filled endlessly and still end up empty. Businesses in a flood leak in four characteristic ways: Attention leaks: a prospect looks once and never returns, because the first contact asked for something before it gave anything. •
Reputation leaks: a sender's standing with inbox providers, platforms or communities is spent on messages that were not wanted. Capacity leaks: a free tier is quietly exhausted, a bill arrives, or a service stops at the worst moment. Correctness leaks: something built quickly does something plausible but wrong, and nobody notices until a customer does. A constraint-native business is designed so that each leak is closed by construction. The rest of this book explains how.
The case business takes its name from this idea. Its product is itself a leak detector: an automated audit that finds where a business's website loses money through slow pages, unclear prices, broken forms or missing email authentication. Its owner did not begin with a market size or a revenue target. He began with constraints: zero budget, checkout on a merchant platform, email through a free mailbox, autonomous operation, no automation of a professional network, no existing audience, and a rule that the business should never use more than a fifth of any free quota. Building was not the bottleneck in the case. The product was built and reviewed in three days. The bottlenecks were elsewhere: The distribution engine was complete but had no accounts to publish from, so every channel sat waiting. Outreach messages were prepared but needed the owner's attention to send on a network that forbids automation, and to answer replies. Two line-by-line reviews found 43 defects in code that had been produced quickly. Most were silent: the code ran, and did the wrong thing. The business had no reputation yet in any channel: no sending history, no community standing, no reviews. What the case does not show is whether the bucket holds water commercially. It had made no sales by the end of the period studied. It shows what a business looks like when building is easy and everything else is hard. • • • • • • •
Before designing a business, test how flooded its market is likely to become. Score each statement from 0 (not true) to 2 (very true): Statement Score A competent person with AI tools could build a credible version of our product in under a month Our buyers already receive unsolicited offers for products like ours every week The main channels to our buyers (inbox, feed, marketplace) are crowded and filtered Buyers cannot easily tell a good provider from a poor one before buying Our product's value can be shown, not just described, in the first few minutes We hold an asset that cannot be built quickly: an audience, a dataset, a relationship, a licence Add statements 1–4 for a flood score (0–8), and statements 5–6 for a bucket score (0–4). A high flood score with a low bucket score is the most dangerous position: you are entering a crowded market with nothing that holds attention. The chapters in Part II are mainly about raising the score on statement 5. Those in Parts III and IV are about protecting the assets in statement 6 once you have them.
Is building really cheap? Building the first version is cheap. Maintaining, securing and supporting it may not be. Some argue that AI moves cost from building to maintenance rather than removing it. Chapter 18 takes this seriously. Does the flood favour incumbents? If attention and trust are the scarce inputs, firms that already have audiences and brands may gain more from cheap building than newcomers. The flood might entrench incumbents rather than democratise entry. Is "constraint-native" just good engineering? One view is that designing within limits is what competent engineers always did, and that a new name adds nothing. Another is that the free-tier economy makes constraints • • •
quantified and binding in a way that changes business decisions, not just technical ones. Does a jagged frontier make AI-built businesses fragile? If the tool is confidently wrong outside its frontier, a business built mostly by AI may carry hidden defects. The case's 43 findings point that way. Whether review can reliably remove them is an open question.
Which of the four leaks (attention, reputation, capacity, correctness) is your business most exposed to today? How would you know? Simon wrote about information in 1971. What has changed since then, and what has not? If your main competitor could rebuild your product in a month, what would you still have that they do not? The case's owner began with constraints rather than a revenue goal. What would your business plan look like if you did the same? Where in your own work have you seen AI tools perform well inside their frontier and badly just outside it?
Run the Flood Test for your business or a business you are considering. Write one sentence explaining each score. List the four leaks and, for each, name one place where your business is losing something it has already earned. Choose the largest leak. Write down what it would take to close it by design, so that closing it does not depend on someone remembering to act. • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. If code, content and infrastructure are now abundant, which inputs actually limit a digital business, and how should that change where you spend your time? Economists like to say that when something becomes cheap, its complements become valuable. When cars became cheap, roads, fuel and parking became valuable. When computing became cheap, software became valuable. If building software is becoming cheap, the question for a business designer is: what are its complements? This chapter argues that there are five, and that a business should be designed around them.
Agrawal, Gans and Goldfarb (2019) offer a useful lens. They describe recent AI as a drop in the cost of prediction: filling in missing information, from the next word in a sentence to the likely outcome of a decision. When prediction becomes cheap, the value of its complements rises. The most important complement is judgement, meaning deciding what a prediction is worth and what to do about it. Building software with AI is, in this sense, a form of prediction. The tool predicts the code that satisfies a request. What it cannot supply is a judgement about whether the request was the right one, whether the result does what the owner intends, and whether it is safe to put in front of customers. Those judgements remain human, and they become relatively more valuable as building gets cheaper. Raisch and Krakowski (2021) add an important warning. Automation (machines taking over tasks) and augmentation (machines working with people) are not alternatives to choose between. They are interdependent across time and across
parts of an organisation. A business that automates a task today shapes what its people can do tomorrow, and a business that only augments may never capture the efficiency gains. Both are needed, and the tension between them has to be managed rather than resolved.
Coase (1937) asked why firms exist at all if markets can co-ordinate activity. His answer was transaction costs: it is sometimes cheaper to organise work inside a firm than to buy it on the market. When the cost of producing activities inside the firm falls sharply, as it does when one person with AI tools can do what once needed a team, the minimum efficient size of a firm falls too. The case is an example. A single owner operates an activity system that includes product development, marketing content, outreach, customer support, billing administration and operations. Some activities are performed by the owner's software, some by borrowed platforms, and a few by the owner personally. The firm is very small. Its activity system, in the sense used by Zott and Amit (2010), is not.
If building is abundant, five inputs become the real limits on a digital business. Attention. This means both the attention of prospects, which the flood consumes (Chapter 1), and the attention of the owner, which is fixed at a few hours a day whatever the software can do. Trust. Buyers cannot see quality before buying. A seller with no history faces what Akerlof (1970) called the market for lemons: when buyers cannot tell good from bad, they discount everyone. Trust is the input that overcomes this, and it is earned slowly. Borrowed reputation. Small businesses reach customers through channels they do not own: an email provider's standing with inbox filters, an account on a social network, a listing on a marketplace, membership of a community. Each has a reputation attached that can be spent and lost. 1. 2. 3.
Verification capacity. This is the ability to check that what was built does what was intended. AI can produce systems faster than anyone can read them. The capacity to verify becomes a limit on how fast it is safe to build. Permissions and accounts. Many channels require an account, an approval, an API key or an application. These take human steps and calendar time that no amount of code can shorten. Notice what is not on the list: engineering capacity, infrastructure and, for many small digital businesses, cash.
The case shows all five scarcities clearly. Owner attention was treated as the binding budget from the start. The build plan set a design target (not a measurement) of about 25 minutes of owner time a day, spent mainly on replies to prospects and on sending prepared messages. Everything else was meant to run alone. The owner's cockpit opens on a "Today" view that ranks the few things needing a human decision. Trust shaped the product. Because the business had no history, every route in begins with a free audit of the prospect's own website. The product shows its value before asking for anything (Chapter 5). Borrowed reputation shaped the email design. Two free mailboxes were used, under daily caps set below the providers' limits. Automatic gates pause a mailbox on signs of trouble such as bounces, opt-outs or spam-folder placement (Chapter 11). Verification capacity shaped the construction process. The owner required every line to be reviewed, and two reviews found 43 defects. Most would never have produced a visible error (Chapter 18). Permissions and accounts were the clearest bottleneck at the end of the period studied. The distribution engine was complete, but no social accounts existed. Each channel waited for its credentials, and the owner's console now labels such channels "on (waiting for account)" rather than "active" (Chapter 12). Engineering, by contrast, was not scarce. The product was built in three days. 4. 5.
List the five scarce inputs. For each, record four things: Input Our current stock What consumes it What replenishes it Weekly budget Owner attention e.g. 2 focused hours a day Support, outreach replies, admin Delegation, automation, saying no e.g. 10 hours Trust e.g. 3 public case studies Broken promises, errors seen by customers Proof, references, consistency n/a: protect Borrowed reputation e.g. mailbox standing, community karma Unwanted messages, selfpromotion Wanted messages, useful answers e.g. 200 cold emails Verification capacity e.g. 4 hours of review a week New features, rapid changes Tests, review routines, fewer changes e.g. 1 feature a week Permissions and accounts e.g. 2 of 8 channels approved Policy breaches, inactivity Applications, good standing n/a: track The ledger has one simple use. Before adding a feature, a channel or a campaign, ask which of the five it consumes and whether the budget allows it. Building may be free; the inputs it consumes are not.
Is cash really no longer scarce? For a solo digital business on free tiers, perhaps. For a business that needs inventory, regulated licences, paid advertising or staff, cash remains the binding constraint. The argument of this chapter applies most strongly to small, software-delivered businesses. Will verification itself be automated? If AI can review code as well as write it, verification capacity may stop being scarce. Others argue that a reviewer that shares the builder's blind spots cannot substitute for human judgement about intent. Is attention a fixed budget? Some founders treat their own attention as expandable through longer hours. The case's design target treats it as fixed. Which assumption produces better businesses over several years? • • •
Do trust and reputation differ? We separate trust (held by buyers) from borrowed reputation (held by channel owners). One could argue they are the same asset seen from two sides.
Which of the five scarce inputs most limits your business today? Which will limit it in a year? What would change if you treated your own attention as a fixed daily budget, as the case does? Agrawal and colleagues argue that cheap prediction raises the value of judgement. Where in your business is judgement the bottleneck? If your business's minimum efficient size has fallen, what activities could one person now run that once needed a team? What should not be run that way? Which accounts, approvals or permissions does your growth depend on, and how long do they take to obtain?
Complete the Scarce Inputs Ledger for your business. Be specific about the weekly budget for each input. Look at the last three features or campaigns you launched. For each, note which scarce inputs it consumed. Was the consumption deliberate? Identify one account or permission your growth will need in six months. Start the application this week. • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. What exactly are we designing when we design a business model, and how do we describe one precisely enough to reason about it? "Business model" is one of the most used and least defined terms in management. Founders use it to mean their pricing, investors to mean their revenue forecast, consultants to mean a canvas on a wall. Before this book can argue that constraints should shape business models, it needs a working definition that is precise enough to use.
Massa, Tucci and Afuah (2017) reviewed the research and found three distinct meanings of the term: an attribute of real firms, meaning the way a company actually operates; a cognitive schema, meaning the picture in managers' heads of how their business works; a formal conceptual representation, such as a diagram or canvas used to describe and design. All three are useful, but confusing them causes trouble. A canvas (the third meaning) can look coherent while the firm (the first meaning) works quite differently. And a manager's mental model (the second meaning) can lag behind both. Teece (2010) offers a definition that bridges the first and third meanings. A business model, he writes, articulates the logic, data and other evidence that support a value proposition for the customer, and a viable structure of revenues and costs for the enterprise delivering that value. Teece is careful to separate the • • •
business model from strategy. Strategy is the more specific analysis needed to protect a business model from imitation. A good business model can be copied; a good strategy makes copying hard.
Zott and Amit (2010) give the most practical definition for design purposes. They describe a business model as a system of interdependent activities that spans the firm and its boundaries, performed by the firm, its partners, its suppliers or its customers. The design of the system has three elements: Content: which activities are performed. Structure: how the activities are linked and sequenced. Governance: who performs each activity. The value of the system, they argue, comes from four design themes, first identified in their study of e-businesses (Amit & Zott, 2001): Novelty: new activities, new links or new ways of governing them. Lock-in: activities that keep customers and partners engaged. Complementarities: activities that are more valuable together than apart. Efficiency: activities that reduce costs for all participants. The activity-system view has an important consequence. A business model is not a list of features or a price list. It is a set of linked activities, and its strength lies in the links. Porter (1996) made a similar argument about strategy: lasting advantage comes from the fit among many activities, which rivals find much harder to copy than any single activity.
Casadesus-Masanell and Ricart (2010) add a dynamic element. They describe a business model as a set of choices, such as policies, assets and governance arrangements, together with their consequences. Some consequences feed back to strengthen the original choices, creating virtuous cycles. For example, low prices produce high volume, high volume produces scale economies, and scale economies allow lower prices. • • • • • • •
They also distinguish three levels: Strategy: the contingent plan for choosing a business model. The business model: the logic that is actually realised. Tactics: the residual choices left once a model is in place. This distinction will matter in Chapter 4. Constraints can remove choices before strategy begins.
The most widely used representation of a business model is the Business Model Canvas (Osterwalder & Pigneur, 2010). It has nine blocks: customer segments, value propositions, channels, customer relationships, revenue streams, key resources, key activities, key partnerships and cost structure. The canvas is valuable because it is shared, simple and complete enough to prompt the right questions. It has two limits for our purposes. First, it records what a business does, not what bounds it: the quotas, terms, rules and limits within which it must operate. Second, it records activities without saying who or what performs them. That matters a great deal when software agents and borrowed platforms perform most of the work. Chapter 25 proposes an extended canvas that addresses both limits.
Mapped as an activity system, TightBucket looks like this. Content. Its activities include: auditing websites and scoring them; publishing private report pages; running ten free tools; collecting public buying signals; preparing outreach; sending email; triaging replies; • • • • • • • • • •
drafting content and answers to community questions; monitoring customers' sites on a schedule; handling payments and memberships; managing team workspaces; delivering done-for-you remediation. Structure. The activities are tightly linked: An audit run for a visitor creates a report page, which can be shared and found by search. An audit run for a prospect becomes the attachment to an outreach message. A free account turns a single audit into a saved history. A monitor re-runs the audit weekly and emails changes, which is the main retention activity. A done-for-you sprint is scoped from the audit's ranked fixes. The audit is the hub of the system. Almost every other activity begins with it or feeds back to it. Governance. This is where the case is unusual. Most activities are performed by the owner's software: auditing, scoring, monitoring, drafting, triage and email. Payments, memberships, tax and payouts are performed by a merchant platform. Social posting is designed to be performed through a scheduling service and platform interfaces. Only a few activities are performed by the owner personally: replying to prospects, sending messages on a professional network that forbids automation, answering community questions, deciding prices and scoping donefor-you work. On the four design themes: Efficiency is the strongest. One audit engine serves four audiences, and free tiers carry the infrastructure. Complementarity is designed in, because each rung of the ladder extends the same proof. Lock-in is modest: report history, monitors and team workspaces. • • • • • • • • • • • • •
Novelty lies less in any single activity than in the governance: who performs what, and the rules that bind them. What the case cannot yet show is whether these links produce virtuous cycles in the market. The cycles are designed, not observed.
Draw your business as an activity system in four steps. List every activity needed to create, deliver and capture value: twelve to twenty is typical. Write each as a verb phrase ("score the site", "collect payment", "answer replies"). Draw the links. Draw an arrow from one activity to another wherever the first feeds the second. Circle the activity with the most arrows: it is your hub. Mark the governance of each activity: O for the owner or staff, S for your own software, P for a partner platform, C for the customer. Score the system on the four themes (novelty, lock-in, complementarities, efficiency) from 1 to 5, and write one sentence of evidence for each score. Then ask three questions. Which links would a competitor find hardest to copy? Which activities marked P could a platform change without your consent? Which activities marked O consume the most of your scarce attention?
Is the activity system the business model, or only its operations? Teece's definition emphasises logic and evidence, Zott and Amit's emphasises activities. Some argue that a list of activities misses the why: the value proposition and the customer's job to be done. Is governance by software really governance? When software performs an activity, the owner is still accountable. Some would say that "governance" should mean only who is responsible, not who or what does the work. Can a three-day-old business have a business model? In CasadesusMasanell and Ricart's terms, a business model is realised. Before launch, • 1. 2. 3. 4. • • •
TightBucket has a designed model, not a realised one. Is a designed model worth studying? Hub risk. A system with one hub is efficient but fragile. If the audit engine fails or is copied, everything fails with it.
Which of the three meanings of "business model" does your team usually mean? Has confusing them ever caused a problem? What is the hub of your activity system? What would happen if it stopped working for a week? Which of your activities are performed by partner platforms? What would you do if one of them changed its terms tomorrow? Porter argues that fit among activities is harder to copy than any single activity. Where does your fit lie? If AI tools can perform most of your activities, what remains distinctively yours?
Draw your Activity System Map following the four steps above. Identify the two links in your map that create the most value. Write down what would strengthen each. Mark every activity performed by a platform you do not control. For the most important one, write a one-paragraph contingency plan. • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. Should the limits on a business be treated as obstacles to overcome, or as the material from which the business is designed? Most business advice treats constraints as problems. Raise money to escape the budget. Hire to escape the capacity limit. Negotiate to escape the platform's terms. This chapter argues for a different stance. When constraints are hard, quantified and known in advance, they should be written down first and treated as the specification of the business. We call this stance constraint-native design.
Research on constraints and creativity offers a more nuanced picture than "constraints are bad". Acar, Tarakci and van Knippenberg (2019) reviewed studies across disciplines. They distinguished three types of constraint: constraints on inputs, such as money, time, materials or people; constraints on processes, such as rules and procedures; constraints on outputs, such as required features or standards. Across these studies, the relationship between constraints and creativity was often an inverted U. Too few constraints and people take the path of least resistance, reusing familiar solutions. Too many and they are stifled. A moderate level of constraint pushes people to search more widely and combine ideas in new ways. The practical implication is that the level of constraint is a design variable. A founder who can raise money at will may build a less creative business than one who must work within limits, though not if the limits are so tight that nothing can be built. • • •
Entrepreneurship research offers three traditions for working under constraint. Bootstrapping. Bhide (1992) observed that most new businesses start without outside capital. He advised founders to get operational quickly, favour projects that generate cash early, and keep growth within their means. Winborg and Landström (2001) catalogued the methods small firms use to reduce their need for capital, from delaying payments to sharing resources with other firms. Bricolage. Baker and Nelson (2005) studied firms in resource-poor environments that "made do" by combining the resources at hand, including resources others considered worthless. By refusing to accept the limits others saw, these firms constructed their own resource environments. Effectuation. Sarasvathy (2001) contrasted causal reasoning, which starts with a goal and selects the means to reach it, with effectual reasoning, which starts with the means at hand (who I am, what I know, whom I know) and asks what can be made from them. Effectual entrepreneurs set an affordable loss rather than an expected return, form partnerships, and treat surprises as opportunities. All three traditions treat constraints as conditions to be worked around with ingenuity. The free-tier economy introduces constraints of a different kind.
The constraints that bound a modern digital business on free infrastructure have three properties together: Generous. A whole working product can run within them. The provider in our case allows 5 million database row reads and 100,000 row writes a day free. Hard. Exceeding them stops the service or triggers a bill. There is no improvising past a quota. Quantified. They are measured in precise units such as rows, requests, minutes or messages, and published in advance. • • •
Constraints like these invite engineering against a budget rather than improvisation. Goldratt's (1984) theory of constraints argued that every system has a bottleneck, and that managing the system means identifying and managing that bottleneck. In a constraint-native business, the bottlenecks are known before the first line of code is written, because the providers publish them. Constraints also come from more than providers. They come from owners (a budget, a time limit, a rule about what will not be automated), from platforms (checkout rules, sending limits, terms of service), from law (consent, unsubscription, data protection) and from the market (no audience, no reputation).
The case's owner stated his constraints before anything was built: zero cash; checkout on a merchant platform; email through a free mailbox; four audiences under one brand; autonomous operation, with a human only for important work; no automation of a professional network; no existing audience; inbound pull; and a rule that the business should use no more than 20% of any free quota or free automation minutes. When the build was later analysed, 24 major design decisions were traced back to these constraints. Twenty-one of them followed from at least one stated constraint or provider rule. For example: No key-value store at all. The provider's free allowance permits only 1,000 key-value writes a day, too few for a busy application. Everything was put in the database instead. Compressed findings. An audit originally cost about 120 database row writes, because each finding was stored as a separate row with two indexes. Compressing the findings onto one row cut this to about 11. • • • • • • • • • • •
A small AI model. Summaries use an optimised model that consumes roughly one-sixth of the inference units of the standard version. A daily email cap of 400. The free mailbox permits about 500 messages a day, so 400 leaves room for safety. Prepared, not automated. Messages on the professional network are drafted for the owner rather than sent automatically, because the network's terms forbid automation. Two features of the case stand out. First, the list of constraints was not complete at the start. Five of the binding rules came from providers or platforms the owner had not mentioned, and were discovered during design. Examples are the key-value write allowance, the second mailbox's limit of 15 messages an hour, and the e-commerce platform's rule that apps in its store must use its own billing. A constraint list is a living document. Second, the most consequential constraint was self-imposed. Nothing forced the owner to stay at 20% of his free quotas; the providers allow 100%. He chose a fifth "so that I never need to worry about quotas". That choice bought protection against provider changes, sudden spikes and measurement errors. It also freed him from watching dashboards. Its cost was unused capacity. Only three of the 24 decisions could not be traced to constraints: a public methodology generated from the scoring code, a partner programme for agencies, and the kill-or-scale gates used instead of revenue forecasts. All three are about trust and learning.
Record every constraint on your business in a ledger with six fields: Field Meaning Example Source Who or what imposes it Cloud provider's free plan Type Hard (breach stops service or costs money), soft (breach degrades results) or self-imposed Self-imposed: 20% of a hard limit Metric The unit in which it is measured Database rows written per day Budget How much the business allows itself 20,000 • • •
Meaning Example Owner The person or mechanism that keeps within it Quota governor; owner checks weekly Review date When to recheck it against the source Monthly, and on any pricing change Then follow three rules: Write the ledger before the value proposition. Let the constraints rule out options early, when ruling them out is cheap. Expect discoveries. Add a row whenever design uncovers a new rule. In the case, five of the binding rules arrived this way. Give self-imposed constraints full standing. A self-imposed limit is a strategic choice. Record why it was chosen and what would justify changing it. A ledger is not a risk register. A risk register lists uncertain events that might happen. A ledger lists certain rules that will apply, and the budgets set against them.
Do constraints become excuses? A team can hide behind a constraint ("we can't, the quota won't allow it") instead of questioning whether it should still apply. The review-date field exists to prevent this, but does it? Is self-imposed scarcity wise? The 20% rule forgoes four-fifths of free capacity. A competitor using 100% might grow faster. When is headroom worth what it costs? Inverted U, but where is the peak? Research suggests that moderate constraint aids creativity. Nobody can say in advance where "moderate" lies for a given team. Bricolage or engineering? Baker and Nelson's entrepreneurs refused to accept limits. Constraint-native design accepts them precisely. Are these opposite philosophies, or the same disposition applied to different kinds of limit? 1. 2. 3. • • • •
List the five most important constraints on your business. Which are hard, which are soft, and which did you impose yourself? Which constraint did you discover only after it hurt you? What would have revealed it earlier? Has a constraint ever made your team more creative? Has one ever stifled it? If you imposed a 20% headroom rule on your most important resource, what would have to change? Sarasvathy's effectuators set an affordable loss. What is the affordable loss of your current venture, in time as well as money?
Build a Constraint Ledger for your business with at least eight rows. Include at least one provider rule, one platform rule, one legal rule and one self-imposed rule. For each hard constraint, record your current use as a percentage of the limit. Flag anything above 50%. Choose one self-imposed constraint you could adopt, and write down what it would protect you from and what it would cost. 1. 2. 3. 4. 5. 1. 2. 3.
PA R T I I
The Tight Bucket
Opening question. How does a business with no reputation, no audience and no references persuade a stranger that it is worth their attention? Every new business faces the same opening problem. It knows its product is good, but the buyer does not, and the buyer has heard the same claim from many others. In a flooded market (Chapter 1), claims cost nothing to make and are therefore worth almost nothing to hear. This chapter argues that the answer is to give proof before making any pitch. It uses the economics of information to explain what makes proof credible.
Akerlof (1970) analysed a market in which sellers know the quality of what they sell but buyers do not. His example was used cars. Because buyers cannot tell good cars from bad ("lemons"), they will pay only an average price. At that price, owners of good cars are unwilling to sell, so the average quality offered falls, so buyers will pay even less. In the extreme the market for good cars disappears. A new digital business sending its first messages faces a version of this problem. The recipient cannot see the quality of the service from an unsolicited email. Most such emails come from low-quality senders, so recipients discount all of them, often to zero. A high-quality newcomer is pooled with the rest.
Spence (1973) showed how the problem can be solved. If high-quality sellers can send a signal that is cheaper for them to send than for low-quality sellers, the signal separates the two. His example was education in the job market. If acquiring a qualification costs able people less effort than it costs others, then holding the qualification signals ability, even if the qualification itself teaches nothing useful.
The key is the cost difference. A signal that anyone can send at the same cost carries no information. "We are the best" costs everyone the same to type. A signal works when it is cheap for the good and expensive for the bad.
A diagnostic that performs real, specific work on the prospect's own situation before any request is made can be a powerful signal. It has three properties: Cheap for a competent provider. If the diagnostic is automated, the marginal cost of producing one more is close to zero. Costly to fake. A diagnostic must be specific to the recipient and correct. An incompetent provider cannot produce one that survives the recipient's own inspection. Verifiable. The recipient can check the findings against reality, often in minutes. Proof also answers Simon's (1971) problem of attention. A message about the recipient carries information the recipient values. A message about the sender carries information the recipient must take on trust. In a crowded inbox, the first kind earns attention and the second kind spends it.
Every route into TightBucket begins with proof. The instant audit. A visitor types a website address and receives, in seconds, a score out of 100 and a ranked list of fixes for that site. No sign-up is needed. Anonymous visitors may run five audits a day. Free tools. Each of the ten free tools produces an answer on the page: a speed result, a pricing-page grade, a churn-risk score, a check of the domain's email authentication. Outreach with an attachment. When the business contacts a prospect, the message carries an audit of the prospect's own website rather than a description of the service. This applies both to email and to messages prepared for the owner to send. • • •
Verifiable method. The public methodology page, which explains how each score is calculated, is generated from the same code that scores sites. The deployment pipeline refuses to release a version in which the published methodology differs from the scoring code. A recipient who doubts a score can read exactly how it was computed. Honest limits. The audit uses only public information. Any site owner can opt their domain out, which blocks audits and cancels any outreach queued for it. At the end of the period studied, the business held 19 audits and 9 outreach messages prepared for the owner, each built around a prospect-specific audit. No message had yet been sent, so the case cannot tell us whether recipients found the proof persuasive. It shows how the signal was engineered, not how the market received it.
Proof can fail in ways a pitch cannot. A wrong finding is an anti-signal. If the audit tells a merchant that their checkout is broken when it is not, the recipient learns that the sender is careless. The specificity that makes proof powerful also makes errors visible. This is why the case's review of its own code mattered so much (Chapter 18). Proof can feel intrusive. An unsolicited analysis of someone's business can read as presumptuous. Using only public information, keeping the tone factual and making opting out easy all reduce this risk. Proof can be too generous. If the free diagnostic solves the whole problem, there may be nothing left to sell. The ladder in Chapter 6 addresses this by making paid rungs extend the proof rather than complete it. Proof can be copied. If a diagnostic is easy to build, competitors will build one too, and it stops separating. The defence is continued depth, and a verifiable method that a quick copy cannot match.
Before relying on a piece of proof to open conversations, test it against six criteria. Score each from 0 to 2: • • • •
Question Specific Is it about this recipient's own asset, data or situation? Correct Would it survive the recipient's own inspection? How do we know? Verifiable Can the recipient check it themselves, quickly? Cheap for us Can we produce one more at near-zero marginal cost? Costly to fake Would a weak competitor struggle to produce one as good? Valuable alone Would the recipient benefit even if they never buy? A score of 10 or more suggests a strong signal. A low score on criterion 2 is disqualifying whatever the total: proof that is often wrong does more harm than no proof. Then apply the proof-before-pitch sequence to every route into your business: Give. Deliver the proof with no request attached. Explain. Show how it was produced, and what it does not cover. Offer. Only then, describe what more you could do, and what it costs.
Signal or gift? One reading of the free audit is that it works as a costly signal. Another is that it triggers reciprocity: people feel obliged to respond to a gift. If the second is what drives replies, is the practice manipulative? Is unsolicited proof acceptable? Some recipients welcome an audit of their site; others resent it. Where is the line between helpful and intrusive, and who should draw it? Does automation weaken the signal? If recipients learn that audits are automated, they may value them less. Or they may value them more, as evidence of a consistent method. Who bears the cost of errors? When a proof is wrong, the recipient wastes time investigating. Should a business that sends unsolicited proof accept a higher standard of accuracy than one that waits to be asked? 1. 2. 3. • • • •
What is the equivalent of the "lemons" problem in your market? How do buyers currently discount newcomers? What proof could your business deliver about a prospect's own situation before asking for anything? How would you know if your proof was wrong? How often would you need to be right for the proof to help rather than harm? Spence's signals work because they cost the good less than the bad. What signal in your market has that property? Have you received unsolicited proof from a seller? Did it make you more or less likely to engage?
Design one piece of proof for your business and score it on the Proof Signal Test. Rewrite your first outreach message or landing page so that it follows the give– explain–offer sequence. Define an accuracy check for your proof: a way to sample it regularly and confirm it is correct. 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. How much should a business give away, to whom, and how should the free offer lead to a paid one? Free is the default opening move for digital businesses. But "free" covers very different things: a free trial, a free tier, a free tool, a free report. Each does a different job. This chapter draws on research into the zero price and freemium to show that the free offer is a design decision with measurable consequences, not a marketing gesture.
Shampanier, Mazar and Ariely (2007) ran a series of experiments in which people chose between a cheap item and a better, more expensive one. When the price of both was reduced by the same small amount, so that the cheap item became free, demand for it jumped far beyond what a simple cost–benefit calculation would predict. People treated free products as more valuable than the price change alone justified. The researchers called this the zero-price effect. The effect is powerful but double-edged. It can draw large numbers of people to a free offer. It can also draw people who value the offer because it is free and will never pay for anything.
Information goods have near-zero marginal cost, which makes giving them away tempting and versioning natural (Shapiro & Varian, 1999). A business can offer a basic version free and better versions for a price. The research on how to manage this transition is instructive.
Pauwels and Weiss (2008) studied an online content provider that moved from free to fee. They found that the move could succeed, but required marketing actions aimed differently at free users and at paying subscribers. What attracted one group could drive away the other. Lambrecht and Misra (2017) studied how much content a provider should give away, and found that the right amount is not fixed. It depends on how demand varies over time and on differences between users. The free share is a strategic variable to be managed, not a one-time setting. Gu, Kannan and Ma (2018) studied freemium software directly. They found that the design of the free version's limits, in particular its capacity, shapes whether and when users upgrade. A free tier that is too generous leaves no reason to pay. One that is too stingy never gives users enough experience to see the value. Kumar (2014), writing for practitioners, made a similar point. Freemium works when the free version is good enough to attract users but limited in ways that the most engaged users will want to escape.
These findings suggest a simple discipline. Before deciding what to give away, decide what job the free offer must do. There are three common jobs: Signal. Prove the product works (Chapter 5). Qualify. Separate people who have the problem from people who are merely curious. Permission. Earn the right to follow up, typically through an account or an email address. Each job implies a different design. A signal should be instant and need no sign-up. A qualifier should require a small effort that only interested people will make. A permission device should exchange something of clear value for contact details.
TightBucket's free offer has three layers, each with a different job. • • •
Anonymous use (signal). Anyone can run up to five instant audits a day and use every browser tool, with no sign-up. The tools that handle sensitive data run entirely in the visitor's browser. The churn-risk scorer, for example, analyses an uploaded customer list without sending it anywhere. That protects privacy and costs the business nothing in server resources. The free account (permission). A free membership, at $0 on the merchant platform, gives three saved audits a month, one monthly monitor and a history of reports. In exchange, the business gains an identity and permission to follow up. The capacity limit (upgrade trigger). The paid Pro plan, at $39 a month, offers 500 audits a month and five weekly monitors. The free tier's limits are exactly the limits an engaged user will hit first. Someone who wants to watch more than one site, or watch it more often than monthly, has a reason to pay. This follows the logic of Gu and colleagues: the capacity limit is the upgrade trigger. The free tier is also sized against the business's own constraints. Every anonymous audit costs about 11 database row writes. The quota governor (Chapter 16) limits background work so that free use can never push the business past a fifth of its free quotas. When the budget for the day is reached, anonymous visitors are offered a recent cached report for the same site or asked to return after midnight UTC. Paying members are never refused. This is a deliberate asymmetry. The free tier is generous in the experience it gives, and strict in the resources it may consume. Because the business had made no sales by the end of the period studied, the case cannot tell us whether this design converts. It shows how the free tier was sized to its job and to its resource budget.
For each free offer, complete five lines: Line Question TightBucket example (anonymous audit) 1. Job Signal, qualify or permission? Signal 2. Cost per use What does one use cost, in the provider's units? ≈11 row writes, ≈10 row reads
Line Question TightBucket example (anonymous audit) 3. Ceiling What limits total free use, and what happens at the limit? 5 per visitor per day; daily budget; cached report or "come back later" 4. Upgrade trigger Which limit will an engaged user hit first? Wanting to save, monitor or run many audits 5. Paid extension What does the paid version add to the same value? Saved, recurring and team-wide audits Then check three warning signs: No trigger. If no engaged user will ever hit a limit, the free tier is too generous. No experience. If users hit a limit before they experience the value, it is too stingy. No ceiling. If free use has no resource ceiling, a surge of free users can harm paying ones.
Does free devalue the product? Some argue that giving the core product away teaches buyers that it is worth nothing. Others argue that a free signal is the only way for a newcomer to be noticed at all. Who should the free tier serve? A generous free tier may attract people who will never pay, inflating usage numbers. Is that harmful, or do free users bring value by sharing reports and recommending the product? Is free use ever truly free? Even in a zero-cash business, free users consume quota, support time and reputation. Should free users be "priced" internally in those units? Can a capacity limit feel punitive? Users who hit a limit sometimes feel trapped rather than invited. How can a limit be designed to feel like an invitation?
What job does your free offer do? Does everyone in your team agree? • • • • • • • 1.
Which limit in your free tier do engaged users hit first? Is that the limit you intended to be the trigger? What does one free user cost you, in whatever units your providers bill? Have you seen the zero-price effect attract the wrong customers? How did you notice? Lambrecht and Misra suggest the free share should vary over time. When might you give away more, or less?
Complete a Free Tier Design Sheet for each free offer you make. Check each against the three warning signs. Change one limit to fix the worst problem. Write the message an engaged user sees when they hit your upgrade trigger. Make sure it explains what they gain, not just what they have run out of. 2. 3. 4. 5. 1. 2. 3.
Opening question. When building is cheap enough to serve several markets at once, should you, and if so, how do you avoid becoming a business that is nothing in particular to anyone? Classic start-up advice says to focus: pick one customer, one problem, one channel, and win there before expanding. That advice was partly a response to the cost of building. Each new segment needed its own product, and engineering time was the scarcest input. When building costs fall, the case for focus has to rest on other grounds. This chapter examines when serving several audiences with one engine makes sense, and what it demands.
Shapiro and Varian (1999) showed that information goods are naturally versioned. A single underlying product is packaged differently for different customers, who value it differently. Versioning lets a business serve several segments without building several products. Business model research adds a caution. Tidhar and Eisenhardt (2020) studied how firms choose revenue models, combining machine learning analysis of app markets with case studies. They found that the effectiveness of a revenue model depends on its fit with the product and its users, and that successful firms often use more than one revenue model. An engine that serves several audiences may need several ways of earning money, each fitted to its audience. McDonald and Eisenhardt (2020) studied ventures in a new market and found that the more effective ones engaged in what they called "parallel play". They learned from peers without treating them as rivals, tested their key assumptions, and postponed committing to a single business model until they had learned enough. Serving several audiences in parallel at the start can be read as a version of this: a way of learning which audience responds before committing.
The activity-system view (Chapter 3) explains where the value of multiple audiences can come from. If the audiences share a hub activity, every improvement to the hub benefits all of them. That is a complementarity in Zott and Amit's (2010) sense. If they share nothing, the business is really several small businesses competing for the same owner's attention.
A useful distinction is between the engine, the shared capability that does the core work, and the wrapper, the audience-specific layer that adapts the engine to each audience. A wrapper has four parts: Language: the words the audience uses for its problem. Proof: the specific diagnostic that matters to this audience. Channel: where the audience can be found. Price and packaging: how the audience prefers to buy. When the engine is genuinely shared and the wrappers are thin, multiple audiences are cheap to serve. When each audience needs a different engine, they are not.
The owner specified four audiences under one roof (e-commerce merchants, SaaS founders, sales directors and agencies), each with its own product and free tools. Engineering for all four was explicitly not a concern; the owner said he could "build everything in a couple of days". One engine. The core is a single audit engine. It fetches a public web page safely, extracts its structure and runs weighted checks in four modules: speed, pricing and offer clarity, forms and conversion paths, and trust and email authentication. It scores the site out of 100 and ranks the fixes. All four audiences use this engine. Four wrappers. Each audience has its own audit page, with its own emphasis and language. E-commerce focuses on mobile speed, product-page trust, shipping and returns clarity, and structured data. • • • • •
SaaS focuses on signup friction, whether a card is required for a trial, and pricing clarity. Sales teams focus on speed-to-lead, the demo path and email authentication. Agencies use an acquisition audit and can run the other audits on their prospects. Reports are watermarked on the free plan and white-labelled on the paid plan. Each audience also has free tools suited to it (Chapter 6), ten in total, from a cartabandonment calculator to a cold-email grader. Several revenue models. Following the logic of revenue-model fit: most audiences buy subscriptions on the merchant platform; agencies are offered a 30% recurring partner programme; e-commerce merchants can buy a $19-a-month plan inside their store platform's app store, through that platform's billing; anyone can buy done-for-you remediation. A shared hub. Every improvement to the audit engine, such as a new check, a faster fetch or a better ranking of fixes, benefits all four audiences at once. The methodology page, the report pages and the monitors are also shared. The case shows the cost side of multiple audiences clearly. The engineering was cheap. The costs that remained were content (each audience needs its own pages, examples and posts), channels (each audience gathers in different places) and owner attention (replies from four kinds of buyer, each with different concerns). These are exactly the scarce inputs of Chapter 2. The case cannot yet show which audience, if any, responds best. The plan's answer is to let gates decide (Chapter 21).
Draw a matrix with your audiences as columns and five rows: Audience A Audience B Audience C Audience D Engine use (% of the core shared) • • • • • • •
A Audience B Audience C Audience D Language (their words for the problem) Proof (the diagnostic they value) Channel (where they gather) Revenue model (how they prefer to buy) Then answer three questions. Is the engine really shared? If any audience uses less than about 70% of the core, it is probably a separate product. Treat it as a separate decision. What does each wrapper cost in scarce inputs? Estimate the weekly content, channel and attention cost of each audience. Add them up and compare the total with your Scarce Inputs Ledger (Chapter 2). What will decide which audience to keep? Define in advance the evidence that would lead you to drop an audience, for example fewer than a set number of members after a set number of visits.
Focus versus parallel play. The conventional view is that a new business should focus on one audience. The parallel-play view suggests that learning across several audiences can be more effective, if commitment is postponed. Which applies depends on how cheap it is to serve each additional audience, and that now depends on content and attention more than on code. Brand coherence. A brand that speaks to merchants, founders, sales directors and agencies may be clear to none of them. Is a single brand an asset or a liability across audiences? Hub risk revisited. If the engine is mediocre, all four audiences suffer. Shared engines concentrate risk as well as value. Is "we can build everything" a trap? When building is cheap, the temptation is to build for every audience. The binding cost then moves to the owner's attention, which is harder to see and easier to overspend. 1. 2. 3. • • • •
Does your business have one engine or several? How would you tell? For each audience you serve, what is their word for the problem? Do your pages use it? Which of your audiences costs the most in content, channels and attention? Which earns the most? Tidhar and Eisenhardt found that successful firms often combine revenue models. Which revenue model fits each of your audiences? What evidence would make you drop an audience? Have you written it down?
Complete the Engine–Audience Matrix for your business. Estimate the weekly scarce-input cost of each audience and compare it with your attention budget. Write a one-line kill criterion for each audience, with a number and a date. 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. How should a set of prices be arranged so that each step up is an easy decision for the right customer, without leaving money on the table or confusing everyone else? Most pricing advice concerns the level of a price: should it be $29 or $49? This chapter concerns the architecture: how many rungs, what each rung contains, how rungs relate to each other, and what each one costs the business to sell. For a constraint-native business, the architecture matters more than the level, because the architecture determines what customers are asked to decide and what the business must deliver.
Buyers rarely judge a price in isolation; they judge it against the alternatives in front of them. Huber, Payne and Puto (1982) showed this with what became known as the decoy or asymmetric dominance effect. Adding a third option that is clearly worse than one existing option, but not clearly worse than the other, increases the share choosing the option it is worse than. The decoy is rarely chosen. Its job is to make another option look obviously better. The broader lesson is that the arrangement of options is itself a message. A ladder of prices tells the buyer which option the seller thinks is normal, which is for serious users and which is for those who want everything done for them.
Tidhar and Eisenhardt (2020) found that the revenue model, meaning how a business charges (subscription, one-time fee, advertising and so on), is consequential and must fit the product and its users. A product used continuously suits a subscription. A product that solves a one-off problem suits a one-time fee. A business that serves several audiences may need several revenue models (Chapter 7).
Information goods also invite versioning (Shapiro & Varian, 1999): offering the same core at several levels of quality, speed or capacity, so that buyers who value it more pay more.
Pricing architecture also has to account for what it costs to collect each payment. Platform fees with a fixed component weigh more heavily on low prices than on high ones. In a business with no other variable costs, the fee schedule is effectively the cost structure.
TightBucket's ladder has six rungs, each extending the same audit (Chapter 6): Rung Price What it adds Anonymous use Free Five instant audits a day; all browser tools Free membership $0 Three saved audits a month; one monthly monitor; report history Pro $39/month 500 audits a month; five weekly monitors; export; an API key for the browser extension and site plugin Agency $149/month 25 monitors; white-label reports; partner terms Fix Sprint From $300, scoped first Done-for-you remediation of the top leaks Store plan $19/month A version sold inside an e-commerce platform's app store, through its billing Referrals earn one extra monitor for each activated referral, up to ten. Several features of this architecture are worth noting. The plan narrowed. The build plan proposed Pro at "$39–49" and Fix Sprint at "$300–1,500". The built product launched at $39 and "from $300, scoped first". Ranges became single entry points, with the higher figures left for testing. The plan also sets a pricing gate: after 20 paying customers, test a price 30% higher on new sign-ups (Chapter 21).
No explicit decoy. The case did not design a decoy in Huber and colleagues' sense. Its rungs differ in kind (saved, recurring, delegated, done-for-you) rather than being arranged so that one dominates another. Whether a decoy would help is an open question the business could test. Fees fall as price rises. All rungs except the store plan are sold on a merchant platform that charges 2.7% plus $0.30 per successful domestic card transaction, with 1.5% added for international cards and 1% for currency conversion. The effective fee rate therefore falls as price rises: Price Domestic card International card International card with conversion $39 3.47% 4.97% 5.97% $149 2.90% 4.40% 5.40% $300 2.80% 4.30% 5.30% These fees are the business's only variable cost, and they arise only when a customer pays. With no fixed costs, the business breaks even on its first sale (Chapter 9). Several revenue models. Subscriptions suit monitoring, which is continuous. A one-time, scoped fee suits remediation, which is a project. The marketplace plan follows its marketplace's rules. A 30% recurring partner commission suits agencies, who bring their own clients.
Arrange your offer so that each rung extends the same proof, rather than adding unrelated features: Rung Proof Economic role 1. Instant proof One diagnostic of the buyer's own situation, no sign-up Signal and qualification 2. Saved proof A history of diagnostics in a free account Identity; permission to follow up 3. Recurring proof The diagnostic repeated on a schedule, with alerts on change Retention
Proof Economic role 4. Delegated proof Team access; proof shown to one's own clients Expansion; customers resell the proof 5. Done-foryou The provider fixes what the proof found High-value service, scoped by the proof Test your ladder with four questions: Extension test. Does each rung extend the same proof in frequency, audience or consequence? A feature that does not belongs elsewhere or nowhere. Step test. Is each step up an easy decision for someone who has used the rung below? What would they say to justify it to a colleague? Fee test. What is the effective payment fee at each price, for domestic and international buyers? Are any rungs priced so low that fees consume a disproportionate share? Model test. Does each rung's revenue model (subscription, one-time, commission) fit how that value is consumed?
Single price or range? The case moved from ranges to single entry points. Some argue that a range signals flexibility and invites larger deals. Others argue that a single clear price reduces friction for self-serve buyers. Should decoys be used? A decoy can raise revenue. Some regard it as manipulative, because it exploits a bias rather than informing a choice. Is a decoy acceptable if every option is genuinely useful? Low-price rungs and fees. A $19 or $39 plan bears a higher effective fee rate than a $149 plan. Should a small business set a minimum price to keep fees proportionate, or accept higher fees to lower the barrier? Referral rewards in kind. The case rewards referrals with product capacity (extra monitors) rather than cash. This costs little in a zero-cash business. Does it motivate referrers as well as cash would?
Draw your current price ladder. Which rung does it suggest is "normal"? 1. 2. 3. 4. • • • • 1.
Does each of your paid features extend your core proof, or add something unrelated? What is your effective payment fee at each price point, including international buyers? Which of your offers would suit a one-time fee better than a subscription, or the reverse? Would you use a decoy? Where would you draw the line between arranging choices and manipulating them?
Rewrite your offer as a Proof-First Value Ladder. Remove or relocate any feature that fails the extension test. Calculate the effective fee rate at every price for domestic, international and currency-converted payments. Define one pricing gate: the evidence (customers, conversion rate or churn) that would trigger a test of a higher price. 2. 3. 4. 5. 1. 2. 3.
Opening question. Should a small digital business run its own checkout, billing and payouts, or hand them to a platform, and what does it give up if it hands them over? Collecting money is harder than it looks. A business that sells online must take card payments securely, handle failed payments and refunds, calculate and remit sales taxes in many jurisdictions, manage subscriptions, prevent fraud and pay itself out. Merchant platforms now offer all of this for a percentage of each sale. This chapter examines the decision to borrow commerce in this way, using platform economics to explain both its appeal and its costs.
Platform economics describes businesses that bring together two or more groups of users. Rochet and Tirole (2003) showed that such platforms choose not only an overall price level but a price structure: how much each side pays. A platform often subsidises one side to attract the other. Parker and Van Alstyne (2005) showed how a business can rationally give away a product to one group of users when that group's participation makes the platform more valuable to another group that pays. Hagiu and Wright (2015) define multi-sided platforms as organisations that enable direct interactions between two or more distinct sides, each of which is affiliated with the platform. A merchant platform fits the definition. Sellers and buyers transact directly, and both have accounts with the platform.
A business that sells through a platform is a complementor: it adds value to the platform's ecosystem and depends on it. Research shows that this position carries real risks. Cennamo and Santaló (2013) show that platform markets involve strategic trade-offs rather than simple winner-takes-all dynamics. Zhu and Liu (2018) studied Amazon's entry into product categories previously served by third-
party sellers. They found that the platform was more likely to enter successful categories, a direct threat to the complementors who had proved those categories' value. For a small business, platform dependence has at least three dimensions: Terms risk: the platform can change its fees, rules or policies. Interpretation risk: the business must correctly interpret the platform's events (payments, cancellations, refunds) in its own systems. Relationship risk: the platform, not the business, may hold the primary relationship with the customer.
In a zero-cash business, borrowing commerce is attractive for a simple reason. It converts fixed obligations into variable ones that arise only on success. There is no payment-processing contract, no tax filing system, no payout infrastructure and no monthly fee. The cost is a percentage of each sale and a degree of dependence. We call this commerce offloading: the deliberate transfer of checkout, billing, tax and payouts to a merchant platform, in exchange for margin and some control.
The owner required that checkout be handled "entirely on Whop", a merchant platform for digital products and memberships. All paid rungs except the store plan are sold there. The business receives webhooks, automated notifications signed by the platform, when a customer joins, pays, cancels or fails to pay. It also lets customers sign in with their platform identity. It holds no card data, files no sales tax returns and runs no payout system. The cost is the platform's fee: 2.7% plus $0.30 per successful domestic card transaction, with surcharges for international cards and currency conversion, and no monthly fee (Chapter 8). The store plan follows a different rule. Apps sold in the e-commerce platform's app store must be billed through that platform's own billing system. This was one of the external rules discovered during design (Chapter 4). The case reveals two hidden costs of offloading. • • •
Interpretation is real work, and its errors are silent. Three of the 43 defects found in the business's code reviews were in the logic that interprets the platform's events: A cancellation or expiry event could downgrade an account the owner had granted for free, once that account was linked to a platform identity. The fix made a complimentary plan a floor that platform events cannot push below. A payment of $0, for the free plan, could trigger a referral reward meant only for real payments. Payment records without an identifier could be stored more than once. None of these would have produced an error message. Each would have silently given or taken away something of value. The relationship pulls back. The owner's original instruction kept every customer interaction on the platform. Later he reversed it, asking for a separate interface for paying customers. The business now runs its own customer portal, sign-in, team workspaces with seats and roles, and email invitations, alongside the platform's membership system (Chapter 19). Offloading checkout did not mean offloading the relationship, and the owner chose not to.
Before borrowing commerce, complete five boxes. Box Question TightBucket Offloaded Which functions does the platform perform? Checkout, subscriptions, tax, payouts, affiliate tracking Retained Which functions do you keep, and why? Product access, team workspaces, customer portal, support Events to interpret Which platform events change what a customer may do? Who checks the interpretation? Join, payment succeeded or failed, cancelled, expired; checked by review and tests Cost What is the effective fee at each price and card type? 2.8%–6.0% depending on price and card • • •
Question TightBucket Exit plan If the platform changed its terms tomorrow, how would you move customers? What data would you need? Members' identities and plans are mirrored in the business's own database The exit plan is the box most often left blank. It is also the one that turns dependence from a hidden risk into a managed one.
Margin versus control. Running your own checkout through a payment processor typically costs less per sale than a full merchant platform, but adds tax, compliance and integration work. For a solo operator, is the saving worth the work? Who owns the customer? If the platform holds the customer's payment relationship, does the business really own its customers? The case's reversal suggests the owner thought not. Discovery or dependence? Platforms often offer marketplace visibility to their sellers. That can be valuable for a business with no audience, but it deepens dependence on the platform's ranking rules. Can interpretation risk be eliminated? The case's defects were found by reading code. Would a platform's own testing tools have found them? Should platforms bear some responsibility for making their events hard to misinterpret?
Which commercial functions does your business perform itself? Which could a platform perform? What would your effective payment cost be on a merchant platform, compared with your current arrangement? List the platform events that change what your customers can do. When did you last check that your systems interpret each one correctly? If your main sales platform doubled its fee next month, what would you do? • • • • 1. 2. 3. 4.
Do you own your customer relationships? What evidence supports your answer?
Complete the Commerce Offloading Canvas for your business, even if you currently run your own checkout. Write test cases for three platform events, including at least one unusual case (a $0 payment, a cancellation of a complimentary account, a duplicate notification). Draft a one-page exit plan: what data you hold, what you would need to export, and how you would tell customers. 5. 1. 2. 3.
PA R T I I I
The Tight Bucket
Opening question. How can a business with no audience become something customers seek out, rather than something that must always chase them? The owner of the case business put it in a phrase: he wanted customers to come "like bees to the flower". Outreach would play a part, but the aim was a business that pulls rather than pushes. This chapter turns that metaphor into a design framework, and examines what inbound pull requires when a business starts with no audience at all.
Simon's (1971) observation that information consumes attention has a corollary. People who are already looking for a solution give their attention willingly. Someone who searches for "why is my store slow on mobile" or "check my email authentication" is in pain and searching. They do not need to be persuaded that they have a problem. They need to find a useful answer. This is the economic case for inbound pull. Attention spent by a searcher is attention they chose to spend. Attention demanded by an unsolicited message is attention taken. The first builds goodwill; the second spends it.
Platform economics explains why giving value away can be rational. Parker and Van Alstyne (2005) show that a business can give a product away to one group when that group's participation creates value that another group pays for. A free tool used by many people creates traffic, links, shared reports and a pool of qualified prospects. Some of those prospects pay. Information goods make this cheap, because the marginal cost of one more use is close to zero (Shapiro & Varian, 1999).
Signals of quality (Chapter 5) can also spread. When a business produces something its users want to show others, such as a good score, a badge or an original statistic, every display becomes a signal seen by new people. The quality signal and the distribution channel become the same object.
The case's build plan organised inbound pull around five parts of a flower: Part Meaning What it requires Nectar Instant, real value with no login Tools and diagnostics that work immediately Scent Being findable where people already search Search pages, marketplaces, communities, AI answer engines Colour Things people want to show others Score cards, badges, original data, leaderboards Pollination Every visitor brings new visitors Comparisons, watermarks, forwarded alerts, referrals, partners Gardener The owner, tending only what needs a person A fixed, small daily time budget The model's strength is that it separates jobs which are often confused. A business can have excellent nectar (a great free tool) and no scent (nobody can find it). It can have scent and no colour (people find it, use it and leave without telling anyone). Each part needs its own design.
Nectar. The four audit pages and ten free tools need no login (Chapter 6). Scent. The plan names sixteen distribution channels in four groups plus direct outreach: Search: tool pages, calculators, benchmark pages and AI answer engines. Marketplaces: the merchant platform's discovery pages, launch sites, an ecommerce app store, a website-plugin directory and a browser-extension store. • •
Loops: share cards, comparisons, badges, watermarks and a monthly data report. Borrowed audiences: agency partners, affiliates, newsletters and an open check library. The built product includes a browser extension, a site plugin and an e-commerce app, each a way of being found where buyers already browse. Benchmark pages are generated from monthly aggregate statistics. Colour. The code includes: a share card showing a site's score; an embeddable badge for sites that score well; a monthly "State of…" data report built from aggregate, anonymised audit statistics. The plan restricts leaderboards to positive rankings only and keeps reports about individual domains out of search engines unless the owner claims them. Those rules limit the harm of publishing information about named businesses. Pollination. The code includes: a competitor comparison, in which each user brings up to three new sites into the audit pool, and the plan forbids telling the competitor who asked; watermarked agency reports, which advertise the service to every agency client who sees one; forwardable alerts; referral rewards; a 30% recurring partner programme for agencies. Gardener. The plan allocates about 25 minutes a day and 45 minutes a week of owner time, roughly three and a half to four hours a week. It is a design target, not a measurement. Most of it goes to posting community answers by hand, sending prepared messages, and deciding at the monthly gates. • • • • • • • • • •
The plan is candid about timing. It expects outreach and communities to bring in most early customers in the first eight weeks, because search and marketplaces "usually take months to compound". Inbound pull is slow to start. The fast channels, it says, pay for the slow ones. At the end of the period studied, none of this had been tested in the market. The nectar existed. The scent, colour and pollination mechanisms were built but had produced no measurable traffic, because the business had not launched.
Score your business on each part from 0 to 3, and record one piece of evidence for each score: Part Your score Evidence Nectar Nothing useful without sign-up Real value in under a minute, no login Scent Findable only by people who know your name Found in search, marketplaces and communities for the problem Colour Nothing worth showing others Users regularly share outputs Pollination Each user arrives alone Each user brings measurable new users Gardener The owner is overwhelmed or absent A fixed, protected time budget focused on what needs a person The weakest part is your constraint. A business with excellent nectar and no scent should not build more tools; it should become findable. A business with traffic but no colour should design something worth sharing.
Is inbound realistic for a newcomer? Search takes months to produce traffic, and marketplaces reward history. Some argue that a business with no audience must rely on outbound until it has earned inbound, and that "be the flower" is advice for the already established. •
Do loops spread or annoy? Watermarks and badges can feel like advertising imposed on users. When does pollination become pollution? Publishing data about others. Benchmark reports and leaderboards use information about real businesses. Positive-only rankings and aggregation reduce harm. Are they enough? Is the gardener's time budget honest? A design target of 25 minutes a day assumes that automation works as planned. Real operations often take longer. How should a founder plan for the gap?
Which part of the flower is weakest in your business? What evidence do you have? What do people search for when they have the problem you solve? Do you appear in those searches? What do your users produce that they might want to show others? How does each of your users bring new users today? How could they? How much of your own time goes to inbound activities, and how much to outbound? Is that the right split?
Complete the Flower Audit for your business. For your weakest part, list three changes, and choose the one that costs least in scarce inputs. Write down the searches, communities and marketplaces where your buyers look for help. Check whether you appear in each. • • • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. If email is free to send, what actually limits how much a business can send, and what happens when it ignores those limits? Email looks like the one channel with no constraints. Sending costs nothing, there is no algorithm to please, and the recipient's address is the whole of the targeting. In practice email is governed by something like physics. There are capacities, flows and reserves, and there is a reputation that behaves like a stock: built up slowly and drained quickly. This chapter sets out those laws and shows how the case designed around them.
Three sets of rules govern business email. Provider limits. Free mailbox providers cap how many messages an account may send. The free personal mailbox used in the case allows about 500 messages a day before sending is restricted. The second, smaller provider used in the case allows 15 an hour. Sender guidelines. Major inbox providers publish requirements for bulk senders. Google's current guidelines require senders to: authenticate their mail; keep the spam-complaint rate reported in its tools below 0.1%, and never let it reach 0.3%; for bulk marketing mail, offer one-click unsubscription. The one-click mechanism is defined in an internet standard (RFC 8058): a header lets the recipient's mail program unsubscribe them without visiting a website. Law. In the United States, the CAN-SPAM Act requires commercial email to: carry accurate header information and honest subject lines; • • • •
identify itself as an advertisement where applicable; include a valid physical postal address; offer a clear way to opt out, and honour opt-outs within ten business days. In the European Union, the General Data Protection Regulation's Recital 47 recognises that processing personal data for direct marketing may be regarded as a legitimate interest. That depends on a balancing test and the reasonable expectations of the person concerned, and other rules on electronic marketing also apply. A business that emails strangers must know which regime applies to each recipient.
These rules imply a model. Think of a business's sending capacity as a stock with a daily refill: the provider's limit. Each message drains the stock by one. But there is a second, more important stock: reputation. Wanted messages maintain it. Unwanted messages, bounces to bad addresses and complaints drain it. Unlike the daily allowance, reputation does not refill at midnight. When it is gone, messages go to spam folders or are refused, and recovery takes weeks. Akerlof's (1970) analysis applies here too. Inbox providers face a lemons problem: they cannot read every sender's intentions, so they judge by behaviour. A sender whose behaviour resembles a spammer's is treated as one. Three principles follow: Capacity is not the binding constraint; reputation is. Sending the full daily allowance is easy. Keeping reputation intact while doing so is hard. Order matters. When capacity is limited, the messages that matter most (receipts, password links, replies to people who wrote to you) must go first. Measurement matters most. A business that cannot see its bounces and complaints accurately will spend its reputation without knowing it. • • • • • •
Caps below limits. The business caps itself at 400 messages a day, below the free mailbox's limit of about 500. The plan allocates 40 to cold first touches, 300 to transactional and nurture messages, and 60 to a reserve. Priority classes. Messages leave in a fixed order: transactional first, then replies, then nurture, then cold. A surge of cold email can never delay a customer's receipt. Two lanes, two reputations. The free mailbox's interface carries most traffic, including a share of cold first touches. A second free webmail provider adds a separate lane for cold first touches, under its own limit of 15 an hour. Because the cloud platform blocks the standard server-to-server mail port, this lane connects through an authenticated submission port, as a mail program would. Each lane has its own reputation, so a problem on one does not drain the other. Law as a gate in the code. Every marketing message carries an unsubscribe link, a delete-my-data link and the one-click unsubscribe header. Marketing email is held in the queue until the owner has entered a postal address in the console, because the law requires one. Unsubscribed addresses are suppressed permanently, and the suppression survives deletion of the person's data by being stored as a one-way hash. Cold email goes only to business addresses published on websites. Circuit breakers. Two kill switches stop all email or only cold email. A gate pauses a lane automatically on signs of trouble: rising bounces, opt-outs, spamfolder placement detected by test messages, or a provider locking the account. Measurement defects. The business's code reviews found five defects in the accounting of reputation rather than in sending itself. Two examples: When a recipient's mail server rejected a message outright, the rejection was not counted in the lane's bounce rate, so the automatic gate could not see it. When a connection failed while being reset after a rejection, the error replaced the true reason. A permanent "no such recipient" error was retried as a temporary connection failure instead of being suppressed. None of these defects would have stopped email from being sent. Each would have blinded the mechanism that protects reputation, exactly the kind of failure the physics predicts. • •
At the end of the period studied the business had sent no outreach, so the case says nothing about deliverability in practice. It shows the design and the defects.
For each sending lane, record: Item Question Example Refill What is the provider's limit per day or hour? ≈500/day; 15/hour Cap What limit do you set yourself, and why? 400/day (20% margin) Allocation How is the cap split across message classes? 40 cold / 300 transactional and nurture / 60 reserve Priority In what order do classes leave when capacity is short? Transactional > replies > nurture > cold Reputation signals Which signals do you measure, and how do you know they are accurate? Bounces, complaints, opt-outs, spam placement, provider locks Breakers What pauses the lane automatically? What stops everything manually? Bounce gate; kill switches Legal Which rules apply, and where are they enforced in the system? Unsubscribe, postal address, honest headers Then run one test: deliberately send a message to an address you know will bounce, and check that your accounting records it correctly. In the case, two of the five reputation defects would have been caught this way.
Is cold email ethical? Some regard any unsolicited commercial email as an intrusion. Others argue that a short, relevant, proof-first message with an easy opt-out is a legitimate way for a newcomer to be noticed. Where do you stand, and does the answer depend on the content? Two lanes or one? Spreading sending across lanes protects reputation, but can also be seen as evading a provider's limits. When is a second lane prudent, and when is it gaming the system? • •
Free mailboxes for business. The case uses free personal and webmail accounts because of its zero-budget constraint. Providers' terms and recipients' perceptions may favour paid business email on one's own domain. When should a business upgrade? Plain text or rich messages? Plain-text cold email without links may reach inboxes more reliably, but makes unsubscribing and verifying harder. How should the trade-off be made?
What is the daily sending limit of each mailbox your business uses? What is your actual daily volume? In what order do your messages leave when volume is high? Have you ever delayed a receipt or password link because of a campaign? How do you measure bounces and complaints? How confident are you in the numbers? Which email laws apply to your recipients? Where in your system is each enforced? If one mailbox were suspended tomorrow, what would stop working?
Complete an Inbox Ledger for each sending lane. Run the bounce test described above and check that the result is recorded correctly. Find one legal requirement that your business currently meets by habit, and enforce it in the system instead. • • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. If building a distribution channel now costs almost nothing, should a business build channels before it has accounts to use them, and how should it report capacity that exists but is not yet working? In the old economics of software, a business built a channel when it needed one. Building was expensive, so it followed demand. When building is cheap, the order can be reversed. A business can build every channel it might ever use, leave each switched off, and switch it on the moment an account becomes available. This chapter examines that strategy, which we call armed-but-dormant capacity, and the governance problem it creates.
Goldratt's (1984) theory of constraints holds that a system's output is limited by its bottleneck, and that improving anything other than the bottleneck is wasted effort. When engineering was the bottleneck, building channels in advance would have been waste. When engineering is no longer the bottleneck, building ahead can be sensible. The bottleneck has moved to accounts, permissions and reputation (Chapter 2). McDonald and Eisenhardt (2020) found that effective ventures in new markets postponed commitment to a single business model while they learned. Armed-butdormant capacity is a similar idea applied to distribution. It keeps many options ready without committing scarce attention to any of them until there is reason to. Capacity held in reserve is only valuable if it can be activated quickly and safely. That requires two things: a clear trigger for activation, and an honest record of what is actually working.
A full engine with no accounts. The business had no audience and no social accounts. Its owner nevertheless asked for a full distribution engine. It was ported "as is" from a sister venture whose engine already worked. The engine drafts and publishes posts across more than thirty publishing rails: several accounts on a social scheduling service; direct connections to a decentralised social network, a developer blogging platform, a messaging service, community forums and others; optional sets of rails for individual sellers who might promote the product. It runs four times a day on the business's automation platform, within the minutes budget (Chapter 16). Armed by credentials. Each rail is armed but dormant. It activates only when its own credentials exist, so adding an account's key is enough to bring it to life. The whole engine also runs only when a single setting is switched on. A checklist in the documentation lists the accounts to create, in order. Tested before activation. Before any account existed, the engine was run in a dryrun mode that does everything except publish. The dry run found a defect: images stored in the database were being served as text, which would have broken every image card. It was fixed before any real post was made. Honest labels. On the final day of the period studied, the owner noticed that the console labelled rails as "active" when they were merely switched on and waiting for an account. He asked for the label to read "on (waiting for account)". The console now distinguishes three states: Active: switched on and credentials present, so it will publish. On (waiting for account): switched on but no credentials, so it will do nothing until an account is added. Parked: switched off by the owner. At the end of the period every rail was in the second state. No post had been published. • • • • • •
The label correction is small, but it points to a real governance problem. In a business run largely by software, the owner learns what is happening mainly through a console. If the console says "active", the owner reasonably believes the channel is reaching people. In fact it may be reaching no one. The owner then under-invests in creating accounts, the real bottleneck, because the console says the job is done. This is a version of a broader risk. Lee and See (2004) argue that people should rely on automation appropriately, in line with what it can actually do. A status display that overstates capability encourages over-reliance. In an autonomous business with few human eyes, the honesty of status labels is not cosmetic. It decides whether the owner's limited attention goes to the right place.
Manage every channel through six stages: Stage What it means Test before moving on 1. Build The channel's code exists Automated tests pass 2. Arm The channel will activate when its credentials appear Removing the credentials disables it cleanly 3. Dry run The channel does everything except publish Outputs inspected by a person; defects fixed 4. Label The console shows its true state "Waiting for account" is shown when credentials are absent 5. Activate Credentials are added and it publishes First real outputs checked by a person 6. Park or keep At a gate, the channel is kept, changed or parked Evidence recorded (Chapter 21) Alongside the cycle, keep an account checklist: every account the channels need, the steps to create it, the time it takes, any approval required and its current status. In an armed-but-dormant business, this checklist is a strategic document. It lists the real bottleneck.
Waste or option? Building thirty channels before having an account for any of them can be seen as waste: code that may never run, and that must be maintained. Or it can be seen as a cheap option, valuable precisely because building is cheap and accounts are slow. Does dormant code rot? Platforms change their interfaces. A channel built today and activated in six months may no longer work. How often should dormant channels be dry-run? Breadth versus depth. Thirty channels at once may spread an owner's attention so thinly that none builds a real presence. Some argue a new business should build depth on one or two channels before arming the rest. Who decides the label? The owner caught the misleading label. In a larger organisation, who is responsible for the honesty of a dashboard, and how would anyone know it was wrong?
Which channels could your business build now and leave dormant? Which accounts would each need? What is your current bottleneck in distribution: building, accounts, content or reputation? Look at your own dashboards. Is there any status that might overstate what is actually happening? How would you test a channel before it reaches real people? If you had thirty channels ready tomorrow, which three would you switch on first, and why?
List every distribution channel you might use and place each in a stage of the Armed-Dormant Capacity cycle. Write your account checklist, with steps, time and status for each account. Review the labels on your main dashboard. Rename any that could mislead someone who sees only the dashboard. • • • • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. How should a business with no audience reach out to strangers in a way that is effective, honest and sustainable, and which parts should a machine never do? Inbound pull is slow (Chapter 10). A new business usually needs some customers before search engines, marketplaces and loops begin to work. Outbound contact, reaching out to people who have not asked, fills the gap. It is also where many businesses do lasting damage to their reputation. This chapter describes an outbound design built on three ideas: reach out because of a signal, lead with proof, and keep replies human.
An unsolicited message is most welcome when it arrives at the moment the recipient has the problem it addresses. Public information often reveals such moments: a company posts a job for a role that suggests a gap; a start-up announces funding and will soon invest in growth; a founder asks a question in a public community; a store launches a new site. These are buying signals. They do not prove that someone will buy, but they make it more likely that a relevant message will be read. • • • •
Chapter 5 argued that proof, a diagnostic of the recipient's own situation, is a credible signal for an unknown sender. In outbound, proof changes the nature of the message. A message that says "we help companies like yours" asks the recipient to trust a claim. A message that says "your demo form asks for eleven fields; here are the three that cost you the most sign-ups" gives them something they can check. Simon's (1971) poverty of attention favours the second. It carries information about the recipient, which is the only kind they have reason to read.
Two kinds of limit apply to outbound automation. Platform terms. Major professional networks prohibit automated tools that send connection requests or messages on a user's behalf. Breaking those terms risks the account, and the account is a piece of borrowed reputation that may have taken years to build. The nature of replies. A reply from a prospect is the start of a relationship. It may contain a question, an objection, a complaint or an opportunity that no template anticipates. Lee and See (2004) argue for reliance on automation that is calibrated to its actual capabilities. Few current systems are capable of handling a stranger's first reply with the judgement it deserves. The case's own defects (Chapter 15) show what can happen when a classifier's reading of a reply triggers an action automatically.
Signals. The business collects public buying signals from several kinds of source: job postings on hiring platforms; funding announcements; community discussions; a technology news forum; news feeds. • • • • •
Each signal can trigger a prospect audit. At the end of the period studied the database held 29 signals and 19 audits. Proof attached. Every outreach touch is built around an audit of the prospect's own site. Split by audience. The plan aims about half of outreach at end customers with the strongest signals. The other half goes to distributors who can reach many customers at once: agencies, newsletter owners and community administrators (Chapter 14). Email, automated with gates. Proof-first cold email goes only to business addresses published on websites. It is capped at 40 a day within the overall budget, sent in priority order behind all other email, and protected by the gates and breakers of Chapter 11. Network messages, prepared by the machine and sent by the owner. On the professional network, which forbids automation, the system prepares a queue of copy-ready messages and the owner sends them by hand. The plan specifies a blank connection request, then a message with the findings once the request is accepted, with at most three touches per person and about ten actions a day. At the end of the period studied, nine touches were prepared and waiting. Replies, by hand. The owner's instruction was that first touches into real inboxes should be autonomous, while he personally worked the replies. The system reads incoming replies, classifies them and drafts responses. A person approves every reply before it is sent. The console's Inbox tab exists for this. A gate, not a forecast. The plan sets a test for every message variant. After 50 messages, a variant with fewer than 5% positive replies is dropped. One with 15% or more becomes the default. These are starting thresholds to be tuned with real data, not predictions. The plan is also explicit that outbound "doesn't compound": its effect stops when sending stops. Its role is to bring early revenue and learning while slower channels mature, and to recruit distributors.
Design every outbound motion as a five-step loop: Step Question Rule 1. Signal Why this person, now? No signal, no message 2. Proof What can we show them about their own situation? Proof must pass the Proof Signal Test (Chapter 5) 3. Touch Through which channel, how often, under what cap? Obey platform terms; cap touches per person and per day 4. Reply Who answers? A person approves every reply to a stranger 5. Gate When do we judge the variant, and on what threshold? Set the sample size and the kill-and-scale thresholds in advance Two measures keep the loop honest: Positive replies per message, by variant and by audience, judged at the gate. Paid customers per hour of owner time, the plan's north-star measure, which accounts for the human effort that replies demand.
platform rules? The owner sends each message personally. But if a machine chooses the recipient and writes the text, is the human just a clicker? Where does assistance end and automation begin? Signals and privacy. Buying signals come from public information. Some recipients may still feel watched when a stranger knows they posted a job or raised money. How should a business weigh relevance against the feeling of surveillance? Distributors or end customers? The plan splits outreach between them. Distributors multiply reach but take longer to win. Which should a new business favour? • • • • •
Are thresholds meaningful at small samples? Fifty messages is a small sample. A 5% threshold means two or three positive replies. Is the gate a sound test or a ritual?
What public signals indicate that a prospect has the problem you solve? How quickly could you detect them? Rewrite your current first message so that it leads with proof about the recipient. What changes? Which of your outbound steps could be automated without breaking platform rules or damaging trust? Which should not be? Who answers replies from prospects in your business today, and how quickly? What thresholds would make you drop a message variant? Have you ever dropped one?
Map your outbound motion onto the Signal–Proof–Human loop and identify the weakest step. Write a list of three buying signals for your best audience, and where each can be found. Set a gate for your next outbound test: sample size, kill threshold and scale threshold. • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. How can a small business make each customer, user or partner bring in more of them, so that growth does not depend entirely on its own effort? A business that must find every customer by its own effort grows only as fast as its owner works. A business where each user brings others, or where partners bring their own audiences, can grow faster than its owner's effort. This chapter examines two such mechanisms: loops, in which use of the product creates new users, and partners, who bring audiences the business could not reach alone.
Platform economics provides the foundation. Rochet and Tirole (2003) showed that platforms create value by bringing groups together, and that pricing one group low can attract another. Parker and Van Alstyne (2005) showed that a product given away to one group can pay for itself through the value that group creates for others. A product loop applies the same logic inside a single product. A free user creates an artefact (a report, a score, a badge) that is seen by people who have not yet used the product. Some of them try it, create artefacts of their own, and so on. Zott and Amit's (2010) design themes help to classify loops: Complementarity loops make one activity more valuable because of another. A monitor makes an audit more valuable; a comparison makes a score more meaningful. Lock-in loops give users reasons to stay. Saved history and team workspaces are examples. Novelty loops create new ways to reach people. A watermark on a report that travels to a third party is one. • • •
Partners are a different mechanism with a similar effect. An agency that resells a product to its clients, a newsletter that features it, or an affiliate who promotes it for a commission each brings an audience that has already granted them trust. In Akerlof's (1970) terms, a partner's endorsement lends the newcomer some of the partner's reputation, and so reduces the lemons problem. Partners are also a form of borrowed reputation (Chapter 2), with the same risks. If the product fails a partner's clients, the partner's reputation suffers, and the partnership ends.
One caution is essential. Loops multiply existing traffic; they do not create it. A share card shown to no one brings no one. The case's build plan says so directly: "loops amplify whatever traffic exists". A business needs some initial traffic, from outbound, communities, search or partners, for its loops to act on.
The case's code includes these loops: Share cards. An image showing a site's score, designed to be shared. Each share shows the tool to new people. Competitor comparison. A user can compare their site with up to three others. Each comparison brings new sites into the audit pool. The plan forbids telling the compared businesses who asked. Embeddable badges. Sites that score well can display a badge, which links back to the service. Watermarked agency reports. On the free plan, reports an agency sends to its own prospects carry a watermark, so each report advertises the service to a new business. On the paid plan, reports are white-labelled. Forwardable alerts. Monitor alerts are designed to be forwarded to developers and teams, who may then sign up. Referral rewards. A member earns one extra monitor for each referred person who becomes active, up to ten. The plan originally proposed a free month of • • • • • •
Pro for three referrals. The built version rewards in product capacity, which costs a zero-cash business almost nothing. Monthly data report and benchmark pages. These are generated from aggregate, anonymised audit statistics, intended for newsletters and journalists, who often cite original data. And these partner mechanisms: Agency partner programme. A 30% recurring commission, white-label reports, and referrals of done-for-you work from the business to the agency. Platform affiliates. The merchant platform's affiliate network lets others promote the product for a recurring commission. The plan proposes 30–40%. Open method. The public methodology is generated from the scoring code. The plan proposes publishing the deterministic check library openly and offering a rate-limited free interface, to attract developers and integrations. Every link carries its source. Share cards, badges, listings, affiliate links, posts, answers and messages carry a reference tag. The member's first and last touch are recorded at sign-up and purchase in a single database write. The business can therefore judge which loop or partner produced each customer. None of these loops had been exercised by real users by the end of the period studied. The business had not launched, and loops need traffic to amplify.
Map each loop in five steps: Step Question Example: watermarked agency report Trigger What user action starts the loop? An agency runs an audit for its prospect Artefact What is created? A report with a watermark Audience Who sees it who has not used the product? The agency's prospect, a business owner Return path How does a viewer become a user? Watermark links to the audit page, tagged with the agency's reference • • • •
Question Example: watermarked agency report Measure How do you know the loop is working? Sign-ups whose first touch is the watermark tag For each loop, estimate two numbers: how many people see each artefact, and what fraction of viewers become users. Their product is the loop's yield. A yield below one means the loop amplifies other channels. A yield above one, which is rare, means the loop sustains itself. For each partner type, add a sixth line: Reputation at risk: what happens to the partner if the product fails their audience, and what protects them?
Loops or pollution? Watermarks, badges and share prompts can feel like advertising imposed on users. When does a loop become an irritation that drives users away? Comparisons and consent. A competitor comparison audits a business that did not ask to be audited. The plan's rule (never reveal who asked) protects the user. Does anything protect the business being compared? Commission levels. A 30% recurring commission is generous. It buys partners' effort but gives away a large share of revenue for the life of each customer. Is it the right level for a business with no other variable costs? Rewards in kind or in cash? The case rewards referrals with product capacity. Some argue that cash motivates more strongly. Others argue that product rewards attract referrers who actually use the product.
What artefacts does your product create that people outside your customer base might see? Which of your users would be good partners? What would make it worthwhile for them? • • • • • 1. 2.
How do you know which channel brought each customer? Is your attribution reliable? What would happen to a partner's reputation if your product failed one of their clients? Where does your traffic come from today, before any loop acts on it?
Draw a Loop Map for each loop your product has, or could have. Estimate the yield of your strongest loop. Decide whether it amplifies or sustains. Add a source tag to every link you publish this week, and check that you can see the source of each new sign-up. 3. 4. 5. 1. 2. 3.
PA R T I V
The Tight Bucket
Opening question. In a business that can run itself, which actions should the machine take alone, which should it take only under strict limits, and which should always wait for a person? The owner of the case business wanted a pipeline that "runs autonomously; the human comes in only for very important activities". Almost every founder using AI tools wants something similar. But "very important" is not self-defining. This chapter argues that the line between machine and human should be drawn by the consequences of an action, not by how hard it is to automate. It offers a matrix for drawing that line.
Human-factors research has studied automation for decades. Parasuraman, Sheridan and Wickens (2000) proposed that automation should be considered separately for four functions: Information acquisition: gathering data. Information analysis: making sense of it. Decision selection: choosing what to do. Action implementation: doing it. Each function can be automated to a different level, from no assistance to full autonomy. A system might gather and analyse information fully automatically, suggest decisions for a person to approve, and act only when told to. Lee and See (2004) argued that the goal is appropriate reliance. People should trust automation as much as its actual performance justifies, and no more. Overtrust leads to misuse, and under-trust leads to disuse. 1. 2. 3. 4.
Bainbridge (1983) identified a set of "ironies". Automating the routine parts of a job leaves people with the hardest parts. It also gives them less practice, so they become less able to handle those parts. And they are asked to monitor a system they rarely touch, which humans do poorly. Raisch and Krakowski (2021) extend the argument to management. Automation and augmentation are interdependent. A choice to automate one activity changes what people can do in others, over time and across the organisation.
These frameworks classify functions of a task. A business needs to classify actions: send this email, delete this record, post this answer, change this price. For business actions, two properties matter most: Reversibility. Can the effects be undone cheaply and completely? A draft can be deleted. A sent email cannot be unsent. Erased data cannot be recovered. Externality. Do the effects fall on people outside the business, such as prospects, customers, community members or the public, or on the business's legal and reputational position? A wrong internal score affects no one else. A wrong public post affects everyone who sees it. An action that is reversible and has no externality is safe to automate fully, even if the machine is often wrong. An action that is irreversible and affects third parties needs a person, even if the machine is usually right.
The case's design places actions as follows: Automated: audits, scoring, monitoring, collecting buying signals, publishing private report pages, and drafting content and messages. All are reversible and mostly internal. Automated with gates: cold first-touch email. It is irreversible once sent and reaches third parties, but it runs under the daily cap, the priority order, the bounce gate, the kill switches and permanent suppression (Chapter 11). • • • •
Prepared for a person: messages on the professional network, replies to prospects, and answers to community questions. The machine drafts; the owner sends. At the end of the period studied, 31 community questions and 9 outreach touches were waiting. Human only: pricing, refunds, partner agreements, and scoping of done-foryou work. The clearest lesson came from a defect. The system used an AI classifier to label incoming replies. When it labelled a reply "unsubscribe", the code also ran the data-erasure routine if the word "delete" appeared anywhere in the message. A customer writing "how do I delete a monitor… and please unsubscribe me from the newsletter" would have had their data erased. An irreversible action affecting a customer had drifted into the "automated" category through a probabilistic classifier and a keyword. The fix allowed erasure only on an explicit erasure request. The irreversible step is now tied to an unambiguous instruction from the person concerned. Two related defects point the same way: Triage rules ran on the whole text of a reply, including quoted earlier messages. An "unsubscribe" line in the business's own quoted footer could trigger an unsubscription. The fix runs the rules only on the sender's own words. A double-submitted reply in the console could be sent twice. The fix makes each send claim its message atomically, so it can only go once. In each case, the danger lay not in the machine's intelligence but in an irreversible or external action taken without a sufficient gate.
Place every action your system can take in one of four quadrants: Low externality High externality Reversible Automate. Let the machine act; review samples. Automate with gates. Caps, rate limits, kill switches, suppression lists, monitoring. • • • •
High externality Irreversible Prepare for a person. Machine drafts; person confirms. Human only. Machine may assist; person decides and acts. Apply it in three steps: List every action your system can take. Include the unglamorous ones: deleting, refunding, changing a plan, posting publicly, emailing a list. Place each action in a quadrant, and note the gates it needs. Check the code. For each action, confirm that the system's actual gates match its quadrant. The case's erasure defect was an action whose quadrant was "human or explicit instruction" but whose code said "automate". Remember that drafting and sending are different actions. A reply can be drafted automatically (top left) and sent only by a person (bottom right).
Will the boundary move as models improve? If AI classifiers become very reliable, should replies to prospects be automated? The matrix says that reversibility and externality matter more than accuracy. Some would argue that sufficiently accurate systems deserve more autonomy.
deepen it? The owner keeps the most consequential actions. But if he does them rarely, will he do them well? Is a human click real oversight? If a person approves fifty drafted replies in five minutes, the approval may be a formality. How can approval be made meaningful? Who carries the externality? A business can decide that a risk to its own reputation is acceptable. Can it make the same decision about risks to third parties? 1. 2. 3. • • • •
List five actions your systems take automatically today. In which quadrant does each belong? Has your business ever had an automated action go wrong in a way that affected a customer? Which quadrant was it in? Where in your business is a "human approval" step at risk of becoming a formality? Which of your irreversible actions depend on a classifier, a keyword or a rule that could misfire? Bainbridge warns that automation leaves people with the hardest tasks and less practice. Where do you see this in your organisation?
Complete the Autonomy Boundary Matrix for every action your system can take. For each irreversible action, write down the exact condition that triggers it. Test that condition against three tricky inputs. Find one approval step and make it more meaningful: show the reviewer what matters, limit batch sizes, or sample approvals for later review. 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. How can a business that runs without supervision be kept safely within the limits of the free infrastructure it depends on, without anyone watching a dashboard? A business on free infrastructure lives within quotas: so many database operations, so many requests, so many units of AI processing, so many minutes of automation a day or a month. A person running the business by hand would notice if usage crept towards a limit. An autonomous business has no such person. This chapter describes a governance mechanism for that situation, quota-bounded autonomy, and the evidence from the case about why it needs two meters, not one.
The cloud provider used in the case publishes free allowances that include, per day: 5 million database rows read; 100,000 database rows written; 100,000 requests; 10,000 units of AI processing ("neurons"). It allows five scheduled triggers per account. The automation platform allows 2,000 minutes a month for private repositories. Two features of these limits matter. First, they are hard: exceeding them stops service or creates a bill. Second, they are counted in units that do not map neatly onto business activity. An index on a database table, for example, means that writing one row counts as several written rows, because the provider bills each index update. • • • •
The owner set a rule before building: the pipeline should use no more than 20% of any free quota while running "at full tilt", "so that I never need to worry about quotas". Chapter 4 discussed the rule as a self-imposed constraint. This chapter is about how it was enforced.
The business enforces the rule with a governor in four steps. 1. Measure. Every database call records the rows read and written as reported by the database itself, including index writes. Every AI call records the units it consumes. The totals are saved to a single row per day, so the meter itself costs almost nothing. 2. Cross-check. Every thirty minutes the governor asks the provider's analytics service for the provider's own figures, and keeps whichever is higher. 3. Pace. Background work (prospect audits, enrichment and AI classification) may use 70% of each daily budget. That share is released evenly across the day, with a one-hour head start, so that a busy morning cannot use up the afternoon's allowance. 4. Degrade, do not fail. When a budget is reached: anonymous visitors receive a cached report for the same site if one exists from the last 30 days, or a message asking them to return after midnight UTC; AI summaries fall back to a second free provider, then to fixed templates; paying members, their monitors and the paid interface are never refused. The budgets are 20% of each allowance: 20,000 row writes and 1,000,000 row reads a day; 2,000 AI units a day; 400 automation minutes a month. • • • • • •
A guard skips the slowest test job once 80% of the monthly minutes budget is used. An early optimisation cut the browser test job from about ten minutes to about one, by using a browser already installed on the automation platform's machines.
The business recorded both meters for three days. The results show why the crosscheck matters. Day (2026) Rows read: own meter / provider Rows written: own meter / provider AI units: own meter / provider 26 October 3,450 / 5,759 71 / 783 4.41 / 4.41 27 October 9,599 / 9,480 402 / 1,839 38.00 / 38.00 28 October (part day) 5,615 / 5,433 396 / 1,051 45.47 / 45.47 The AI meters agree exactly. Reads agree closely after the first day. Writes do not agree: the provider counted between 2.7 and 11 times more writes than the business's own meter. The reason is structural. Database migrations, deployments, console queries and administrative scripts all write to the database outside the application code that the meter instruments. The gap was largest on the heaviest day of construction and narrowed as construction slowed. A business that trusted only its own meter would believe it was well within budget at exactly the moments when it was most active. At its observed peak, the business used: 0.19% of the free read allowance; 1.84% of the write allowance; 0.45% of the AI allowance; 1.44% of the request allowance. In October it used 39 automation minutes, 1.95% of the free allowance. These figures show that the rule was comfortably met at low volume. They do not show how the governor behaves under heavy load, because usage never came near a budget. Pacing and degradation were exercised only in automated tests. The • • • •
arithmetic gives an indication of room: at about 11 row writes per anonymous audit, the 20,000-write budget allows roughly 1,800 audits a day. That is an estimate, not an observation.
Define two quantities for each metered resource: Headroom ratio (H) = your budget ÷ the provider's allowance. This is a policy choice; in the case, H = 0.2. Observed utilisation (U) = the higher of your own measure and the provider's measure ÷ the provider's allowance. The rule is: U must never exceed H. Enforce it with the four steps: Step Design question Case answer Measure Where is each unit consumed, and is every path instrumented? Every database and AI call; one row per day Crosscheck How often do you compare with the provider, and which number do you use? Every 30 minutes; the higher Pace How is the budget spread across the period? Who gets priority? Background work gets 70%, released evenly Degrade What happens at the limit, and who is protected first? Cached or deferred for anonymous users; paying customers never refused Choosing H is a strategic decision: A low H protects against provider changes, spikes and metering error, and frees the owner from watching dashboards, at the cost of unused capacity. A high H buys growth before an upgrade, at the cost of margin. Record the upgrade trigger as well: the condition under which you will move to a paid tier. In a zero-cash business, upgrading is not failure. It is a planned step, taken when revenue can pay for it. • • • •
Is 20% too cautious? A competitor using 100% of the same free tier could serve five times as many free users. Is the owner's peace of mind worth that? Should the meter be trusted at all? If the provider's figures are authoritative, why keep a self-meter? The case suggests the self-meter is needed for real-time pacing, because provider analytics lag. Is that enough to justify it? Who should degrade first? The case protects paying customers and degrades anonymous visitors. Some argue that anonymous visitors are the future customers, and that degrading them harms growth more than delaying a paying customer's background task. Quota as strategy. Free tiers are set by providers for their own reasons and can change. Is building a business around them prudent, or a dependence in disguise (Chapter 23)?
What are the hard limits on your infrastructure, and what is your current utilisation of each? Do you measure your own usage? Have you ever compared your figures with your provider's? If a busy hour consumed a day's allowance, what would happen to your customers? What headroom ratio would you choose for your most important resource, and why? What is your upgrade trigger, the condition that would justify paying for more capacity?
For your three most important metered resources, calculate H (your intended budget) and U (actual use, using the higher of your measure and the provider's). Write a degradation plan: what happens at each limit, and who is protected first. • • • • 1. 2. 3. 4. 5. 1. 2.
Compare one week of your own usage figures with your provider's. Note any gap and its cause. 3.
Opening question. When a business's infrastructure is free, what does it actually cost to serve a customer, and how should that cost be measured? Unit economics, meaning the revenue and cost of serving one customer or one transaction, is a staple of business analysis. It is usually expressed in money: cost to acquire a customer, cost to serve them, lifetime value. In a business that runs on free tiers, most costs are zero in money but not in resources. Every audit, page view and email consumes part of a quota. This chapter argues that such a business should measure its unit economics in the provider's own units, at the level of the meter, and it sets out the conditions under which a business can run with no cash at all.
Information goods have long been characterised by high fixed costs and very low marginal costs (Shapiro & Varian, 1999). Serverless computing pushes the logic further: the developer pays only for what is used, and many providers offer generous use free (Jonas et al., 2019). For a small business, the cash marginal cost of one more customer can be exactly zero. But the resource marginal cost is not zero. Each action consumes a measurable amount of a free allowance, and the allowance is finite. When a business is bound by a headroom rule (Chapter 16), these resource costs determine how many customers it can serve before it must start paying.
Bhide (1992) advised bootstrapped founders to focus on cash rather than on accounting profit or market share. Winborg and Landström (2001) documented the ways small firms minimise their need for capital. A business that runs on free tiers
is an extreme case of this discipline: it needs no capital at all for infrastructure. The discipline shifts from managing cash to managing quota. The same rigour applies: know what each activity consumes, and design to consume less.
The business measured its unit costs in production, in the provider's units: Activity Rows written Rows read Other Anonymous audit ≈11 ≈10 — Prospect audit ≈10 ≈15 — Report view — Idle scheduled minute ≈2 — AI summary — — 4.41 AI units (provider: 4.4096) These numbers were not the first version. Two changes driven by the meter show why measurement at this level matters. The lean pass. The first version of the audit stored each of its 38 findings as a separate database row with two indexes. Because the provider counts each index update as a written row, one audit cost about 120 row writes. Compressing the findings onto the audit row reduced this to about 11, a cut of roughly 91%. In practical terms, the number of audits the write budget could support rose about tenfold. The email budget query. An early check on the email budget ran three range scans of the outgoing mail table for every message. Replacing them with one grouped count avoided an estimated 2.6 million row reads a day at full sending volume. That is roughly half of the provider's entire daily free read allowance, consumed by a single query pattern. Without measurement at the meter, the business would have broken its own 20% rule on email alone, and no dollar figure would ever have revealed it.
Other choices followed the same logic: The AI model. Summaries use an optimised model that consumes roughly one-sixth of the units of the standard version of the same model. The input to the AI classifier is capped at 2,000 characters. No key-value store. It was removed entirely, because its free allowance of 1,000 writes a day was too small to be useful. Browser-side tools. Tools such as the churn-risk scorer run in the visitor's browser, so they consume no server resources at all. Cash costs. The only cash cost in the model is the merchant platform's fee on each sale: 2.7% plus $0.30 per domestic card transaction, more for international cards and currency conversion. It arises only when a customer pays. The business therefore breaks even on its first sale. The plan notes some optional one-off costs: a domain name, and listing fees for the browser-extension store and the e-commerce app store. These are to be paid when the channels are activated, not before.
The case suggests five conditions under which a digital business can operate with no cash outlay. Every fixed cost sits on a free tier, with headroom. Observed utilisation stays below the headroom ratio for every metered resource (Chapter 16). Every variable cost is linked to success. The only variable costs arise when a customer pays, such as payment fees and partner commissions. Unit costs are measured in the provider's units. Rows, requests, AI units and minutes, not estimated in dollars. Owner attention is the binding budget. There is an explicit daily time target and an allocation of it (Chapter 2). Upgrade triggers are explicit. The conditions under which a paid tier will be adopted are written down in advance, for example sustained processing-time limits on the serverless plan. • • • 1. 2. 3. 4. 5.
When all five hold, the cost of the venture failing is the owner's time. Starting such a business becomes closer to an affordable-loss decision in Sarasvathy's (2001) sense than to an investment decision.
For each activity your business performs repeatedly, record: Activity Units consumed (per provider meter) Daily volume at full tilt Daily total Budget (H × allowance) Share of budget e.g. anonymous audit 11 row writes 1,000 11,000 20,000 55% e.g. report view 1 row write 3,000 3,000 20,000 15% … Total must be ≤ 100% Then ask: Which activity consumes the largest share? That is where an optimisation like the lean pass pays most. Which activities scale with free use, and which with paid use? Free-use activities need ceilings (Chapter 6). Where are the hidden consumers? Look for indexes, repeated scans, retries and background jobs. The email budget query was invisible until it was measured.
Is quota a real cost? Some argue that a free resource has no economic cost until it runs out, so measuring it is premature optimisation. The case suggests that by the time it runs out, it is too late to redesign. Does zero cash distort decisions? A business that refuses to spend $5 a month may spend hours of owner time avoiding it. Is owner time being undervalued? 1. 2. 3. • •
Break-even on the first sale. This is true in cash terms. It ignores the owner's time, which is the real investment. Should that time be costed, and at what rate? Optimising for one provider. The lean pass was shaped by one provider's billing rules, such as counting index writes. If the business moved, its optimisations might not transfer. Is meter-level design a form of lock-in?
What does it cost your business, in resource units, to serve one free user? One paying customer? Which single activity consumes the largest share of your most constrained resource? Have you ever found a hidden consumer, a query, retry or job that used far more than expected? How did you find it? Which of the five Zero-Cash Operating Model conditions does your business meet? Which does it fail? What is the real cost of your own time, and does your business design account for it?
Complete a Meter-Level Unit Economics Sheet for your five most frequent activities. Find the activity with the largest share and design one change to reduce its consumption by half. Write down your upgrade triggers: the specific, observable conditions under which you will start paying for infrastructure. • • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. When AI can build a business faster than anyone can read what it built, what risk accumulates, and how should it be managed? The case business was built in three days. That speed is the promise of AI-assisted development, and it is real. But speed has a shadow. Every line of code, every message template and every automated rule that has not been checked against the owner's intent is a small, unknown liability. This chapter names that liability verification debt, describes its composition in the case, and proposes ways to measure it and pay it down.
The productivity evidence for AI-assisted work is strong (Chapter 1). The evidence on its correctness is more sobering. Pearce and colleagues (2022) asked an AI coding assistant to complete programs in scenarios relevant to security. About 40% of the programs it produced contained vulnerabilities. Perry and colleagues (2023) ran a study in which participants wrote code with or without an AI assistant. Those with the assistant wrote less secure code, and were more likely to believe their code was secure. Dell'Acqua and colleagues (2026) found that consultants using AI performed much better on tasks inside the AI's capability frontier and worse on a task outside it. The output looked equally competent in both cases. Together these studies suggest a specific risk. AI-produced work tends to look right, whether or not it is. Its errors are not obviously errors. And people who use it may become more confident at exactly the moment they should become more careful.
Software engineers speak of technical debt: design compromises taken deliberately to move faster, which must be "repaid" later by reworking the code. Technical debt is known. The team chose it and can list it. Verification debt is different. It is the stock of artefacts (code, copy, configuration and automated decisions) whose behaviour has not been checked against the owner's current intent. It is not chosen; it accumulates as a by-product of speed. It is not known, because nobody has looked. Its size grows with the speed of building, not with the size of the team.
The owner required that "every line of code is reviewed for errors, breaks and points of breaking, and all identified issues are fixed", with no new features added during reviews. After the first complete release there was a hardening pass, followed by two documented line-by-line reviews. The first found 32 defects and the second found 11. Every defect was fixed, and each fix was accompanied by a test so that it could not return. The automated test count rose from 187 after the first review to 206 after the second, and stands at 233. The 43 documented findings fall into seven categories: Category Number Example Communication errors reaching third parties A rescan email would have reached real people signed with a raw template placeholder instead of the owner's name Resource, quota and capacity governance Blocked messages occupied the outbox's selection window, so sendable mail was starved Decision drift The deployment check still required a second-factor secret after the owner had made it optional, so every deployment failed Reputation accounting Rejections by recipients' mail servers were not counted in the bounce rate Data integrity and validation A status was changed before the input was validated, so a rejected request still altered data Security and privacy A login lockout applied globally, so anyone could lock the owner out of his own console for 24 hours
Number Example Money and entitlements A cancellation event could downgrade an account the owner had granted free Three patterns stand out. Most defects were silent. Only 3 of the 43 produced a visible failure: the blocked deployment, some customer pages that were not served, and an error response to a particular kind of web request. The other 40 let the code run and do something plausible but wrong. Watching the system work would not have revealed them; only reading it did. Half reached outside the business. Twenty-two of the findings, in the communication, reputation, money and privacy categories, would have affected prospects, customers or recipients of email. Verification debt is a business risk, not only an engineering one. A fifth were decision drift. Eight findings were residues of decisions the owner had changed. He made the second factor optional, and he reversed the rule that customers would interact only through the merchant platform. Each time, the change was implemented where it was requested, but traces of the old decision survived elsewhere, in code, copy, comments and routes. All three of the visible failures were of this kind. Decision drift deserves particular attention. When an owner can change a decision in one sentence, and an AI agent implements it in one place, the old decision lives on everywhere it was not explicitly removed. The faster decisions change, the more drift accumulates. What the case does not show is how many defects remain. The decline from 32 to 11 is consistent with debt being paid down, but it is not proof that the debt is gone.
Five measures, computable from a simple review log:
Definition Case Review yield Findings per review pass 32, then 11 Decay ratio This pass's yield ÷ last pass's 0.34 Silent share Silent findings ÷ all findings 93% Third-party share Findings that would affect outsiders ÷ all findings 51% Drift share Findings caused by changed decisions ÷ all findings 19% Three practices for paying the debt down: Read, line by line. Use a reviewer who did not write the code, human or otherwise, and record every finding. Watching the system run will not find silent defects. One test per finding. Convert each defect into an automated test that fails if it returns. The debt then stays paid. Propagate decisions. When a decision changes, search everything (code, copy, documentation, configuration, comments) for traces of the old one. Treat a changed decision as a search task, not an edit. A decay ratio well below 1 over successive passes suggests the debt is shrinking. A high third-party share suggests that reviews should be prioritised by where effects fall, not by where code is complex.
Can AI review AI? If an AI reviewer shares the builder's blind spots, its review may miss the same errors. If it does not, it may be a cheap way to reduce debt. What evidence would settle the question? Is line-by-line review realistic? Reading every line is slow, and the point of AI was speed. Is verification debt simply the price of speed, to be accepted, or must it always be paid? Does testing replace reading? Tests check what someone thought to test. Silent defects are often the ones nobody thought of. Can testing ever substitute for reading? 1. 2. 3. • • •
Who is accountable? When an AI-built system sends a wrong email to a customer, the owner is accountable. Does that change how much verification an owner owes?
How much of your product was produced faster than anyone could read it? Has it all been reviewed since? When your team changes a decision, how do you find every place the old decision lives? Of the defects your team found last quarter, how many were silent? How were they found? Which of your systems' outputs reach customers or the public without being checked by a person? Perry and colleagues found that people using AI were more confident in less secure code. Where might over-confidence be a risk in your organisation?
Start a review log. For every defect found, record its category, whether it was silent or loud, and whether it would have affected anyone outside the business. Choose one recent change of decision and search your entire codebase, copy and documentation for traces of the old decision. Calculate the five measures for your next two review passes, and share them with whoever oversees your product. • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. When a customer pays, what should they receive at that moment, and how can a one-person business give every customer a proper, private workspace without any manual set-up? For many small software businesses, the moment of purchase is followed by a delay. Someone must create an account, set permissions, send instructions and answer the first questions. For a business run by one person, that delay is a cost in attention. For the customer, it is a gap between paying and getting value, which is the moment buyer's remorse is most likely. This chapter examines tenancy at purchase: giving each paying customer their own workspace, created and handed over automatically the instant they pay.
Zott and Amit (2010) identify lock-in as one of the four sources of value in a business model's activity system. Lock-in here means activities that keep customers and partners engaged, ideally because they find staying valuable rather than because leaving is hard. A workspace that holds a customer's reports, monitors and team members is a source of lock-in of this benign kind. The value grows with use. Casadesus-Masanell and Ricart (2010) describe business models in terms of choices and their consequences, some of which form virtuous cycles. A workspace that invites a customer's colleagues can start such a cycle. More colleagues mean more use, which means more value, which means more reason to stay and to upgrade. The first experience after purchase matters disproportionately. A customer who pays and immediately finds a working, private space, with their colleagues invited and their plan's features available, has evidence that the purchase was sound. A customer who pays and waits has reason to doubt.
In software, a tenant is a customer whose data and settings are kept separate from other customers' within a shared system. There are two broad ways to provide tenancy: Separate infrastructure for each customer: their own database, application or account. Shared infrastructure with logical separation, where each customer's data is tagged and isolated within a single system. Separate infrastructure offers strong isolation but multiplies cost and operational work with every customer. Logical separation scales at almost no marginal cost but demands careful design, so that one tenant can never see another's data.
The owner's instruction was that clients should get their own workspaces, "created automatically and handed over at purchase, with no manual step". One system, many workspaces. The owner explicitly rejected separate infrastructure per client. Workspaces are created inside the single application, as rows in its database with membership and role records. This adds no infrastructure and almost no quota cost per customer. Triggered by payment. When the merchant platform's webhook reports a qualifying purchase (Pro, Agency or a done-for-you Fix Sprint), the application creates a workspace for the buyer. Handed over two ways. The buyer receives an email containing a claim link and also sees a button inside the merchant platform's member area. Either one takes them into their workspace. Seats and roles by plan. Each plan carries a number of seats, including the buyer: Pro has 3 seats. Agency has 10 seats. A Fix Sprint gives 3 seats while the sprint is active, so the client's team can follow the work. • • • • •
Each workspace has an owner role and a member role. The owner invites colleagues by email. When all seats are taken, the workspace explains how to free one. Visible to the owner. The business owner's console has a Clients tab listing every workspace, its owner, its seats and the state of any Fix Sprint. Changes in sprint status email the client automatically. Privacy across tenants. When a person asks for their data to be deleted, their seats in other people's workspaces and any pending invitations to them are removed. Their details are cleared, they are signed out everywhere, and their address is added to the permanent suppression list. If the person still has an active paid plan, the business keeps only the minimum needed to provide it and tells them how to close the plan. One of the review findings concerned exactly this area: deletion originally scrubbed only the first of several matching member records. It now scrubs them all. At the end of the period studied, the database contained one workspace, created as a test. No customer had yet paid, so the handover has not been exercised by a real buyer.
Tenancy at purchase converts what would be a recurring manual task, setting up each new customer, into a one-time design task. For a business whose binding constraint is owner attention (Chapter 2), that conversion is decisive. It also makes the business's response to a purchase independent of the owner's availability. A customer who pays at 3 a.m. in the owner's time zone gets the same experience as one who pays at noon. The design also embodies the owner's reversal of an earlier decision (Chapter 9). Customers have a space owned by the business, not only a membership on the platform. The relationship is partly reclaimed.
Design the moment of purchase in six parts:
Question Case answer Trigger What event creates the customer's space? Merchant platform's purchase webhook Container What is created, and where? A workspace in the shared application; no new infrastructure Handover How does the customer reach it? Email claim link and an in-platform button Capacity What does the plan include? Seats by plan (3, 10, or 3 during a sprint); features by plan Expansion How does the customer bring others in? Email invitations; clear message when seats are full Exit What happens on cancellation or deletion? Plan changes follow platform events; deletion removes seats, invitations and details; an active paid plan keeps only the minimum needed to run it Then test the design with three scenarios: The 3 a.m. buyer: does everything happen without the owner? The cancelling buyer: does their workspace degrade gracefully, keeping their data available to export? The deleting member: is every trace of them removed from every workspace?
Shared or separate? Logical separation is cheap but puts every customer's data in one system. A single defect could expose one tenant's data to another. When does a business owe its customers separate infrastructure? Lock-in or value? Workspaces make leaving harder. Is that a legitimate source of value, or a way of keeping customers who would otherwise leave? Automatic or personal? Some argue that a personal welcome from the owner builds loyalty that no automated handover can match. Can a one-person business afford it, and should it try? Seats as pricing. Seat limits encourage upgrades but can frustrate teams. Is a seat limit a fair proxy for value? 1. 2. 3. • • • •
What happens in your business between a customer paying and receiving value? How long does it take? Which steps in your onboarding depend on a person being available? How are your customers' data kept separate from each other? How would you know if the separation failed? What do your customers lose if they cancel? Is that loss fair to them? Would your customers value a personal welcome more than an instant one?
Complete the Purchase Moment Design for your business. Run the three test scenarios (3 a.m. buyer, cancelling buyer, deleting member) and record what actually happens. Remove one manual step from your onboarding this month. 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. If a business runs itself, what should its owner see, and how should the owner's few minutes a day be spent? An autonomous business still has an owner, and the owner still needs to know what is happening, decide what only a person can decide, and intervene when something goes wrong. The place where this happens is the owner's console, which the case calls the cockpit. This chapter treats the cockpit as part of the business model, not just an interface. It decides how the scarcest input, owner attention, is spent.
Simon (1971) argued that the design problem in an information-rich world is not to provide more information but to filter it. The scarce resource is the attention of the person receiving it. A console that shows everything spends the owner's attention on everything. Bainbridge (1983) warned that people are poor monitors of systems that rarely need them. If the owner is asked to watch a dashboard for rare problems, they will miss them. A good cockpit therefore does not ask the owner to watch. It tells them when and where to act. Lee and See (2004) argued for reliance that is calibrated to a system's real capabilities. A cockpit is the main instrument of calibration. If it shows a channel as "active" when it is not, or hides a failing mailbox, the owner's reliance becomes miscalibrated.
A phone-installable console. The cockpit is a web application that can be installed on a phone, with eleven tabs: Today: what needs a person, ranked. •
Outreach: prepared touches to send. Inbox: replies to approve. Community: questions with drafted answers to post by hand. Content: drafts to edit and approve. Gates: experiment results and recommended decisions. Seeds: job boards and companies to watch, manual audits and benchmark pages. Privacy: deletion requests and suppression. Health: quotas, lanes, settings and warnings. Clients: customer workspaces and Fix Sprints. Mesh: the state of every distribution rail. Built-in sign-in. The owner asked for a login built into the application rather than depending on an external access service, using a password only. The password is stored as a slow, salted hash. A second factor exists but is off unless the owner configures it. Failed attempts trigger a lockout per address. The first version locked out globally, so anyone could have locked the owner out of his own console for up to 24 hours by entering wrong passwords. A review found and fixed this. Honest state. The Health tab shows the day's quota use against the target of "≤ 20% of each free quota", and the state of each sending lane: cold messages today against the cap, all messages in the last 24 hours, and a seven-day reputation summary. Lanes pause automatically on bounces, opt-outs, spam placement or a provider lock, and the tab says why. The Mesh tab distinguishes channels that are active, "on (waiting for account)" and parked (Chapter 12). Switches within reach. Kill switches for all email and for cold email, the postal address required by email law (Chapter 11), the daily cap on network actions and the list of paused sources can all be changed from the console. Marketing email waits in the queue until the postal address is set, and the console says so. • • • • • • • • • •
Placeholders never shown. One review finding was that the cockpit's header displayed the raw template value "REPLACE_WITH_YOUR_FIRST_NAME" instead of the owner's name. The fix falls back to "Owner". The defect was harmless in itself. But it shows how the residues of construction reach the surfaces that people see, and why those surfaces deserve review. A time budget. The plan allocates owner time explicitly: community answers about 8 minutes a day, network messages about 12, email approvals about 5, plus weekly and monthly reviews. That totals roughly 25 minutes a day and 45 minutes a week. These are design targets, not measurements. The cockpit's job is to make them achievable.
The case suggests five principles. Today first. The opening screen answers one question: what needs me now? Everything else is a click away. Exceptions, not activity. Show what is wrong or waiting, not everything that happened. Activity logs belong behind a tab. Honest states. Every status must mean exactly what it says. "Active" means working. "Waiting" means waiting. Paused lanes say why. Switches within reach. Every action that stops harm (kill switches, pausing a lane, parking a channel) must be available from the phone, in seconds. Law and safety as settings, not memory. Requirements such as a postal address or a sending cap are settings the system enforces. They are not things the owner must remember.
Review your own console against the five principles. For each, score 0 (absent), 1 (partial) or 2 (fully met), and write the evidence: Principle Test Score Evidence Today first Can you see what needs you in under ten seconds of opening it? 1. 2. 3. 4. 5.
Test Score Evidence Exceptions, not activity Is the first screen mostly about what is wrong or waiting? Honest states Pick three statuses. Does each mean exactly what it says? Switches within reach Can you stop all outbound activity from your phone in under a minute? Law and safety as settings Is every legal requirement enforced by the system, not by habit? Then do one more test. Ask someone who has never seen the console what they think is happening in the business, based only on the first screen. Compare their answer with reality.
Is a password enough? The owner chose password-only sign-in. Security practitioners generally recommend a second factor for administrative access. When does convenience justify a weaker default? Phone or desk? A phone-first cockpit encourages quick decisions. Some decisions, such as pricing or partner agreements, deserve slower thought. Should a cockpit make some actions harder? Can the owner trust the cockpit? The cockpit is built by the same process that built the business, AI-assisted and fast. If it has verification debt (Chapter 18), the instrument itself may mislead. Time budgets as targets. A 25-minute daily target may become a ceiling that leaves important work undone. Should owner time be budgeted at all?
What is the first screen you look at each day to understand your business? What does it show? Which statuses on your dashboards might be misleading? How would you know? How quickly could you stop all outbound activity if something went wrong? • • • • 1. 2. 3.
Which legal or safety requirements in your business depend on someone remembering? How much time a day do you spend on decisions only you can make? Is that the right amount?
Run the Cockpit Review on your main console. Redesign your first screen so that it shows only what needs a person today. Move one requirement you currently remember into a setting the system enforces. 4. 5. 1. 2. 3.
PA R T V
The Tight Bucket
Opening question. How should a new business decide what to keep, change or stop, when it has no history, little data and every reason to see what it hopes to see? A founder with a new product is surrounded by numbers that feel like progress: visitors, sign-ups, followers, emails sent. Few of them say whether the business is working. This chapter draws on research into entrepreneurial experimentation to argue for a discipline of gates: decisions set in advance, with thresholds, that replace forecasts and protect the founder from vanity.
Camuffo and colleagues (2020) ran a randomised controlled trial with early-stage start-ups. Some founders were trained to treat their business ideas as hypotheses, to be stated precisely, tested with evidence and accepted or rejected. Others received similar training without this scientific framing. The founders taught the scientific approach made better decisions, including more timely pivots and decisions to abandon ideas that the evidence did not support. Koning, Hasan and Chatterji (2022) studied start-ups that adopted A/B testing, the practice of comparing two versions of a page or product with real users. Adopters improved their performance and made more substantial changes to their products. Testing did not just fine-tune; it gave firms the confidence to change direction. Ries (2011) popularised a distinction that matters here: between vanity metrics, which rise and make founders feel good but do not inform decisions, and actionable metrics, which tie specific actions to specific outcomes. Total sign-ups is a vanity metric. Sign-ups per hundred visitors from a particular channel, compared before and after a change, is actionable.
Not everything can be tested. Gans, Stern and Wu (2019) argue that entrepreneurs face many mutually exclusive paths and cannot test them all. Testing one path often forecloses another, because it builds commitments, relationships and reputation in one direction. Strategy therefore involves choosing which experiments to run, not just running them well. A founder should test the assumptions that would change the most decisions if they proved false.
A forecast predicts a number. A gate commits to a decision. A gate states: what will be measured; after how much evidence; what result will cause something to be stopped; what result will cause it to be scaled. Forecasts invite self-deception, because a missed forecast can always be explained away. Gates force decisions, because the threshold was agreed before the result was known.
The case's build plan states: "no revenue forecasts are given here, on purpose." In their place it sets gates: What is checked When Stop or cut if Scale if An outbound message variant After 50 messages Positive replies below 5% 15% or more: becomes the default A tool page After 500 visits Visit-to-free-member below 2% Above 6%: build three sibling pages A community source After 10 answers No sign-ups Raise its priority Time across channels Monthly Lowest paid-customers-perhour channel loses half its time Give that time to the best channel • • • •
When Stop or cut if Scale if Volume across audiences Monthly Lowest paid-per-1,000visitors audience is cut Reallocate Price After 20 paying customers — Test a price 30% higher on new signups The plan describes these as "starting thresholds, tune them with real data". North-star measures. The plan names two: paid customers per hour of owner time, by channel; paid customers per 1,000 visitors, for inbound channels. Both are actionable. The first ties results to the scarcest input, owner attention. The second ties them to traffic quality rather than volume. Attribution built in. Every link carries a source tag, and each member's first and last touch are recorded at sign-up and purchase. Without attribution, gates cannot be applied, because no one knows which channel produced which result. Gates in the cockpit. The owner's console has a Gates tab that calculates each gate's current state and recommends a decision. The decision remains the owner's. At the end of the period studied, no gate had been reached. The business had not launched, so there was no evidence to judge. The gates are commitments made in advance, which is exactly their point.
Write a Gate Card for every experiment before it starts: Field Content Assumption The belief being tested, stated so that it could be false Measure One actionable metric, tied to the assumption Sample How much evidence before judging (visits, messages, days) Stop threshold The result that ends or cuts the experiment Scale threshold The result that makes it the default or expands it • •
Content Decision date When the gate will be judged, whatever the sample Decider Who makes the call Then apply a vanity filter to every number you report. For each, ask: What decision would change if this number doubled or halved? Is it a ratio tied to an action, or a total that can only rise? Would I report it if it fell? If the answer to the first question is "none", stop reporting the number.
Are small samples meaningful? Fifty messages or ten answers are small samples. A gate judged on them may reflect chance. Is it better to decide on weak evidence or wait for strong evidence and lose time? Do gates kill good ideas too early? Some products and channels take time to work. Search, the plan admits, takes months. A strict gate may cut a slow but valuable channel. Can a founder be scientific about their own business? Camuffo's training improved decisions, but the founder still interprets the evidence. Is a precommitted threshold enough protection against motivated reasoning? No forecasts at all? Investors, partners and lenders often ask for forecasts. Is refusing to forecast principled, or a way of avoiding accountability?
Which numbers does your team report every week? Which would survive the vanity filter? What assumption, if false, would change the most decisions in your business? Are you testing it? When did your business last stop something because the evidence said so? What would your north-star measure be, if it had to involve your scarcest input? 1. 2. 3. • • • • 1. 2. 3. 4.
Can you tell which channel produced each of your last ten customers?
Write Gate Cards for your three most important current experiments. Apply the vanity filter to your weekly report and remove one number. Check your attribution: trace your last five customers to their first touch. Fix any gap. 5. 1. 2. 3.
Opening question. If constraints decide much of a business's design before strategy begins, what is left for strategy to do? Earlier chapters made a strong claim. In the case business, 21 of 24 major design decisions followed from stated constraints or provider rules (Chapter 4). If that is typical of constraint-native businesses, then much of what is usually called strategy has already been decided by the time a strategist arrives. This chapter asks what remains, and argues that what remains is the most important part: the choices about trust, learning and identity that no constraint can make.
Porter (1996) distinguished strategy from operational effectiveness. Operational effectiveness means doing the same things better than rivals, and it is necessary but rarely enough, because good practices spread. Strategy means choosing to do different things, or the same things differently, and accepting trade-offs: choosing what not to do. Its durability comes from the fit among many activities, which is harder to copy than any single one. Much of what constraint-native design produces is operational effectiveness: lean data storage, efficient models, careful sending. Any competitor can learn these practices. Strategy has to come from elsewhere.
Rumelt (2011) described the "kernel" of good strategy in three parts: a diagnosis that identifies the critical challenge; a guiding policy for dealing with it; a set of coherent actions that carry out the policy. • • •
Bad strategy, he argued, often skips the diagnosis, mistakes goals for strategy, or lists actions that do not cohere.
Gans, Stern and Wu (2019) adapted strategy for new ventures. They argue that an entrepreneur faces choices along four dimensions: customer: whom to serve; technology: what to build on; organisational identity: what kind of firm to be; competition: whether to compete against or co-operate with incumbents. Many paths are open at the start. Choosing one forecloses others, because commitments, relationships and reputation accumulate in one direction. Testing every path is impossible. Strategy is the choice of which path to commit to. Casadesus-Masanell and Ricart (2010) add that strategy is the contingent plan for choosing a business model, and the business model is the realised result. Teece (2010) adds that strategy is what protects a business model from imitation.
Constraints remove options. A zero budget removes paid advertising. A platform's terms remove automation of its network. A headroom rule removes heavy free use. These removals make strategy easier in one sense: fewer options to consider. They make it harder in another, because the options that remain are open to anyone facing the same constraints. Every bootstrapped founder on the same free tiers faces the same limits. What constraints cannot decide are choices about: Trust: how the business will earn the belief of strangers. Learning: how it will discover what works and change accordingly. Identity: what kind of business it will be, and what it will refuse to do. • • • • • • •
The case can be described with Rumelt's kernel. Diagnosis. The market is flooded (Chapter 1). The business has no audience, no reputation and no cash. Its buyers cannot tell a good provider from a poor one before buying. The critical challenge is earning a stranger's trust without an audience or a budget. Guiding policy. Prove value before asking for anything. Design every activity within the constraints, with headroom. Automate everything reversible and private. Keep the owner on the actions that affect other people.
the free instant audit; outreach with proof attached; a methodology verifiable against the code; a ladder in which every rung extends the same proof; a quota governor; an autonomy boundary; a cockpit that ranks what needs a person; gates in place of forecasts. The three decisions that constraints did not explain (Chapter 4) are revealing: A public methodology generated from the scoring code is a trust choice. It makes the proof verifiable. A 30% recurring partner programme for agencies is a competition choice in Gans and colleagues' sense: co-operating with agencies that might otherwise compete, and borrowing their trust. Gates instead of forecasts is a learning choice. Strategy, in the case, was concentrated in exactly the areas that constraints leave open. • • • • • • • • • • •
The case also shows identity choices that are constraints in form but strategic in substance. The refusal to automate a professional network is required by its terms. The commitment to unsubscribe and deletion links on every message is required by law. Yet the decision to apply the same standards everywhere, including where no rule demands it, is a choice about what kind of business to be. Examples are honest status labels, hashed suppression that survives deletion, positive-only leaderboards, and never revealing who requested a comparison. What the case cannot show is whether this strategy works. That depends on whether strangers find the proof credible, which the business had not yet tested.
Write your strategy in five parts: Part Question Note Constraint ledger summary Which options have constraints already removed? From Chapter 4; list them so no one wastes time on them Diagnosis What is the critical challenge that remains? Usually about trust, attention or learning Guiding policy What approach will you take to that challenge? One or two sentences; must imply trade-offs Coherent actions Which actions carry out the policy, and how do they reinforce each other? Check fit: each should strengthen the others Open choices On trust, learning, identity and competition, what have you chosen that no constraint required? This is where your strategy is distinctive Then test it. Could a competitor facing the same constraints write the same kernel? If so, look again at the open choices. That is where difference must come from.
Is constraint-native design anti-strategic? If constraints decide most of the design, businesses facing the same constraints will look alike. Does constraintnative design lead to sameness? •
Are identity choices strategy? Some argue that ethical standards are not strategy but simply conduct. Others argue that in a market of strangers, a reputation for conduct is the most durable advantage. Commitment before evidence. Gans and colleagues argue that entrepreneurs must commit before they can test everything. The case commits to a proof-first strategy before any market evidence. Is that brave or reckless? Can strategy be protected? Teece argues that strategy protects a business model from imitation. What in the case is hard to imitate? Perhaps nothing yet, apart from its accumulated audits, reputation and partner relationships, none of which existed at the end of the period studied.
Which options in your business have constraints already removed? Does everyone on your team know? What is the critical challenge your business faces? Write it in one sentence. What have you chosen about trust, learning or identity that no rule required? Could a competitor facing the same constraints copy your strategy? What would stop them? Where in your business are you co-operating with potential competitors? Where should you be?
Write your Constraint-Native Strategy Kernel. Ask a colleague to identify which of your coherent actions do not reinforce the others. Remove or change one. Write down three things your business will refuse to do, even where no rule forbids them. • • • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. A business built entirely on other companies' free services owns almost nothing. How should it think about the risks of that dependence, and what can it do about them? The constraint-native business borrows almost everything: compute and storage from a cloud provider; checkout from a merchant platform; email capacity from free mailboxes; AI from model providers; distribution from social networks, marketplaces and communities; automation minutes from a code-hosting platform. This is what makes it possible to start with no cash. It also means that the business depends, at every point, on decisions made by others for their own reasons. This chapter examines that dependence and offers a way to manage it.
Platform research is clear that dependence carries risk. Zhu and Liu (2018) found that Amazon was more likely to enter product categories where third-party sellers had already proved demand. The platform used its position to capture value its complementors had created. Cennamo and Santaló (2013) show that platform markets involve strategic trade-offs, and that platforms' choices reshape the opportunities open to the businesses that depend on them. Hagiu and Wright (2015) emphasise that a multi-sided platform's sides are affiliated with it. They depend on the platform's continued willingness to host them. • • • • • •
For a small business, the risks of borrowed infrastructure take several forms: Terms change. A free tier is reduced, a fee is raised, or a rule is added. Access is withdrawn. An account is suspended, often by an automated system, sometimes without a clear reason or appeal. Capability changes. An interface is retired or a model is replaced. Coupling. Problems in one dependency cascade into others. Eligibility. A service is unavailable in the owner's country, or requires documents the owner cannot provide.
Free tiers exist because providers expect some free users to become paying ones, or to bring paying ones. They are a promotion, not a commitment. A business that builds on a free tier should assume that its terms will change, and design so that a change is an inconvenience rather than a catastrophe. This is one reason the headroom rule (Chapter 16) matters. A business at 20% of a free allowance can absorb a halving of that allowance without noticing. A business at 90% cannot.
The case's build plan lists its main dependency risks and responses. Among them: The mailbox's access token expires or is revoked. A warning banner appears in the console's Health tab, there is a one-click reconnect, and the email queue pauses safely rather than failing. Mailbox limits or deliverability problems. A budget with priority classes, a cap on cold email, immediate opt-outs, and a plan to move to a business domain and paid mailbox later. A marketplace rejects the app. Follow each store's rules (for example, the website-plugin directory's ban on trialware and the e-commerce platform's billing rules), ship small, then add. A community bans the business for self-promotion. Answer in full first, follow each community's rules, post by hand, and cap links per community. • • • • • • • • •
owner's country. Skip it, or ship as an unlisted download with a bookmarklet alternative. Publishing data about named companies. Aggregated, anonymised data only. Domain reports are kept out of search engines unless claimed, and leaderboards are positive-only. The built system adds further safeguards: AI has a fallback chain: the cloud provider's model, then a second free provider, then fixed templates. No single model provider can stop the business from working. Email has two lanes on different providers, each with its own reputation and its own automatic pause. The merchant platform's member data is mirrored in the business's own database, which supports an exit if needed (Chapter 9). The distribution engine is credential-gated, so losing one account disables one rail, not the engine. The case also shows two forms of dependence that are easy to overlook. Identity dependence. At the end of the period studied, the business had no domain of its own. It ran on a subdomain provided by its cloud host, and its public address belonged to the provider. A domain costs about $10 a year. The plan treats it as the one unavoidable cost, deferred under the zero-budget constraint. Coupling with a sister venture. The distribution engine was ported "as is" from a sister business owned by the same owner. Its second mailbox was, at the owner's choice and as a temporary measure, shared with that sister business. Shared code means shared defects. A shared mailbox means a shared reputation: a problem caused by one business's sending would pause the other's lane too. Coupling of this kind is cheap and convenient, and it is a dependence like any other.
List every external dependency in a register: • • • • • •
Dependency Function it performs What if terms change? What if access is lost? Early warning signal Fallback Exit cost (time) e.g. cloud free tier Compute, database Headroom absorbs up to 5× reduction Business stops Provider announcements; usage vs budget Paid tier ($5/ month) 1 day e.g. merchant platform Checkout, billing Fee rise reduces margin No new sales Webhook failures Mirrored member data; alternative processor 1–2 weeks e.g. free mailbox Email Lower cap Email stops Bounce and lock signals Second lane Hours … Then calculate two things: Concentration. How many critical functions depend on a single provider? In the case, the cloud provider hosts compute, database, AI and the public address. That is high concentration. Unhedged dependencies. Which dependencies have no fallback? Prioritise building one for the dependency with the highest exit cost. Review the register whenever a provider announces a change, and at least quarterly.
Is dependence avoidable? Every business depends on others: landlords, banks, suppliers. Is dependence on platforms different in kind, or only in degree? Concentration or diversity? Using one provider for everything is simpler and often cheaper. Spreading across providers reduces concentration but adds complexity, which can itself cause failures. Where is the balance? Free tiers and fairness. Building a business on a free tier designed to attract paying customers might be seen as taking advantage of the provider. Or it 1. 2. • • •
might be exactly the use providers intend: small businesses that will pay once they grow. Sharing between ventures. An owner with several businesses may share code, mailboxes or accounts between them to save effort. When is that sensible, and when does it couple their fates too tightly?
List the five external services your business could not operate without. Which has no fallback? What would happen if your most important free tier were halved tomorrow? Is your business's public address, its domain and its accounts, owned by you or by a provider? Do any of your businesses or projects share infrastructure? What would a failure in one do to the other? Which dependency would take longest to replace? What would replacing it involve?
Complete a Dependence Register with at least eight rows. Identify your most concentrated provider and your highest-exit-cost dependency. Write a fallback plan for one of them. If you do not own your domain, consider whether the cost of owning one is worth the independence it buys. • 1. 2. 3. 4. 5. 1. 2. 3.
Opening question. How can a founder, director or strategist put the ideas of this book to work in their own business, in a defined period, without trying to do everything at once? This book has offered a set of ideas and frameworks. Ideas change nothing until they are applied. This chapter sets out a ninety-day programme for applying them, organised into six two-week sprints, each with a clear output. It is written for an existing business or one about to start. It can be followed by one person or by a small leadership team. The programme follows one principle from the case: constraints first, then proof, then governance, then learning. It does not require building anything new. Most of its work is writing things down, deciding and checking.
Choose a programme owner, the person accountable for completing it. Agree a fixed weekly time budget for the programme, for example three hours. Treat that budget as a constraint in its own right. Decide where outputs will be kept so that they can be reviewed at the end.
Aim: know what bounds the business. Run the Flood Test (Chapter 1) for your market. Complete the Scarce Inputs Ledger (Chapter 2), with a weekly budget for owner attention. Build the Constraint Ledger (Chapter 4) with at least eight rows, including one provider rule, one platform rule, one legal rule and one self-imposed rule. • • •
Record current utilisation for every hard constraint and flag anything above 50%. Output: a two-page constraints brief. Checkpoint question: which options have constraints already removed?
Aim: see the business as a system, and find its proof. Draw the Activity System Map (Chapter 3), marking governance (owner, software, platform, customer) for each activity. Design one piece of proof and score it on the Proof Signal Test (Chapter 5). Rewrite your main landing page or first outreach message in the give–explain– offer sequence. Output: an activity map and one proof, tested for accuracy on at least ten real cases. Checkpoint question: what is the hub of the system, and does the proof start there?
Aim: arrange what is free and what is paid. Complete a Free Tier Design Sheet (Chapter 6) for each free offer and fix the worst warning sign. If you serve several audiences, complete the Engine–Audience Matrix (Chapter 7) and write a kill criterion for each audience. Rewrite your pricing as a Proof-First Value Ladder (Chapter 8), and calculate effective payment fees at each price. If you use a merchant platform, complete the Commerce Offloading Canvas (Chapter 9), including an exit plan. Output: a one-page offer architecture. Checkpoint question: does every paid rung extend the same proof? • • • • • • • •
Aim: decide how customers will find you, and protect the channels you borrow. Run the Flower Audit (Chapter 10) and address the weakest part. Complete an Inbox Ledger (Chapter 11) for each sending lane, and run the bounce test. List every channel in the Armed-Dormant Capacity cycle (Chapter 12) and write the account checklist. Map one outbound motion onto the Signal–Proof–Human loop (Chapter 13). Draw a Loop Map (Chapter 14) for your strongest loop and add source tags to every published link. Output: a distribution plan with an account checklist and attribution in place. Checkpoint question: which accounts or permissions are the real bottleneck?
Aim: make the business safe to run with little supervision. Complete the Autonomy Boundary Matrix (Chapter 15) for every action your systems take, and check the code's gates against it. Set a headroom ratio for your three most important resources, compare your own meter with your provider's, and write a degradation plan (Chapter 16). Complete a Meter-Level Unit Economics Sheet (Chapter 17) and record your upgrade triggers. Start a review log and calculate the verification debt measures (Chapter 18) for one review pass. Run the three purchase-moment scenarios (Chapter 19) and the Cockpit Review (Chapter 20). Output: a governance pack: matrix, headroom table, degradation plan, review log and cockpit changes. Checkpoint question: what irreversible action could your systems take today without a sufficient gate? • • • • • • • • • •
Aim: decide how you will learn, and what your strategy is. Write Gate Cards (Chapter 21) for your three most important experiments, and apply the vanity filter to your weekly report. Complete a Dependence Register (Chapter 23) and write one fallback plan. Write your Constraint-Native Strategy Kernel (Chapter 22), including three things you will refuse to do. Assemble everything into a Constraint-Native Business Model Canvas (Chapter 25). Output: a canvas, a strategy kernel and a calendar of gate dates for the next quarter. Checkpoint question: could a competitor facing the same constraints write the same strategy?
The case business compressed its own construction into three days. Its plan for launching was spread over five weeks of waves: Foundations in days 0–2. The product and first tool pages in week 1. The cockpit, outbound seed and communities in week 2, the first launch wave. Monetisation and loops in week 3, the second wave. Search depth and data reports in week 4. Marketplace apps in week 5, the third wave. The order matters more than the speed. Constraints and proof came first, governance was built in from the start, and gates were set before any data existed. • • • • 1. 2. 3. 4. 5. 6.
At the end of the period studied, the case had completed the equivalent of Sprints 1, 2, 3 and 5. It had built much of Sprint 4 but not activated it, because the accounts did not exist. It had set the gates of Sprint 6 but not reached them. Like most businesses, it was strongest in what it could do alone and weakest in what depended on others.
Ninety days or nine? The case built a business in three days. Is a ninety-day programme too slow for a world where building is cheap? Or is the slowness the point, because the scarce inputs (attention, trust, accounts) cannot be rushed? Paperwork or progress? Much of this programme is writing things down. Some founders will see it as bureaucracy. When does structured thinking pay for itself, and when does it delay action? Order of sprints. The programme puts governance after distribution. An argument could be made for governance first, especially in businesses that already act autonomously. One person or a team? The frameworks were drawn from a one-owner business. Do they transfer to teams, where attention is shared and decisions are distributed?
Which sprint would make the most difference to your business right now? Why? What weekly time budget can you realistically protect for this programme? Which outputs would you share with your board, investors or partners? What would make you stop the programme early, and would that be a success or a failure? Who in your organisation should own each sprint? • • • • 1. 2. 3. 4. 5.
Put the six sprint start dates in your calendar, with the programme owner's name against each. Complete Sprint 1 in the next fourteen days. At day 90, run the Flood Test and the Scarce Inputs Ledger again, and compare them with your day-one answers. 1. 2. 3.
T O O L K I T
The Tight Bucket
This chapter collects the frameworks of the book in one place, in the order a business would normally use them. Each entry gives the framework's purpose, its core questions, the chapter where it is explained, and the common mistake it guards against. The chapter ends with the Constraint-Native Business Model Canvas, which brings the most important frameworks together on one page, completed for the case as an example. All frameworks are proposals drawn from one case and the research cited in each chapter. They are tools for thinking and testing, not proven laws.
1. The Flood Test (Chapter 1) Purpose: judge how crowded a market will become when building is cheap, and how much the business holds that cannot be built quickly. Core questions: Could a competent person rebuild our product in a month? Are buyers flooded with offers? Can our value be shown, not described? Do we hold an asset that cannot be built quickly? Guards against: entering a crowded market with nothing that holds attention. 2. The Scarce Inputs Ledger (Chapter 2) Purpose: budget the five inputs that limit a business when building is cheap: attention, trust, borrowed reputation, verification capacity, and permissions and accounts. Core questions: What is our stock of each? What consumes it? What replenishes it? What is our weekly budget? Guards against: treating building as free while overspending what building consumes. • • • • • •
3. The Activity System Map (Chapter 3) Purpose: describe the business as linked activities, with their governance. Core questions: Which activities create, deliver and capture value? How are they linked? Who or what performs each: owner, software, platform or customer? Where is the hub? Guards against: mistaking a feature list or price list for a business model. 4. The Constraint Ledger (Chapter 4) Purpose: record every rule that bounds the business as a design input. Fields: source; type (hard, soft, self-imposed); metric; budget; owner; review date. Rules: write it before the value proposition; expect discoveries; give selfimposed constraints full standing. Guards against: discovering constraints in production.
5. The Proof Signal Test and give–explain–offer (Chapter 5) Purpose: check that a free diagnostic works as a credible signal, and order every first contact so that proof comes first. Criteria: specific; correct; verifiable; cheap for us; costly to fake; valuable alone. Correctness is disqualifying if weak. Guards against: pitches that ask for trust, and proof that is wrong. 6. The Free Tier Design Sheet (Chapter 6) Purpose: size each free offer to its job and its resource cost. Lines: job (signal, qualify, permission); cost per use in provider units; ceiling; upgrade trigger; paid extension. Warning signs: no trigger; no experience; no ceiling. Guards against: free tiers that are too generous, too stingy or unbounded. • • • • • • • • • • • • • •
7. The Engine–Audience Matrix (Chapter 7) Purpose: decide whether several audiences can share one engine. Rows: engine use; language; proof; channel; revenue model. Guards against: serving many audiences because building is cheap, while content, channels and attention are not. 8. The Proof-First Value Ladder (Chapter 8) Purpose: arrange the offer so that each rung extends the same proof. Rungs: instant proof; saved proof; recurring proof; delegated proof; done-foryou. Tests: extension; step; fee; model. Guards against: feature creep and incoherent pricing. 9. The Commerce Offloading Canvas (Chapter 9) Purpose: decide what to hand to a merchant platform and how to manage the dependence. Boxes: offloaded; retained; events to interpret; cost; exit plan. Guards against: silent errors in interpreting platform events, and dependence with no exit.
10. The Flower Audit (Chapter 10) Purpose: diagnose inbound pull. Parts: nectar (instant value); scent (findability); colour (shareable artefacts); pollination (users bring users); gardener (owner time). Guards against: building more tools when the real gap is findability or shareability. 11. The Inbox Ledger (Chapter 11) Purpose: treat email capacity as a stock and reputation as a depletable asset. • • • • • • • • • • • • • •
Items: refill; cap; allocation; priority; reputation signals; breakers; legal requirements. Test: send a known bounce and check that it is recorded. Guards against: spending reputation without seeing it. 12. The Armed-Dormant Capacity cycle (Chapter 12) Purpose: build channels ahead of accounts, and report their state honestly. Stages: build; arm; dry run; label; activate; park or keep. Keep an account checklist alongside. Guards against: dashboards that show capacity as active when it is waiting. 13. The Signal–Proof–Human loop (Chapter 13) Purpose: design outbound that is relevant, credible and safe. Steps: signal (why now); proof (why you); touch (capped, within platform terms); reply (by a person); gate (judged in advance). Guards against: untargeted, claim-based and fully automated outreach. 14. The Loop Map (Chapter 14) Purpose: design loops and partner programmes that bring users. Steps: trigger; artefact; audience; return path; measure; and for partners, reputation at risk. Guards against: expecting loops to create traffic rather than amplify it.
15. The Autonomy Boundary Matrix (Chapter 15) Purpose: decide which actions a machine takes alone. Axes: reversibility × externality. Quadrants: automate; automate with gates; prepare for a person; human only. Check: do the code's actual gates match each action's quadrant? Guards against: irreversible, third-party-facing actions triggered by classifiers or keywords. • • • • • • • • • • • • • • • • •
16. Headroom, Utilisation and the four-step Governor (Chapter 16) Purpose: keep an autonomous business within its quotas. Definitions: headroom ratio H = budget ÷ allowance; observed utilisation U = the higher of own and provider measures ÷ allowance; rule U ≤ H. Steps: measure; cross-check; pace; degrade. Guards against: self-meters that undercount, especially during construction. 17. The Meter-Level Unit Economics Sheet and the Zero-Cash Operating Model (Chapter 17) Purpose: measure unit costs in the provider's units, and define when a business can run with no cash. Five conditions: fixed costs on free tiers with headroom; variable costs linked to success; unit costs in provider units; owner attention as the binding budget; explicit upgrade triggers. Guards against: hidden consumers that no dollar figure reveals. 18. Verification debt measures and practices (Chapter 18) Purpose: measure and pay down the liability created by building faster than anyone can check. Measures: review yield; decay ratio; silent share; third-party share; drift share. Practices: read line by line; one test per finding; propagate decisions. Guards against: silent defects and residues of changed decisions. 19. The Purchase Moment Design (Chapter 19) Purpose: give each paying customer a working space at the moment of purchase. Parts: trigger; container; handover; capacity; expansion; exit. Test with the 3 a.m. buyer, the cancelling buyer and the deleting member. Guards against: onboarding that waits for the owner. 20. The Cockpit Review (Chapter 20) Purpose: make the owner's console spend attention well. • • • • • • • • • • • • • • •
Principles: today first; exceptions, not activity; honest states; switches within reach; law and safety as settings. Guards against: asking the owner to watch rather than to act.
21. The Gate Card and the vanity filter (Chapter 21) Purpose: replace forecasts with decisions committed in advance. Fields: assumption; measure; sample; stop threshold; scale threshold; decision date; decider. Vanity filter: what decision would change if this number doubled or halved? Guards against: motivated reasoning and numbers that only feel like progress. 22. The Constraint-Native Strategy Kernel (Chapter 22) Purpose: locate strategy in the choices constraints cannot make. Parts: constraint ledger summary; diagnosis; guiding policy; coherent actions; open choices on trust, learning, identity and competition. Guards against: strategies that any competitor under the same constraints would write. 23. The Dependence Register (Chapter 23) Purpose: manage reliance on borrowed infrastructure. Columns: dependency; function; effect of term change; effect of lost access; early warning; fallback; exit cost. Calculate concentration and unhedged dependencies. Guards against: treating a free tier as a contract. 24. The ninety-day programme (Chapter 24) Purpose: apply the frameworks in six two-week sprints, from constraints to strategy. • • • • • • • • • • • • •
The Business Model Canvas (Osterwalder & Pigneur, 2010) describes a business in nine blocks. The Constraint-Native Business Model Canvas keeps those nine and adds three, so that constraints, capacity and autonomy appear on the same page as value and customers. Below, it is completed for the case, as designed at the end of the period studied. Block TightBucket (designed, pre-launch) Customer segments E-commerce merchants; SaaS founders; sales directors; agencies Value propositions Find where your website loses revenue, in seconds, with ranked fixes, and keep watching it Channels Free audit and tool pages; search and benchmark pages; marketplaces (merchant platform, e-commerce app store, plugin directory, browser extension); communities; proof-first email; network messages sent by the owner; partners and affiliates; armed-dormant social rails Customer relationships Self-serve; saved history; monitors and alerts; team workspaces at purchase; replies from the owner Revenue streams Subscriptions ($39, $149); store plan ($19, via marketplace billing); done-for-you sprints (from $300) Key resources Audit engine and check library; report and benchmark data; quota governor; cockpit Key activities Audit; monitor; collect signals; prepare outreach; triage replies; publish content; review and test Key partnerships Cloud provider; merchant platform; mailbox providers; marketplaces; agency partners; affiliates Cost structure Zero fixed cash cost; payment fees only on success (≈2.8%–6.0%); owner time; optional one-off listing and domain fees when channels are activated Constraint Ledger (added) Zero cash; checkout on merchant platform; free mailboxes (≈500/day; 15/hour); network forbids automation; no audience; ≤20% of every free quota; legal rules on marketing email Headroom and degradation plan (added) H = 0.2 on database reads and writes, AI units and automation minutes; background work 70%, paced; cached or deferred for anonymous users; paying customers never refused; AI falls back to second provider then templates
TightBucket (designed, pre-launch) Autonomy boundary (added) Automate: audits, scoring, monitoring, drafting. Gated: cold email. Prepared: network messages, replies, community answers. Human only: pricing, refunds, partners, sprint scoping. Owner time target ≈25 minutes a day (design target) The three added blocks connect to the original nine: The constraint ledger bounds key resources, channels and cost structure. The degradation plan protects customer relationships. The autonomy boundary decides how much of key activities a person performs. A business that cannot fill in the three added blocks has not yet finished designing its business model, however complete the other nine look. • • •
This guide is for anyone leading a discussion of this book: a reading-group host, a lecturer, a leadership-team facilitator or a founder working through it with advisers. It suggests formats, a session plan, ground rules and ways to make the discussion produce decisions rather than only conversation.
Five-session reading group (one part per session). Suitable for founders' circles, executive groups and boards. Each session takes 90 minutes. Participants read the part beforehand and complete one "Apply it" exercise from it. Twelve-session course (two chapters per session). Suitable for university modules in entrepreneurship, strategy or digital business. Each session pairs two related chapters. Students prepare a short written application to a business of their choice. Leadership-team workshop (two days). Suitable for a company redesigning its business model. Day one covers Parts I and II, ending with a draft Proof-First Value Ladder. Day two covers Parts III to V, ending with a Constraint-Native Business Model Canvas and a ninety-day plan. Solo founder with advisers (ninety days). Follow the programme in Chapter 24, and meet an adviser or peer at the end of each sprint to review its output.
Separate the case from the claim. The case is a single business before launch. When someone says "TightBucket shows…", ask whether the case shows a design, a measurement or an outcome. It shows the first two, not the third. Bring your own evidence. Every participant should be ready to say how a framework applies, or fails to apply, in a business they know. Disagree with the book. Each chapter's "Points of debate" section is there to be argued. A session in which everyone agrees has not done its job. 1. 2. 3.
End with a decision. Each session should end with each participant writing down one thing they will do, change or stop.
Opening (10 min): each participant states their Flood Test score and one sentence of evidence. Discussion (50 min): Is building really cheap, or has cost moved to maintenance? Which of the five scarce inputs binds most in the room's businesses? Does a self-imposed constraint such as a 20% headroom rule make sense outside software? Exercise (20 min): draft a Constraint Ledger in pairs, with each person interviewing the other. Close (10 min): one decision each.
Opening: participants share a piece of proof their business could give before asking for anything. Discussion: Signal or gift: is proof-first outreach a costly signal or a reciprocity tactic? When should a business give away more, and when less? Is a decoy ever acceptable? Who owns the customer when commerce is offloaded? Exercise: rewrite one participant's price list as a Proof-First Value Ladder, as a group. Close: one decision each.
Opening: each participant names the weakest part of their flower. Discussion: Is inbound realistic for a newcomer? Is cold email ever ethical, and under what conditions? Is building channels before accounts wise or wasteful? Where is the line between assisted and automated outreach? Exercise: map one outbound motion onto the Signal–Proof–Human loop and identify its weakest step. 4. • • • • • • • • • • •
Close: one decision each.
Opening: each participant names one irreversible action their systems take automatically. Discussion: Should the autonomy boundary move as AI improves? Why did the case's own meter undercount writes, and what does that teach about trusting internal figures? Can AI review AI? Is a password enough for an owner's console? Exercise: place ten actions from participants' businesses in the Autonomy Boundary Matrix, then argue about the borderline cases. Close: one decision each.
Opening: each participant shares a number they report that fails the vanity filter. Discussion: Should a new business refuse to forecast? If constraints decide most of the design, where does distinctiveness come from? How much dependence on platforms is acceptable? Exercise: each participant drafts their Constraint-Native Strategy Kernel, and a partner tests whether a competitor could have written it. Close: each participant commits to the start date of their own ninety-day programme.
Session Chapters Theme 1–2 The flood and the scarce inputs 3–4 Activity systems and constraint ledgers 5–6 Proof and the free tier 7–8 Audiences and pricing architecture 9–10 Borrowed commerce and inbound pull 11–12 Inbox physics and dormant capacity • • • • • • • • •
Chapters Theme 13–14 Outbound and loops 15–16 Autonomy and quotas 17–18 Unit economics and verification debt 19–20 Tenancy and the cockpit 21–22 Experiments and strategy 23–24, 25 Dependence, the programme and the canvas
Case memo (2,000 words). Apply three frameworks to a real business. Identify one point where the framework fails and propose an amendment. Proposition test design. Choose one of the seven propositions in the accompanying working paper and design a study that could test it, including the data needed and the ethical safeguards. Canvas critique. Complete a Constraint-Native Business Model Canvas for a well-known digital business from public information, and argue whether the three added blocks reveal anything the original nine conceal. Debate. Assign teams to argue each side of a "Points of debate" item, judged on use of evidence.
These questions work at the end of any format: Which single idea in this book would most change how your business operates, and what stands in the way of adopting it? Where does the book's argument depend on the case being a small, softwareonly business? Which ideas would survive in a business with staff, inventory or regulation? If AI keeps improving, which chapters will date first? Which will matter more? The case had no sales when this book was written. What evidence, gathered over the next year, would most strengthen or most weaken the book's argument? • • • • 1. 2. 3. 4.
What should a constraint-native business refuse to do, even when a constraint does not forbid it?
Facilitators should keep the case in proportion. It is valuable because its design is unusually well documented: in code, in a written plan, in a log of every defect found and in usage data. It is limited because it had not launched, was commissioned by the same owner who commissions this book, and was built in three days. Encourage participants to treat it as a worked example of design and governance, and to look to their own businesses, and to further research, for evidence about outcomes. 5.
Activity system. A business model described as a set of linked activities, performed by the firm, its partners or its customers, characterised by content, structure and governance (Zott & Amit, 2010). See Chapter 3. Affordable loss. In effectuation theory, the amount an entrepreneur is willing to lose on a venture, used instead of an expected return to decide whether to proceed (Sarasvathy, 2001). See Chapter 17. Armed but dormant. A channel or capability that is built and ready but activates only when a condition is met, typically when its account credentials are added. See Chapter 12. Attribution. Recording which channel, link or partner brought each visitor, member or customer, typically through source tags on links and first- and lasttouch records. See Chapters 14 and 21. Autonomy boundary. The line between actions a system takes alone and actions that require a person, drawn in this book by reversibility and externality. See Chapter 15. Bootstrapping. Starting and growing a business without outside capital, by minimising capital needs and generating cash early (Bhide, 1992; Winborg & Landström, 2001). See Chapter 4. Bricolage. "Making do" by combining resources at hand, including resources others consider worthless, to address new problems and opportunities (Baker & Nelson, 2005). See Chapter 4. Buying signal. Public information suggesting that an organisation may currently have a problem a business can solve, such as a job posting, funding announcement or community question. See Chapter 13. Cockpit. The owner's console in an autonomous business, designed to show what needs a person and to put the switches that stop harm within reach. See Chapter 20.
Commerce offloading. Transferring checkout, billing, tax and payouts to a merchant platform in exchange for a fee and some dependence. See Chapter 9. Complementor. A business that adds value to a platform's ecosystem and depends on that platform. See Chapters 9 and 23. Constraint-native. Designed with the business's hard, quantified constraints as starting material, recorded and budgeted before the value proposition is chosen. See Chapter 4. Constraint Ledger. A maintained register of the constraints on a business, each with a source, type, metric, budget, owner and review date. See Chapter 4. Cross-check. In the quota governor, comparing the business's own resource measurements with the provider's figures and using the higher. See Chapter 16. Decay ratio. In measuring verification debt, the number of findings in one review pass divided by the number in the previous pass. See Chapter 18. Decision drift. Residues of a changed decision that survive in code, copy, configuration or documentation after the change was implemented elsewhere. See Chapter 18. Decoy (asymmetric dominance) effect. The tendency for an added option that is clearly inferior to one alternative to increase the share choosing that alternative (Huber, Payne & Puto, 1982). See Chapter 8. Degrade, do not fail. The governing principle that when a resource budget is reached, service is reduced in planned ways, protecting the most important users, rather than stopping. See Chapter 16. Dry run. Operating a system in a mode that performs every step except the final external action, such as publishing or sending, so that its outputs can be inspected. See Chapter 12. Effectuation. A logic of entrepreneurial action that starts from available means rather than a fixed goal, and emphasises affordable loss, partnerships and leveraging surprises (Sarasvathy, 2001). See Chapter 4. Externality. In this book, the extent to which an action's effects fall on people outside the business, or on its legal and reputational position. See Chapter 15.
Freemium. A model in which a basic version of a product is free and enhanced versions are paid. See Chapter 6. Gate. A decision committed to in advance: a measure, a sample size, and thresholds at which something will be stopped or scaled. See Chapter 21. Headroom ratio (H). The share of a provider's allowance that a business allows itself to use; a policy choice. In the case, 0.2. See Chapter 16. Inbox physics. The model of email capacity as a stock with a daily refill, and of sender reputation as a slowly built, quickly drained asset. See Chapter 11. Jagged frontier. The uneven boundary of AI capability, inside which AI improves performance and outside which it can make performance worse, often without visible warning (Dell'Acqua et al., 2026). See Chapters 1 and 18. Lemons problem. The failure of a market in which buyers cannot distinguish quality, so that low-quality offers drive out high-quality ones (Akerlof, 1970). See Chapter 5. Lock-in. In activity-system theory, design features that keep customers and partners engaged (Zott & Amit, 2010). See Chapter 19. Loop. A mechanism by which use of a product creates artefacts that bring new users. Its yield is viewers per artefact multiplied by the fraction who become users. See Chapter 14. Meter. A mechanism that records resource consumption at the point where it occurs, in the provider's units. See Chapters 16 and 17. North-star measure. The single measure a business uses to judge progress. In the case, paid customers per hour of owner time. See Chapter 21. Observed utilisation (U). Resource use, taken as the higher of the business's own measure and the provider's, divided by the provider's allowance. See Chapter 16. One-click unsubscribe. A mechanism, defined in RFC 8058, by which a recipient's mail program can unsubscribe them from a list without visiting a website. See Chapter 11.
Pacing. Releasing a resource budget gradually across a period so that early activity cannot consume the whole allowance. See Chapter 16. Parallel play. A pattern in which ventures in a nascent market learn from peers without treating them as rivals, test assumptions and postpone committing to a single business model (McDonald & Eisenhardt, 2020). See Chapter 7. Proof-first. Giving a prospect a specific, verifiable demonstration of value concerning their own situation before making any request. See Chapter 5. Rail. In the case, one publishing channel in the distribution engine, such as one account on a social scheduling service or one direct platform connection. See Chapter 12. Reversibility. The extent to which an action's effects can be undone cheaply and completely. See Chapter 15. Serverless computing. Running code without provisioning or managing servers, paying only for use (Jonas et al., 2019). See Chapter 1. Signal (costly signal). An action that conveys hidden information because it costs high-quality senders less than low-quality ones (Spence, 1973). See Chapter 5. Silent defect. A defect that does not cause a visible failure; the system runs and does something plausible but wrong. See Chapter 18. Suppression list. A permanent record of addresses that must not be contacted. In the case, it is stored as one-way hashes so that it survives deletion of personal data. See Chapter 11. Tenant. A customer whose data and settings are kept separate from other customers' within a shared system. See Chapter 19. Third-party share. In measuring verification debt, the proportion of findings whose effects would reach people outside the business. See Chapter 18. Vanity metric. A number that rises and feels like progress but does not inform a decision (Ries, 2011). See Chapter 21. Verification debt. The stock of artefacts produced by a business whose behaviour has not been checked against the owner's current intent. See Chapter 18.
Webhook. An automated, usually signed, notification sent by one system to another when an event occurs, such as a payment or cancellation. See Chapters 9 and 19. Zero-Cash Operating Model. Five conditions under which a digital business can operate with no cash outlay: fixed costs on free tiers with headroom; success-linked variable costs; unit costs in provider units; owner attention as the binding budget; explicit upgrade triggers. See Chapter 17. Zero-price effect. The disproportionate attraction of a free offer compared with a low-priced one (Shampanier, Mazar & Ariely, 2007). See Chapter 6.
Works are cited in the text by author and year. Digital object identifiers (DOIs) were checked against Crossref in October 2026. Provider terms, prices and limits are as published in October 2026 and will change.
Acar, O. A., Tarakci, M., & van Knippenberg, D. (2019). Creativity and Innovation Under Constraints: A Cross-Disciplinary Integrative Review. Journal of Management, 45(1), 96–121. https://doi.org/10.1177/0149206318805832 Agrawal, A., Gans, J. S., & Goldfarb, A. (2019). Artificial Intelligence: The Ambiguous Labor Market Impact of Automating Prediction. Journal of Economic Perspectives, 33(2), 31–50. https://doi.org/10.1257/jep.33.2.31 Akerlof, G. A. (1970). The Market for "Lemons": Quality Uncertainty and the Market Mechanism. The Quarterly Journal of Economics, 84(3), 488–500. https://doi.org/ 10.2307/1879431 Amit, R., & Zott, C. (2001). Value creation in E‐business. Strategic Management Journal, 22(6-7), 493–520. https://doi.org/10.1002/smj.187 Bainbridge, L. (1983). Ironies of automation. Automatica, 19(6), 775–779. https://doi.org/ 10.1016/0005-1098(83)90046-8 Baker, T., & Nelson, R. E. (2005). Creating Something from Nothing: Resource Construction through Entrepreneurial Bricolage. Administrative Science Quarterly, 50(3), 329–366. https://doi.org/10.2189/asqu.2005.50.3.329 Bhide, A. (1992). Bootstrap finance: The art of start-ups. Harvard Business Review, 70(6), 109–117. Brynjolfsson, E., Li, D., & Raymond, L. (2025). Generative AI at Work. The Quarterly Journal of Economics, 140(2), 889–942. https://doi.org/10.1093/qje/qjae044 Camuffo, A., Cordova, A., Gambardella, A., & Spina, C. (2020). A Scientific Approach to Entrepreneurial Decision Making: Evidence from a Randomized Control Trial. Management Science, 66(2), 564–586. https://doi.org/10.1287/mnsc.2018.3249 Casadesus-Masanell, R., & Ricart, J. E. (2010). From Strategy to Business Models and onto Tactics. Long Range Planning, 43(2-3), 195–215. https://doi.org/10.1016/ j.lrp.2010.01.004
Rumelt, R. P. (2011). Good strategy/bad strategy: The difference and why it matters. Crown Business. Sarasvathy, S. D. (2001). Causation and Effectuation: Toward a Theoretical Shift from Economic Inevitability to Entrepreneurial Contingency. Academy of Management Review, 26(2), 243–263. https://doi.org/10.2307/259121 Shampanier, K., Mazar, N., & Ariely, D. (2007). Zero as a Special Price: The True Value of Free Products. Marketing Science, 26(6), 742–757. https://doi.org/10.1287/ mksc.1060.0254 Shapiro, C., & Varian, H. R. (1999). Information rules: A strategic guide to the network economy. Harvard Business School Press. 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. Spence, M. (1973). Job Market Signaling. The Quarterly Journal of Economics, 87(3), 355– 374. https://doi.org/10.2307/1882010 Teece, D. J. (2010). Business Models, Business Strategy and Innovation. Long Range Planning, 43(2-3), 172–194. https://doi.org/10.1016/j.lrp.2009.07.003 Tidhar, R., & Eisenhardt, K. M. (2020). Get rich or die trying… finding revenue model fit using machine learning and multiple cases. Strategic Management Journal, 41(7), 1245–1273. https://doi.org/10.1002/smj.3142 Winborg, J., & Landström, H. (2001). Financial bootstrapping in small businesses. Journal of Business Venturing, 16(3), 235–254. https://doi.org/10.1016/s0883-9026(99)00055-5 Zhu, F., & Liu, Q. (2018). Competing with complementors: An empirical look at Amazon.com. Strategic Management Journal, 39(10), 2618–2642. https://doi.org/ 10.1002/smj.2932 Zott, C., & Amit, R. (2010). Business Model Design: An Activity System Perspective. Long Range Planning, 43(2-3), 216–226. https://doi.org/10.1016/j.lrp.2009.07.004
These sources support the figures and rules quoted for providers, platforms and regulation, principally in Chapters 4, 8, 9, 11, 16 and 17. Cloudflare. (2026). D1 pricing; Workers limits; Workers AI pricing [Developer documentation]. https://developers.cloudflare.com/ (accessed October 2026). Federal Trade Commission. (n.d.). CAN-SPAM Act: A compliance guide for business. https://www.ftc.gov/business-guidance/resources/can-spam-act-compliance-guidebusiness (accessed October 2026).