In-house developer vs development agency: the cost math with the assumptions shown

Most comparisons on this topic are written by one side and argue the case rhetorically. The salary figure appears with no source, recruiting time is left out entirely, and time to first useful output is never mentioned because it is the line that makes hiring look worst.

Here is the arithmetic with the assumptions visible, including the cases where hiring is clearly the right answer.

The lines nobody puts in the comparison#

	Hire and train someone	Engage a studio
Time to first useful output	3 to 6 months	Week one, a written scope
Recruiting and onboarding	4 to 10 weeks before they start	None, start inside two weeks
Who trains them	Your most senior person, for months	Nobody
Who reviews the work	Also your most senior person	We do, visible weekly
Breadth	One person, one skill set	Product, data, AI, commerce and CRM
If they leave	The knowledge leaves with them	Documentation and code you own
Cost	$95k to $160k, plus benefits and tools	A fixed project fee agreed up front

Where the salary range comes from. It reflects US market rates for a mid to senior full stack developer or a HubSpot administrator, before employer taxes, benefits, equipment and software. It is a market range, not a quote, and it varies enormously by city. Check it against your own recruiting data rather than taking ours.

Where the ramp figures come from. These are our observation across client teams, not a published statistic. Yours may be shorter, particularly if the codebase is small or the new hire has worked in your exact stack before. We are stating the source because a comparison that hides it is not a comparison.

The three costs that do not appear on the offer letter#

Recruiting is a project. Writing the spec, screening, four rounds of interviews, a take home, references, an offer that gets countered. Four to ten weeks of calendar, and a meaningful chunk of it is your senior people's time, which is the resource you were trying to free up.

Ramp consumes your best person. A new developer does not produce net value on day one. For the first months they produce work that your most senior engineer reviews, corrects and explains. The cost of a hire includes a partial tax on the output of the person doing the training.

Departure is total. When the person who built the integration leaves, and the median tenure in this market is around two years, everything they knew and did not write down leaves with them. This is the line that turns a cheap hire into an expensive one, and it is invisible in year one.

Where the agency model is genuinely worse#

Being fair about this matters more than winning the argument.

Per hour, we cost more. A fixed fee that carries the risk of a bad estimate is priced higher than a salary divided by 2,000 hours. If the work is continuous and predictable, that premium compounds against you.

We are not in the room. An employee absorbs context from hallway conversations. We need that context transferred deliberately, which costs your time.

We leave. At the end of a project we hand over code, infrastructure and runbooks and go. If what you need is someone who is permanently available for small requests, that is a retainer at best and a hire at worst.

You are not building internal capability. Every project we do is knowledge that lives in your documentation rather than in your team's heads. Documentation is better than nothing and worse than a person who knows.

The actual decision rule#

It is not about cost per hour. It is about whether the work is continuous.

Hire when the work never ends, when there is someone internal senior enough to direct and review it, and when you can survive the three to six month ramp without the thing being late.

Engage a studio when you need one thing built well, once, this quarter. When the skills needed span more than one person can hold. When you do not have a senior engineer with months of review capacity spare. Or when you are not yet sure the role is permanent, which is most companies before their first technical hire.

Do both in the most common good outcome: a studio builds the first version and hands over documentation and code, then you hire someone into a role with a working system to maintain rather than a blank repository and a six month ramp. Hiring into an existing system is a much easier hire to make and a much faster one to onboard.

What a fixed fee actually buys#

The comparison only holds if the fee is genuinely fixed, which means a scoping week that produces a number that does not move rather than an estimate that discovers itself during the build.

It also means you own the output. Code in your repository, infrastructure in your accounts, documentation covering redeploys, credentials and how to add a field. An engagement that leaves you unable to continue without us is not an alternative to hiring, it is a worse version of it.

If you are weighing this before committing to anything, the one week paid scope is the cheapest way to get a real number to compare against a salary.

Frequently asked questions#

Is it cheaper to hire a developer or use an agency?#

Per hour, hiring. Per outcome, it depends entirely on whether the work is continuous. A single project completed in eight weeks is almost always cheaper with an agency once you count recruiting time and the three to six month ramp.

How long does it take to hire a developer?#

Four to ten weeks of recruiting before they start, then three to six months to full productivity. Budget both. The second number is the one most plans omit.

Should we hire a developer or a HubSpot admin first?#

Depends on where the bottleneck is. If your problem is that the CRM does not reflect how you sell, an admin fixes more than a developer will. If the problem is that a product does not exist, the reverse.

What happens to the code when the project ends?#

It goes to your repository and the infrastructure sits in your accounts, with runbooks covering redeploys, credentials and adding a field. An agency that is hard to leave is a dependency, not a partner.