Every System Needs Two Owners: A Business Owner and a Builder
Every system needs one person who owns its result and one who keeps it working. Why the pair matters more once AI agents do part of the work.
Short answer: Every system that runs part of a business, from the phone flow to an AI agent that books jobs after hours, needs two named roles. A business owner answers for what the system should produce and whether it is still worth running. A builder answers for whether it works, keeps working and can be changed safely. They answer different questions, so one name is not enough, and the gap matters more with AI, because AI systems can change after they are built. This is my operating principle, not a proven method: software teams have long separated these roles, but I found no published study that tests the pairing in small service companies. The strongest objection is real too: the people who build a system often run it best, so in a small company the two jobs can sit with one person, as long as both are written down.
An illustrative example, not company data: picture a home service company doing a few million dollars a year. Over five years it has collected systems: a call flow, a booking script, a price book, a follow-up text sequence, a reporting sheet, and now an AI agent that answers after-hours calls. Each was set up by someone. Some of those people have moved on. If you ask who decides what each system should do, and who fixes it when it breaks, the answers might be "the owner" for every system and "whoever set it up" for the second question.
In my previous essay I argued that one person should answer for every result, including the AI's part. That tells you who is accountable when an outcome is wrong. This essay asks two different questions: who decides what a system is for, and who keeps it working? The second name is the one most small companies never write down.
Two questions, two names
By a system I mean any repeatable way of getting work done: software, an automation, an AI agent or a written process. Every system faces two kinds of questions.
The first kind is about the business. What should this system produce? Is it still worth what it costs? What trade-off is acceptable: speed or accuracy, more bookings or fewer cancellations? Should it be allowed to do more on its own? These need someone who understands customers and money and can decide.
The second kind is about the system. Does it do what it was designed to do? Is it still doing it this week? What breaks if we change this step? How do we roll a change back? These need someone who understands how the thing is built.
The "business owner" answers the first set. In a small company that is often the person who owns the company, but it can be a manager who answers for bookings or collections. The "builder" answers the second set, and doesn't need to be a developer: for a written process, it is whoever maintains it; for an AI agent, whoever sets it up, tests it and changes it.
Business owner | Builder | |
|---|---|---|
Answers for | The result the system exists to produce | The system working as designed |
Decides | What it should do, what good looks like, when to stop or expand it | How it is built, how changes are made and tested |
Notices first | Results moving the wrong way | Errors, failures, changes from vendors |
Without them | A system that works well at the wrong thing | A system that slowly stops working and nobody knows why |
Where the idea comes from
The split is not new. The Scrum Guide, the short document that defines the Scrum framework for software teams, has a version of it. In the 2020 edition, the Product Owner "is accountable for maximizing the value of the product" and "is one person, not a committee." Developers are "the people in the Scrum Team that are committed to creating any aspect of a usable Increment each Sprint" and are accountable for instilling quality by adhering to a Definition of Done. One role answers for value; the other answers for what gets built.
AI risk guidance makes a similar demand without prescribing the pair. The AI Risk Management Framework published by the U.S. National Institute of Standards and Technology in January 2023 asks organizations to make sure that "roles and responsibilities and lines of communication related to mapping, measuring, and managing AI risks are documented and are clear to individuals and teams throughout the organization." It is a voluntary framework, not a law, and it doesn't say how many roles a company needs.
Neither document is evidence that the split works. They show that people who build complex systems found it useful to name value and construction separately.
Why AI makes the builder job permanent
A small company could once treat the builder as a one-time job: set up the phone system once, and it did roughly the same thing for years. AI weakens that in two ways.
First, the system can change even when nobody touches it. In a 2023 study, Lingjiao Chen, Matei Zaharia and James Zou compared the March 2023 and June 2023 versions of two widely used AI models on the same tasks. In one test, GPT-4's accuracy at telling prime from composite numbers fell from 84% to 51% between the two versions, while the other model improved on the same task. The authors concluded that the behavior of the "same" AI service "can change substantially in a relatively short amount of time" and called for continuous monitoring. The limits matter: these are 2023 models on test tasks, not a booking agent. What carries over is narrow: build on a model someone else updates, and your system can drift with no change on your side.
Second, AI systems carry ongoing maintenance costs. In a 2015 paper, D. Sculley and colleagues argued that it is "dangerous to think of" quick machine learning wins "as coming for free," and that real-world machine learning systems commonly incur "massive ongoing maintenance costs." Among the causes they list are tangled dependencies on data and configuration and "changes in the external world." That paper is about engineering teams building machine learning systems, not a small business renting an AI tool, and it argues from experience rather than measurement. But anyone connecting an AI agent to customer calls, a calendar and a price book faces the same direction of risk: each connection can break.
There is also a sign that AI is arriving without either owner. In Microsoft and LinkedIn's 2024 Work Trend Index, a survey of 31,000 people in 31 countries, 78% of AI users said they were bringing their own AI tools to work. Microsoft sells AI tools, so read this as a vendor survey of office workers, not home service crews. Still, a tool an employee brings in on their own was not chosen by the company, so there may be no business owner who decided to use it and no builder who checks it.
My inference from these sources, not a finding: with AI, the builder is not a project role that ends at launch. It is a standing responsibility, like maintaining a truck.
What I had to change in myself
What follows is my own story and my opinion.
At the end of last year I recorded a short video about a call with a coach I work with. I showed him our numbers, and he asked one question: why does all of this work now, when you had the same tools two years ago? That was when I realized it wasn't the strategy. It was me. I had stopped being the chief firefighter in the company and become the architect of the system. I stopped delegating tasks and started delegating results. I stopped searching for star people and started building a star system. By then, every part of the business had a leader with full responsibility for it.
Looking back, I see two jobs in that realization. One is the leader who owns the result of an area. The other is the person who designs and keeps up the system that area runs on. Before, I was the firefighter, the person every problem came back to. In the video I said the tools didn't change, I did; what changed, I now think, is who answered for what. That is my explanation, not a controlled test: other things changed in those two years too, and I can't separate them.
AI made the second job easier to start and easier to forget. Earlier this year I published another short video about building a working AI voice system myself, from idea to deployment, in about an hour, without being a developer. Its point was that the barrier to building has dropped. What the video didn't cover is everything after the first hour: who tests the system when the model behind it changes and who updates it when prices change. Building got cheap. Keeping it working is still work.
The principle I take from this: name the business owner and the builder for every system, separately, even when the same person holds both names.
The mechanism: why two names beat one
This is my working model, a hypothesis rather than an established method. Four reasons the pair should work better than one name.
They see different failure signals. A business owner notices when results move: more cancellations, fewer bookings, unhappy customers. A builder notices when the system moves: errors, slower responses, a vendor update, a connection that dropped. With only one name, half the early warnings have no reader.
Neither should grade their own work alone. A builder judging whether a system is worth it will tend to say yes, because they built it. A business owner judging whether a change is safe can't see what it might break. Two names create a natural check: the owner says what, the builder says how and whether it is safe.
Knowledge concentrates. Software engineers use the "truck factor": how many people would have to leave before a project stalls. Guilherme Avelino and colleagues estimated it for 133 popular projects on GitHub, using an automated method based on who wrote the code, and found that 65% had a truck factor of two or less (2016). Those are software projects, not small company workflows. But the risk carries over: a system that one builder understands is fragile, so part of the builder's job is writing down how it works.
Changes need two keys. For any system that touches customers or money, my rule would be: the business owner approves what changes, the builder approves how. Neither changes it alone. In my article on trust levels for AI I argued that how much an AI may do on its own should depend on how close the action is to the person accountable for it. In this model, that is the business owner's call; making the limit actually hold is the builder's job.
An illustrative example, not company data. A company runs an AI agent that answers after-hours calls and books jobs. The business owner is the person who answers for after-hours bookings; they decide which services the agent may book and when it must hand the caller to a person. The builder keeps its instructions, connections and test calls current. After a model update, the builder's routine test call shows the agent describing the service fee differently. The builder flags it; the business owner pauses booking for that service until it is fixed. With one name, either the change goes unnoticed or someone technical makes a business decision alone.
The strongest case against two owners
The best argument against this essay comes from Amazon's engineering culture. In a 2006 interview with ACM Queue, Amazon's chief technology officer Werner Vogels described the model of handing software "to the wall that separates development and operations" and forgetting about it, then said: "Not at Amazon. You build it, you run it." He said giving developers operational responsibility "greatly enhanced the quality of the services," and that it brought them into day-to-day contact with customers. If the builder also runs the system, the argument goes, splitting the roles recreates the wall.
Second, small companies don't have spare people. The owner may be the business owner and the builder of half the systems, and two names can add a coordination step where none is needed.
Third, two names can blur responsibility: when two people share something, each may assume the other has it.
The objection is strongest where one team has the skills and time for both jobs, as in Vogels' description, where each team is responsible for a service from scoping out the functionality to operating it. In my view, most small service companies don't have that team: the builder is often a vendor, a part-timer or the owner at night, and the bigger risk is not a wall between building and running but nobody doing the second job at all. So the thesis survives in a narrower form. The two names answer different questions; they are not two owners of the same decision, and for the business result there is still one decider. They can be the same person or the same team. What matters is that both questions are written down, someone is asked each of them on purpose, and the builder stays close to how the system is used, which is Vogels' real point.
When this fails
The system is small and cheap to replace. A one-off spreadsheet doesn't need the pair. Use it where customers, money or many people are touched.
The builder is far from the work. An outside vendor who never hears from customers will maintain the system against an outdated picture. Bring the builder close to how it is used.
The business owner has no authority. If the named owner can't stop, change or fund the system, the name is decoration.
Nothing is written down. If how the system works lives only in the builder's head, the truck factor is one.
Nobody budgets the builder's time. If maintenance is unpaid extra work, it will be skipped until something breaks.
The names never change. When people move roles, systems become orphans. Review the names when people change jobs.
What this changes for owners and investors
For owners. Make a list of the systems that touch customers or money and write two names next to each. Where you find the same name everywhere, usually your own, you have found where you are the bottleneck. Treat the builder role as ongoing work with time set aside, not a favor. This is about how responsibility is designed, not a staffing plan.
For investors and acquirers. For each critical system, ask three questions: who answers for its result, who keeps it working, and what happens if that builder leaves tomorrow? A company that relies on AI agents but can't answer the last two carries key-person risk the numbers won't show. As I argued in AI Flips the Org Chart, someone still has to own the result when AI does more of the work; the builder is the other half of that design.
How to test this in 30 days
Week 1: list the systems. Every system that touches customers, money or scheduling. Write who decides what each should do and who fixes it. Blanks and repeated names are your first finding.
Week 2: write two names per system. One business owner, one builder. For any system that talks to customers, write which changes need both of them.
Week 3: make each builder write one page. How it works, what it connects to, how to test it, how to roll back. Each business owner writes one paragraph: what good looks like.
Week 4: run a check. For one AI system, have the builder run a test after any vendor update, and have the business owner review the results. Count systems still without a builder.
You will know how many systems depend on one person, and whether anyone watches the ones built on AI.
Frequently asked questions
Who should own an AI agent or automated workflow in a company?
Two named roles with different jobs. A business owner answers for what the agent should produce, decides its limits and whether it is worth running. A builder answers for it working: setting it up, testing it after changes and fixing it. In a small company one person can hold both, but write both down. This is my recommended approach, not a validated standard.
Does a small home service company need a developer to have a builder?
No. The builder is whoever sets up, tests and maintains the system. For many AI tools that can be a capable office manager with time set aside, with help from the vendor.
What is supported, what is uncertain, what to test
Supported by the sources I cite: software frameworks such as Scrum separate accountability for value from accountability for building; AI risk guidance asks for documented, clear roles; the behavior of an AI service can change between versions on the same tasks; machine learning systems can carry large ongoing maintenance costs; and knowledge in software projects often sits with very few people.
My opinion: every system that touches customers or money should have a named business owner and a named builder, written separately even when one person holds both, and for AI systems the builder's job is permanent.
Uncertain: whether the pair improves results in small service companies, how much builder time an AI system really needs, and when the cost of coordinating two people outweighs the benefit. Test it on your most important AI system for a month first.
Building a system is now the easy part. Knowing who answers for its result, and who keeps it working, is the part that lasts.