He gave his notice at 9:40 in the morning and was perfectly decent about it. The problem was not that he left. The problem was that the subscription billing service had been his for two years, nobody else had merged a line into it since the previous March, and our renewal run was on the 28th of every month.
We had talked about this exact risk in planning meetings, in the abstract, the way you talk about a fire drill. We had even produced a document about it once. What we had never done was measure it, and so we did not know which of our systems carried the risk until the person carrying it was already working out his notice.
This is the method we used in the 90 days that followed, and have used twice more since on calmer terms. It is deliberately unambitious: it does not try to make everyone know everything, it does not require a documentation sprint, and it attaches every action to work that was going to happen anyway. The target is modest and achievable, which is why it survived contact with a delivery schedule.
What the Number Actually Measures
The bus factor of a system is the number of people who would have to become unavailable before that system could no longer be changed safely. It is sometimes called the truck factor or the lottery factor, and the grim framing is the point: it is about availability, not loyalty. A bus factor of one is not a statement about anybody’s commitment. It is a statement about where knowledge physically lives.
Two things make the number worse in a small Singapore team than the raw headcount suggests. The first is notice periods: one to two months is typical for a senior engineer here, and that is the whole window you get to move two years of context. The second is replacement lead time. If the answer to a departure is to hire, you are looking at a search, a notice period on the other side and, for a candidate who needs a pass, administrative weeks on top. By the time the replacement arrives, the knowledge has walked out of the building and the only remaining copy is the code.
So the goal is not to be ready to replace a person. It is to make sure that no single departure takes a system with it.
Step 1: Map Ownership From Evidence, Not From Memory
Ask a team who owns what and you will get an organisational chart. Ask the repository and you will get the truth, and the two disagree more than is comfortable.
Build one table. Rows are systems, defined as units a person would be paged for rather than as repositories. Columns are people. In each cell, put three facts from the last twelve months: who merged changes, who was paged for it, and who reviewed the merges. Commit history and your incident tool give you all three in an afternoon, and no interpretation is required at this stage.
Our table had eleven systems. Four had exactly one name in all three columns. One of those four was the billing service, which we would have told you confidently was shared because two engineers had touched it when it was built in 2024. Neither had merged into it since. Shared history is not shared ownership, and only the evidence version of the table makes that visible.
Step 2: Rank by Blast Radius, Not by Size
The instinct after step 1 is to fix every single owner system. Resist it, because spreading the effort evenly is how this work quietly dies in week three.
Score each system on what happens when it breaks and nobody available understands it. Money stops moving, customer data is exposed, the product is unusable, an internal process gets slower, or nothing much happens until Monday. Then multiply that against the bus factor you measured. A small, boring service that silently handles payment retries outranks a large internal admin tool with three contributors, every time.
| System | Bus factor | What breaks | Priority |
|---|---|---|---|
| Subscription billing | 1 | Revenue stops on the 28th | Fix first |
| Auth and sessions | 1 | Nobody can log in | Fix first |
| Data export pipeline | 1 | Two enterprise accounts notice within a day | Fix next |
| Internal admin tool | 1 | Support works around it | Accept for now |
| Mobile release tooling | 2 | Release slips a week | Monitor |
Three systems, chosen on purpose, and a written decision to tolerate the fourth. That last line matters more than it looks: an accepted risk is managed, while an unexamined one is just a surprise waiting for a resignation letter.
What we learned the hard way
Our first attempt was a documentation sprint. Two weeks, 40 pages, a wiki section everyone congratulated themselves about. When the billing service threw an unexpected error three months later, the engineer on call read the documentation, understood the architecture perfectly, and still could not ship a fix, because the thing that mattered was a deploy ordering quirk nobody had thought to write down. Documentation records what someone remembered to describe. The gap is always the part that only shows up when you have your hands on the system. We lost three weeks learning that the artefact is not the knowledge.
Step 3: Buy the Second Brain With the Next Real Change
This is the step that does the actual work, and it is almost embarrassingly simple. For each of your three systems, take the next genuine ticket that lands in it and assign it to a second engineer, with the current owner available for questions but not touching the keyboard.
Not a walkthrough. Not a brown bag session. A real change, with a real deadline, merged and deployed by the person who did not previously know the system. The owner’s job during this is to answer questions and to resist the overwhelming urge to take over at the 40 minute mark, which is harder than it sounds and worth saying out loud before you start.
Expect the ticket to take roughly 1.5 times as long. That is the entire visible cost of this method, and you will pay it about six times across a quarter. The first billing ticket we did this way took a day and a half instead of a morning. The second took a morning. By the third, we had two people who could change the billing service, which is the definition of the outcome we were after.
Step 4: Write the Runbook During the Incident, Not After
A runbook written in calm conditions describes the system as its author believes it to be. A runbook written at 11pm while the thing is actually broken describes the system as it is, including the step where you have to clear a cache before the migration will run.
So we moved the writing into the incident itself. Whoever is not driving keeps a running log in the incident channel: the command that was run, what it returned, what was ruled out, what finally worked. At the end, that log is the first draft, and it already contains the parts that a retrospective document always loses. Google’s SRE practice makes a similar case for the blameless postmortem as an artefact that captures what actually happened rather than what should have, and we run ours along the lines set out in our guide to blameless postmortems.
One rule makes the difference between a runbook and a wiki graveyard: if a runbook is used during an incident and turns out to be wrong, correcting it is part of closing the incident. Not a follow up ticket. Part of the close.
Step 5: Rotate the Pager and the Review Queue
Steps 3 and 4 move knowledge once. Steps 5 and 6 are what stop it collapsing back onto one person within six months, which is the default behaviour of every engineering team I have worked in.
Two mechanisms create knowledge as a side effect of work you already do. The first is being on call: nothing teaches a system like being responsible for it at an unsociable hour, which is also why rotations have to be humane to be sustainable, a point the SRE literature on on call makes at length. If you do not already have a rotation that works for a small team, building an on call rotation is the prerequisite for this step rather than an optional extra.
The second is code review. Most teams route reviews to the person who knows the system best, which is efficient this week and is precisely the mechanism that concentrates knowledge. Invert it for your three priority systems: the second engineer reviews, and the owner is added as an optional extra pair of eyes. Reviews get slower for a few weeks. That slowdown is the knowledge transfer, visible on a graph.
One person, one system, no backup
Tell us which systems carry a single name and what your delivery schedule looks like. We will help you sequence the cover, and shortlist pre-vetted engineers for the gap your map exposes.
Start with your mapStep 6: Hire for the Overlap, Not for a Duplicate
Sooner or later the map exposes a gap that pairing cannot close, usually because the system needs a skill exactly one person has and the rest of the team has no foundation to build on. That is a hiring problem, and it is worth being precise about what you are buying.
The reflex is to write a job description that describes the person you are afraid of losing. That reproduces the silo with a different name on it. Write instead for the overlap: the engineer whose depth is in the adjacent discipline and who is credible in the risky one. For our billing gap we did not hire a payments specialist. We hired a backend engineer with real payments exposure and a strong data background, because the data pipeline was our next single owner system and one hire covering two adjacent risks was worth more than a deeper match for one.
Interview for it specifically. A candidate who can describe a system they inherited badly documented, and how they got to the point of changing it safely, is telling you they can absorb an existing system, which is the actual job. We put that question in the first technical conversation and it has been more predictive than anything else we ask. If the gap is structural rather than circumstantial, size it properly first using engineering capacity planning and make the case with a headcount business case rather than an anecdote about a near miss.
Step 7: Put the Number in the Planning Cycle
Everything above decays. People change teams, new services appear, the engineer who learned billing in March spends Q4 on something else and quietly stops being a second owner. Without a scheduled recount, you are back to a map that describes last year.
Rebuild the table every quarter, from evidence, with one named owner for the exercise. It takes an afternoon once the queries exist. Report three numbers to whoever does planning: how many systems have a bus factor of one, how many of those have a high blast radius, and which single system you are fixing this quarter. Three numbers survive a planning meeting. A twelve column spreadsheet does not.
This also gives you a defensible answer when someone asks why a ticket took 1.5 times as long. Teams that track delivery and reliability together, in the manner of the DORA research programme, tend to find that this kind of work shows up as a small, temporary cost against a risk that was previously invisible, which is a much easier conversation than the one that starts with a resignation.
What I Would Do Differently
Beyond the documentation sprint, two things.
I announced the first pairing session as a bus factor exercise, which was honest and a mistake. The owner heard it as a statement about his replaceability and the second engineer heard it as homework. The framing that works is the ordinary one: this ticket is yours, he knows the system, ask him anything. The resilience is the by-product and it does not need a banner.
I also treated it as a one quarter project. It is a quarterly measurement with occasional small interventions, and the teams I have seen do this well keep it next to their technical debt review rather than running it as a campaign. Our billing service has a bus factor of three now, nine months later, and it got there through two pairing cycles, one rotation change and a hire written for the overlap. Nothing in that list was heroic. The only hard part was measuring the thing honestly before anyone handed in their notice.
Frequently Asked Questions
What is a good bus factor for a small engineering team?
Is documentation enough to fix a bus factor of one?
How do we do this without slowing delivery down?
Should we hire someone to fix a bus factor of one?
Build the second owner before you need one
Run step 1 this week, then bring us the three systems carrying a single name. We will help you cover them, and put forward pre-vetted engineers for the gap pairing cannot close.
Get startedRelated reading: Build an on call rotation for a small team · Knowledge transfer when a dedicated team scales · Hire a site reliability engineer in Singapore
External references: Google SRE Book, Being On-Call · Google SRE Book, Postmortem Culture · DORA research.
