Outsourcing gets argued as a cost question, which is the least interesting thing about it. The real trade is who holds the knowledge when the engagement ends — so here is how we would decide, including the cases where you should not hire us.
2 September 2026
11 min read
Both arrangements deliver working software. What separates them is where the knowledge lives once the work ends.Illustration
Listen to this entry
0:00 / 15:17
Narrated by A I from the text of this page
Every few months somebody sends us a spreadsheet. On one side, the fully loaded cost of two senior engineers in-house. On the other, our rate for the same two people, multiplied out across a year. The two numbers land close enough that the decision appears to turn on a percentage, and the person who built the sheet is usually asking us to confirm which column wins.
Neither column wins, because the sheet is measuring the wrong thing. Both arrangements deliver working software; teams of both kinds ship every day. What separates them is not price per hour. It is where the knowledge lives at the end — who can still change the system a year from now, and how much of that ability walks out when the arrangement does.
We are obviously not neutral. So this is written to be useful even if you decide against us: what each arrangement is genuinely good at, how each one fails, and the cases where we would tell you to hire rather than sign with anybody, ourselves included.
In brief: the real difference is not price per hour. It is who holds the knowledge — and can still change the system — once the engagement ends.
01A permanent team compounds context and stays aligned for the long haul. An agency buys you calendar time, elasticity, and outside judgement.
02Decide by asking how often the system changes, and whether those changes are decisions or deliveries. Decisions want people who stay; deliveries can be bought.
03Most of the risk is set before work starts: your repositories from day one, direct access to engineers, a real trial, documentation as a deliverable.
The comparison everybody runs.
A salary is not the cost of a hire, and a day rate is not the cost of an agency. Both are the visible number, which is why both get compared — and both are the smallest term in their own equation.
On the in-house side, the real cost is the search: the months of it, the attention it takes from whoever is already the most senior engineer you have, and the roadmap that does not move while it runs. Then onboarding, which is a senior engineer producing very little for several weeks while consuming another senior engineer’s output to do it. Then the management surface a permanent team needs forever — reviews, career conversations, somebody to notice when a good person has quietly checked out.
On the agency side, the invisible cost is context transmission. Everything your team knows and never wrote down has to be reconstructed by people who were not there, and every hour your staff spends transmitting it is an hour they are not building. An agency that never asks those questions is not being efficient. It is guessing, and you will meet the guess later, usually in production.
Neither of those is an argument for the other. They are simply the terms missing from the spreadsheet, and they happen to be the ones that decide whether the arrangement works.
Fig. 01
The two totals land close enough that the decision looks like a percentage. The rows that actually decide it are the ones nobody entered.Diagram
What a permanent team actually buys.
Context that compounds. The engineer who was in the room when you chose the queue, who remembers which customer the odd exception exists for and why the cheap fix was rejected in March. None of that is in the repository. It is the difference between a change taking a day and taking a fortnight, and it accrues only to people who stay.
Availability without a contract. A permanent team can be interrupted. Tuesday afternoon, an idea from a sales call, half an hour of somebody’s attention — no scope, no change request, no conversation about what it displaces. A great deal of product work is made of exactly those, and they are the transactions an agency handles worst.
Alignment over a long horizon. People who will still be here in two years make decisions for a two-year system, because they are the ones who will have to live in it. That is the strongest argument for hiring, and it is not really about loyalty. It is about who bears the consequence.
Ownership by default. Any arrangement can be made to leave the knowledge with you. This is the only one that does it without anybody having to be careful.
What an agency actually buys.
Time — calendar, not hours. A senior engineer you hire is a search measured in months, and the work does not start until the search ends. A team that already exists starts in days. When the thing you are building has a date attached to it — a season, a regulation, a funding round, a competitor who shipped first — that gap is the entire decision, and no cost-per-hour comparison contains it.
Having done the shape before. Not your domain; the shape. A payments integration, a re-platforming, a migration with money inside it. Anyone can learn these. What you are buying is somebody who already made the expensive mistakes on another company’s system and arrives carrying the list.
Elasticity, in both directions. Two more engineers for the push, and none of them on the invoice by autumn. A permanent team is a fixed cost with a person attached to it; scaling it down means redundancies, notice periods, and a bad quarter for everybody who stays.
No history in your organisation. We did not choose the architecture, we do not report to the person who did, and we lose nothing by saying the thing most of the room already believes. That is worth a surprising amount for about six months — after which we have a history too, and you should discount our opinions accordingly.
How an agency goes wrong.
Every failure below is real. We have watched most of them from the inside, and one or two are ours from earlier years. They are worth knowing in advance because each one is visible in how an engagement is set up, long before there is any code to judge.
01The knowledge leaves with the invoice. The engagement ends, the team moves on, and what they understood about your system is now nowhere. That is the default outcome rather than the unlucky one. Avoiding it takes deliberate work, and the deliberate work has to be scheduled from the beginning instead of promised for the end.
02An account layer between you and the code. If your questions reach the engineers through somebody whose job is the relationship, you get answers optimised for the relationship. Ask to speak to the people writing it, in the first meeting. How that request is handled tells you most of what you need to know.
03Substitution. The engineers in the proposal are not always the engineers on the work, and a rotation six weeks in resets context you have now paid to build twice. Ask who, specifically — and what happens the week one of them is moved to another client.
04The incentive to keep building. An agency paid by the month has no structural reason to tell you a feature is not worth building. The honest ones do it anyway, at cost to themselves, and it is the clearest signal available to you in the first month of working together.
05The demo problem. Work gets judged on what can be shown on Friday, so the parts that cannot be shown — the tests, the migrations, the boring seams — quietly lose. A year of that is a codebase that demonstrates beautifully and resists every change you ask of it afterwards.
06Diffuse ownership when it breaks. At three in the morning, with a system built by people who are no longer engaged and are contractually off the hook, somebody inside your company is awake and on the phone. Decide who that is while everything is still calm.
How building in-house goes wrong.
The in-house failures get discussed less, largely because they arrive slowly and are nobody’s fault in particular. They are not smaller.
01A wrong hire costs a year. Months to find, months to be certain, and then a conversation most organisations postpone by another quarter because it is unpleasant. Throughout, the roadmap is being carried by somebody who cannot carry it, and the person who ends up repairing that is your best engineer.
02The team of one. A single in-house senior is the highest-risk arrangement on this page and easily the most common. Everything lives in one head; their holiday is a freeze, their resignation is an outage measured in quarters. In-house does not mean resilient. A team means resilient.
03You cannot scale down. The build is a surge; the maintenance is not. A team sized for the build is over-sized within a year of shipping, which is when good engineers get bored — and bored senior engineers leave, which is how you come to be hiring again for a system nobody remaining understands.
04Hiring encodes today’s architecture. The team you build is shaped around the decisions you have already made. Two years later, revisiting those decisions means changing people rather than changing code. Agencies get replaced; architectures held in place by employment contracts do not.
05Nobody senior to review the senior. Your first engineer sets every convention in the codebase unchallenged, and by the time you can afford somebody able to challenge them, the conventions have become the system.
06It is management, not headcount. Recruiting, onboarding, reviews, progression, retention — somebody owns all of it, permanently. In a small company that somebody is usually the founder who was meant to be selling.
The question underneath both.
Take the arrangements away and what is left is a question about ownership rather than staffing: is this a capability your organisation has to hold, or a body of work you need delivered well?
The test we use is unglamorous. Look at the system in question and ask how often it changes, and whether those changes are decisions or deliveries. Something that will be argued about every fortnight for the next five years — pricing, the core model of the product, whatever it is your customers actually pay for — wants people who stay, because the value sits in the argument and in remembering how the last one went. Something with a shape, an end, and a named owner afterwards — a migration, a re-platform, an integration, the first version of something whose future nobody can predict yet — is work, and work can be bought.
Most companies contain both, and get into trouble by treating everything as one or the other. Outsourcing the core is how you end up renting your own product. Hiring for the surge is how you end up with a permanent team maintaining something that stopped changing eighteen months ago.
Fig. 02
How often does it change, and are those changes decisions or deliveries? The first wants people who stay. The second can be bought.Diagram
“
The question is not who writes the code. It is who will still understand it two years after the last invoice.
When we would tell you to hire instead.
We turn work down for the reasons below, and it is cheaper for everyone when that happens in the first conversation rather than the fourth month.
01The software is the business. If the product is the thing you sell, the team building it is not a cost line to be optimised — it is the company. Buy help around the edges, own the middle.
02The domain takes a year to learn. Clinical, regulatory, heavy industry, anything where being wrong is not a bug report. Where the expensive knowledge is the domain rather than the engineering, the arrangement should keep the people who acquire it.
03The work is small, constant and unpredictable. Half a day here, an urgent hour there, indefinitely. That shape suits an employee and fights every contract ever written; you will spend more describing the work than doing it.
04You need somebody in the room. Not a channel, not an overlap window — a person at the table when decisions get made. Some organisations run entirely on those rooms, and no amount of process substitutes for a chair in one.
05You are buying the cheapest possible build. Then hire, or find somebody else. A cheap build, outsourced, is the most expensive item on this page: you pay for it twice, and the second time is worse.
The terms that make either one survivable.
Whichever way you go, most of the risk is settled by arrangements made before any work starts. These are what we would insist on as a client, and what we hold ourselves to as a studio.
01Your accounts and your repositories, from the first commit. Not migrated at the end. Code, infrastructure, domains and CI live in your organisation from day one, and the agency has access rather than custody. Anything else turns the handover into a negotiation at precisely the moment your leverage is lowest.
02Direct access to the people writing it. No proxy, no translation. You should be able to ask an engineer why, and get the answer they would give another engineer.
03A trial with a real exit. A fortnight, judged on shipped work rather than CVs, with the right to stop and owe nothing. The same logic protects a hire: a probation period you would genuinely be willing to use.
04Documentation as a deliverable, not a favour. The decision record, the runbook, the reasons — written while the work happens and reviewed like code. Documentation promised for the end of an engagement does not get written, and everybody in the room knows it at the time.
05A named owner on your side. One person who can answer a question, make a decision and take the pager. If nobody can be named, the engagement drifts regardless of who staffs it.
06An exit that is a conversation. Notice periods are reasonable; lock-in is not. If ending the arrangement requires a lawyer, that was designed in — and it was not designed for you.
Own the core, borrow the surge.
In practice most of the companies we work with end up somewhere in the middle, deliberately: a small permanent team owning the decisions and the memory, with outside engineers carrying bounded work alongside it — a migration, a second product line, the six months where the roadmap is twice the size of the team.
That arrangement has a failure mode of its own, worth naming. Two tiers form. The permanent team keeps the interesting work and reviews everything; the outside team receives tickets and touches nothing structural; and within a couple of months you are paying senior rates for people who have been prevented from behaving like seniors. The fix is unremarkable, and it is cultural rather than contractual: one backlog, one review standard, one definition of done, and outside engineers who are expected to argue with a decision when it deserves it.
None of this makes the choice for you, and it is not meant to. What it should do is move the conversation off the spreadsheet — away from what an hour costs, and onto what you have to own, what you can safely buy, and the state you want to be in on the day the arrangement ends. If you are somewhere in that decision and would like an honest answer, including the one where we tell you to hire instead, send us a brief.
Fig. 03
The arrangement most companies land on: a permanent team owning the decisions and the memory, outside engineers carrying work that has an end.Diagram