In-House Developer vs Agency: The Honest Math

A nine-location garden-center chain we advise — an illustrative company we will follow throughout — hit the moment every growing business faces. A loyalty and online-ordering platform was finally worth building, and there were two ways to get it: a first developer hire with a $130,000 salary request in one browser tab, and an agency proposal at $150,000 in the other. The salary looked cheaper, the invoice scarier — and both numbers were the wrong number, because neither included everything that surrounds them.

This article runs the comparison the way we run it with clients: fully-loaded cost, speed to start, skill breadth, continuity risk, management overhead, then the hybrid patterns and a decision matrix by project type and stage. Salary and benefits benchmarks come from BLS data and published surveys; every model below is illustrative, with assumptions visible. Already shortlisting partners? Our questions to ask before hiring a dev agency pairs well with this math.

Here is the short version.

Key Highlights

• The median US software developer earns about $133,000 (BLS wage data, May 2024); benefits and payroll taxes add roughly 30% before a line of code ships.
• Fully-loaded year one (illustrative): about $165K for a mid-level hire, $200K for a senior hire, $330K for two mid-level hires.
• An agency MVP at the illustrative midpoint — 1,000 build hours at a $150 blended rate — is about $150K, or $186K in year one with a stabilization retainer.
• Speed: first release in about 6 weeks through an agency versus 14 for a solo hire (illustrative); SHRM's hiring benchmark is ~44 days before day one.
• Coverage: a solo hire fully covers about 2 of 8 capability areas with 3 more partial; an agency bench covers 7–8 (illustrative).
• Continuity: software engineers change jobs roughly every 2 years on average (LinkedIn published tenure data); our model prices a resignation at about two quarters of velocity (illustrative).
• Three-year totals (illustrative): about $580K on the hire path versus $530K through the agency — close enough that capability, not cost, should decide.
• Fit scores by stage (illustrative rubric): agency 8 of 10 pre-launch, hybrid 9 of 10 in growth, in-house 8 of 10 at maturity.

The Cost Question Behind the Question

A salary and an agency invoice measure inputs, and inputs are where both sides of this debate cherry-pick. The unit that matters is the cost of delivered, maintained software over three years — and that cost has five layers whichever route you pick: pay or fees, load, tools, management time, and risk. Most budgets count only the first.

One anchor before the scenarios: BLS wage data puts the median US software developer at about $133,000 a year (May 2024), and employer-cost data shows benefits and payroll taxes adding roughly 30% on top. Mobile, DevOps and data specialists command premiums in industry surveys, so treat that median as a floor. The salary, in other words, is roughly two-thirds of the true price of an employee — and none of the price of a bad fit.

Key takeaway: Compare capability to capability, not salary to invoice. Price all five layers — pay, load, tools, management time and risk — before either option wins on paper.

Factor 1: Fully-Loaded Cost — What a Salary Actually Buys

Start with what a hire really costs in year one. The table below builds a mid-level developer at a $115,000 base (illustrative, below the BLS median), with every hidden layer priced:

A senior hire at $140,000 lands around $200,000 in year one and roughly $187,000 after; two mid-level hires run about $330,000 (all illustrative). The agency route prices differently: an MVP at the illustrative midpoint of 1,000 build hours at a $150 blended rate is about $150,000, and three months of stabilization retainer takes year one to roughly $186,000.

Key takeaway: A salary is roughly two-thirds of what an employee costs, and an agency invoice is roughly two-thirds of what an engagement costs. Budget the loaded numbers — about $165K to $200K for a hire versus $186K for a build year one — or the comparison is fiction.

Factor 2: Speed to Start — When the First Release Lands

Cost is only half the ledger; calendar is the other half. SHRM's published benchmarks put a typical hire at about 44 days and roughly $4,700 before day one — and developer searches routinely run longer without a technical interviewer (illustrative). Add a 3–6 month ramp to full productivity, a common industry rule of thumb, and the calendar gets real.

An agency starts scoping the week you sign and staffs a bench that already knows how to ship. In our illustrative ranges, the first production release lands about 6 weeks in through an agency, 9 weeks contractor-first, and 14 weeks with a solo hire — the difference is mostly recruiting and ramp, not coding speed. For a pre-launch product, every month of delay is missing revenue — that gap alone can decide the question.

Speed has a hidden corollary: optionality. An agency build buys a working product you can judge before committing to permanent payroll; a hire commits you to a person and a roadmap simultaneously. Contractor-first splits the difference — a senior contractor starts within days while your hiring process runs.

Key takeaway: If the first release has a deadline attached, the agency route starts finished weeks earlier and keeps your hiring decision reversible. Treat time-to-release as a budget line, because it is one.

Factor 3: Skill Breadth and Continuity Risk

A hire is one brain; production software needs about eight capability areas. Scoring the illustrative senior full-stack hire against that list is sobering — and the same scoring flatters the agency bench, which is the actual trade:

The hire fully covers about 2 of 8 areas plus 3 partial; the agency covers 7–8 (both illustrative). The gap shows up as risk before it shows up as quality: the solo hire sets up deployment, backups and monitoring alone, and whatever they have never run in production is your next outage. Our DevOps and CI/CD case study shows what a mature pipeline buys.

Continuity is the second half of this factor, and the data is blunt: LinkedIn's published tenure data puts software engineers at about 2 years per job on average. For a one-person team that is a structural bus factor of one. The model below shows what a resignation does — velocity collapses to roughly a third, then takes about two quarters to recover through recruiting and ramp (illustrative).

Every departure also carries a replacement bill — recruiting costs plus lost velocity that we model at 1.5–2× monthly salary per exit (illustrative). An agency absorbs churn internally, which is the quiet reason retainers feel expensive and still cost less than a bad quarter.

Key takeaway: You are not hiring "a developer" — you are buying coverage of eight capability areas and betting continuity on one person's tenure. Price the bench and the bus factor before you price the salary.

Factor 4: The Three-Year Math

The senior-hire path runs $200K, $187K and $192K across three years (year one carries recruiting and ramp). The agency path runs a $150K MVP plus stabilization in year one (~$186K), then a $14K-a-month product retainer (~$168K), drifting to about $174K by year three as scope grows. Totals: about $580K versus $530K (illustrative).

Read those numbers honestly: a $50K three-year gap is close enough to be a tiebreaker, not a verdict — one hiring miss or one oversized retainer flips it. What the totals hide is what each dollar buys: the hire path buys deep product knowledge and instant access, the agency path buys breadth and surge capacity. The model also assumes competent management of both.

Key takeaway: Over three years the routes cost within roughly 10% of each other, so cost alone cannot make this decision. Decide on speed, coverage and continuity first — then let the arithmetic confirm the choice.

Factor 5: Management Overhead — The Hours Nobody Budgets

Software does not manage itself either way, and the hours land on someone's calendar — usually a founder's. The illustrative weekly load differs in shape more than size:

Industry practice puts one engineering manager per 5–8 engineers, and a single hire still needs real technical steering — which a non-technical founder usually cannot provide. That is the classic failure: a good hire, badly led, drifts a year and leaves. If nobody in the building can review code and unblock architecture decisions, budget for a fractional CTO or technical product owner (illustratively $150–$250/hour).

Key takeaway: Whichever route you pick, someone senior must own technical direction for a few hours every week. If that person does not exist, the management gap — not the salary or the retainer — is your biggest unbudgeted cost.

Factor 6: Hybrid Patterns — What Growing Companies Actually Do

Very few growing companies stay pure. The durable patterns we see, and when each one earns its keep:

The first pattern is the most common bridge, and it works only when the handover is a designed deliverable — documentation, environments, credentials and a pairing sprint, not a folder of files. We use a variation on most client engagements; the patient app we built for a healthcare group was built for the client's team to inherit.

Key takeaway: The real question is not "hire or agency" but "which sequence." Deliberate hybrids capture the agency's speed and the hire's continuity — sloppy hybrids capture neither.

Factor 7: Decide by Project Type and Stage

Stage changes the answer more than anything else. Scored against cost, speed, coverage and continuity, the illustrative rubric matches what we watch clients choose in practice:

Translated into decisions by situation:

Two of those rows deserve the spotlight. Regulated builds carry documentation, audit and security demands that punish solo-hero development — the patient app case study shows that governance on a real engagement. Growth-stage data products benefit from a team that ships weekly against analytics, the pattern behind our SaaS analytics dashboard work. For the garden-center chain: growth stage, customer-facing, non-technical founder — the rubric says agency build with a designed handover, then the first hire to run what ships.

Key takeaway: Match the route to the stage: buy an agency's speed when the product is unproven, build a hybrid when the roadmap is compounding, and hire in-house when the work is steady enough to keep one person full-time.

What Your Business Should Do

Days 1–30: Define the work before the people.

• Write the one-page brief: business outcomes, must-have scope for version one, and hard constraints.
• Score your gaps across the eight capability areas above; mark which must be full strength at launch.
• Set the calendar — when version one must be live, and what one month of delay costs in revenue or runway.

Days 31–60: Run parallel probes.

• Post the role and interview two or three candidates to test the market, the salary reality and your own ability to assess.
• Get two or three agency proposals against the same brief; compare loaded three-year numbers, not hourly rates.
• Start the smallest sensible pilot with the leading agency while the hiring process continues.

Days 61–90: Decide and structure.

• Choose by stage and project type using the matrix; if you hybrid, own the repository, the roadmap and the decisions from day one.
• If you hire, fund tools, recruiting and a 90-day ramp honestly; if you sign an agency, contract milestone payments, IP assignment on payment and weekly demos.
• Review at day 90 on one scoreboard: shipped scope, velocity, and cost per delivered feature — the same scoreboard either route.

The Bottom Line

The honest math rarely crowns a permanent winner; it sequences one. Buy an agency's speed and breadth while the product is unproven, build a hybrid while it compounds, and hire for continuity when the work is steady — the garden-center chain will likely do all three inside four years. Companies that treat hire-versus-agency as a stage-by-stage decision outperform companies that treat it as ideology.

If you want that math run against your roadmap, Book a free strategy call and we will pressure-test both routes with your numbers — or send us a message with your questions and we will answer within one business day.