Why Staffing Juniors on Your MVP Costs More

A junior-heavy team quotes a lower day rate. On a spreadsheet that is straightforwardly cheaper, and for a large, well-specified project with senior people directing it, it frequently is.

On a small, ambiguous, early-stage build it usually is not, and the reason is specific rather than a matter of opinion about experience. It is about what consumes the budget on a project of that shape.

We have run senior-only teams since 2015, so treat this as an argument we have an interest in. It is still the argument, and the boundaries where it stops applying are set out at the end.

On a small build, cost is decisions, not hours

On a large project with a settled specification, most of the work is execution. Hours dominate, and a lower rate lowers the total.

On an early-stage build almost nothing is settled. The work is a rapid sequence of judgement calls: what to build first, what to leave out, how to model the data, where the boundaries go, what to do manually for now, which features are the same feature.

Each of those takes minutes to decide and weeks to undo. And critically, they are not made faster by adding people or hours, they are made better by having made them before. That is the whole of the argument.

The three costs that do not show up in the rate

Rework. A wrong architectural call is not discovered when it is made. It is discovered six weeks later when a feature turns out to be much harder than it should be, and by then it is load-bearing. The rate you paid for those six weeks is irrelevant next to the cost of unwinding them.

Supervision. A junior team needs direction and review. If that is not in the quote, it is coming out of your time, and a founder spending fifteen hours a week reviewing work is a founder not doing the job only they can do. That is a real cost paid in the scarcest resource you have.

Over-building. This is the most expensive and least discussed. Experience mostly shows up as not building things: recognising that two requested features are one feature, that a step can be manual for now, that a whole subsystem is not needed until there are users. Less experienced teams build what they are asked for, competently. On an MVP, building what you were asked for is frequently the failure, as scoping an MVP sets out at length.

The most valuable thing a senior engineer does on an early build is talk you out of a third of it.

Working the comparison through

The argument is easier to see with the shape of the arithmetic rather than in the abstract. Take a build quoted at a lower rate over a longer timeline against a higher rate over a shorter one, and the day rates alone can make the first look like clear value.

So work it. The figures below are illustrative, not quoted, and your own will differ; what matters is which columns exist, because the left-hand one is usually the only column anybody compares. Founder time is valued at $400 a day, which is conservative for someone whose main job is finding customers:

The quoted price was the only line where the cheaper team won, and it was the only line anyone looked at. Note the last row especially: it is not a cost, it is four extra months before you find out whether you built the right thing, and for an early product that is usually worth more than the whole difference above it.

Those three added rows routinely close the gap and often reverse it. That is not a claim that the cheaper team is bad; it is that the rate is measuring the wrong thing. On a build where most of the budget goes into decisions rather than keystrokes, comparing rates is like comparing the price of two flights without looking at where either lands.

The comparison worth running is total cost to a validated product, including your own time, not cost per engineer-day.

For Zoolingo we owned delivery end to end: design, animation, build and launch. That is the shape this argument is about. There was no handover between a team that decided things and a team that typed them, which is where most of the founder hours in the left-hand column above actually go.

Why this got sharper with AI in the stack

Two reasons, pulling the same direction.

First, AI features concentrate the irreversible decisions early. Retrieval, fine-tuning or a better prompt. Whether a feature needs a model at all. Where the human checkpoint goes. What the cost per request will be at scale. These are exactly the hour-to-decide, months-to-unmake calls, and the common error: reaching for a model where ordinary code would be cheaper, faster and testable, is exactly the error that inexperience produces. We cover the reasoning in RAG, fine-tuning or prompting.

Second, coding assistants have compressed the part of the work where a rate difference mattered most. Producing competent code from a clear specification is dramatically faster than it was for everyone. What has not been compressed is knowing what to build, what to refuse, and which failure modes to design against. The value has shifted toward exactly the thing experience provides.

What we mean by senior

Not years on a CV. Three specific things:

• Has shipped this kind of system before, and remembers where it hurt. Pattern recognition is the whole asset.
• Will say no, and explain why. An engineer who builds whatever is asked without pushing back is not protecting you from anything.
• Can talk to you directly about trade-offs in terms of cost and risk rather than implementation. If every conversation needs a translator, the judgement is not reaching the decision.

The third is why we do not put an account manager between the founder and the engineers. Most of the value is in that conversation, and a layer that summarises it removes the part that mattered.

When a junior-heavy team is right

The argument has real limits, and pretending otherwise would be dishonest:

• A large, well-specified project with strong senior direction. This is what junior engineers are for, and how they become senior. The specification and the review capacity have to exist.
• Long-running maintenance of a stable system where the decisions are behind you.
• You are technical and have the time to direct it. A technical founder with capacity to review daily gets much of the benefit at a lower rate. The honest question is whether you have the time, not whether you have the skill.
• Volume work where the task is well understood and repeated.

What these share: the hard decisions are already made, or someone is making them. Where that is not true, the rate is not the number that matters.

What a good small team looks like

"Senior-only" invites an obvious objection: surely you need a range of people. On a large programme, yes. On an early-stage build the shape is different, and it is worth being concrete about it.

An effective small team is two to four people who each cover more than one discipline. Someone who designs and can build the front end. Someone who does backend and infrastructure without needing a separate specialist for deployment. Someone senior enough to hold the architecture and talk to you directly about trade-offs.

The reason is coordination cost, not heroics. Every handoff between specialists is a meeting, a document, and an opportunity to lose context. On a project with a settled specification that overhead is worth paying for the throughput. On a project where the specification is still forming, the overhead exceeds the benefit. You spend more time transmitting an evolving understanding than acting on it.

This is also why adding people to a late early-stage project reliably makes it later. The bottleneck is shared understanding, and understanding does not parallelise.

How to check the claim

Every agency says its people are senior. The word costs nothing, so it is worth testing rather than accepting. Four things that are hard to fake:

Ask to meet the people who will do the work. Not the founder, not the account lead. If the team on the call is not the team on the project, you are being sold something other than what you will get.

Ask about a project that went badly. Experienced engineers have several and describe them exactly, what they misjudged, when they noticed, what they would do differently. A flawless track record means either a short one or an unreliable narrator.

Ask them to explain a technical trade-off in your product's terms. Cost, risk, and what it means for your timeline. Retreating into jargon is not depth; it is usually the opposite.

Give them something to disagree with. Put a slightly wrong assumption into your brief on purpose and see whether anyone catches it. This one is unfair and extremely informative.

The question to ask any team

Whoever you are considering, ask: which of these features would you tell me not to build, and why?

You are not really asking about features. You are testing whether they will engage with your commercial situation or just quote what you listed. A team that answers "all of them look fine" is telling you they will build whatever you say, competently, including the third of it that is a mistake.

The answer you want is specific, reasoned, and slightly uncomfortable. That is what a senior team is for, and the reason our engineering process puts the architectural conversation in week one instead of deferring it until something breaks.

If you would rather judge the argument on the work than on the reasoning, the products we have shipped are the honest test of it, and who you would actually be working with is a fair question to ask any team making this claim.