The roadmap is stuck, the developer role has been open for two months, and the debate around the table has hardened into camps: hire properly and wait, bring in a freelancer, or call an agency. Framed that way — loyal employee versus hired guns — the debate goes in circles, because it compares identities instead of comparing what the business needs.
The useful frame is different: are you solving a permanent need or buying fast impact? A full-time hire answers “who builds and owns this product for years.” A freelancer or an agency answers “what ships this quarter.” Those are different questions, and most SMBs have both at once — which is exactly why the either/or debate never resolves.
This guide compares the three models honestly — real costs, real timelines, real failure modes — and makes the case for the combination many owners treat as an admission of defeat: external capacity delivering while the hire is recruited. It isn’t defeat. It’s usually the cheapest sequence.
Before choosing a model, run your job ad through tensionscore: score out of 10, estimated time-to-hire and true first-year cost — the numbers that tell you whether waiting for the hire is affordable, or whether the roadmap needs external capacity now.
See my free diagnosisThe question that untangles it: permanent need or fast impact?
A need is permanent when the software is core to the business and will evolve continuously for years, when the knowledge of how it works must live inside the company, and when there will still be a full workload eighteen months from now. That’s an ownership question, and ownership is what employment buys.
A need is about impact when there’s a dated deliverable: a backlog to clear, a rebuild, an integration, a launch. Speed and expertise matter more than long-term ownership, and the workload has an end. Paying an external premium for a few months costs less than stretching the same work across a year of distracted internal capacity.
Run your project list through that filter and the answer is usually “both”: one permanent core need, plus two or three impact-shaped chunks around it. Which is why the right answer is rarely one model. It’s the right model per need, sequenced deliberately.
The full-time hire: highest ceiling, slowest start
Cost first, honestly. A mid-level developer at $120k base — squarely in the $102k to $132k national range for a mid-level full-stack developer — costs about $156,000 a year fully loaded, using the 1.3 × base multiplier tensionscore applies for employer payroll taxes and benefits. Getting them in the door costs nearly $4,700 on average when handled in-house (SHRM), or 15% to 25% of first-year base if a contingency recruiter does it: $18,000 to $30,000 on that same role.
Then time. Hiring averages about 44 days across all roles (Josh Bersin Company / AMS), and tensionscore’s benchmarks put developer hires at two to four months, up to five or six for DevOps, data and tech leads (see our guide to developer time-to-hire). From posting to a developer actually shipping, add the offer stage, the standard two weeks’ notice and a realistic ramp-up on top. That’s the model’s real price: not the salary, the wait.
What you get for it is the highest ceiling of the three: knowledge that compounds instead of walking out at contract end, the lowest effective hourly cost at full utilization, and someone who owns the product rather than a deliverable. The risks are the mirror image — a mis-hire costs a full cycle plus the delay, and a single in-house developer is a bus-factor problem of its own.
The freelancer: fast and surgical, but a single point of failure
Rates first, because they span a factor of ten and the spread is informative. On mass marketplaces like Upwork, software developers typically bill anywhere from $10 to $100 an hour — a global median that says more about offshore supply than about US talent. On vetted networks like Arc, freelance software development averages $81 to $100 an hour, and seasoned US independents with direct clients charge $100 to $300 (Arc.dev, Upwork, FullStack Labs). At $100 an hour, a full-time month is roughly $17,000: more per hour than an employee, with zero commitment beyond the contract, no benefits, no severance — and a start date measured in days, not months.
The model fits well-scoped work: a defined deliverable, a specific expertise you need for three months, a part-time need no salary line justifies. The math flips at permanent full-time volume — $100 an hour year-round approaches $200,000, freelance premium paid indefinitely for what has become an employee-shaped need.
The failure modes are structural, not moral. A good freelancer is booked, so availability is never guaranteed — least of all for the urgent fix six months after the contract ends. It’s a bus factor of one. And scoping, prioritizing and reviewing stay with you: a freelancer executes your management, they don’t replace it. The mitigations are known — your repository from day one, documentation as a deliverable, a planned handover.
The agency or collective: a team on tap, at a team price
Here too, the rate spread is itself information. Credible US-based shops run about $90 to $160 an hour at the smaller end and $120 to $250 for mid-market firms (FullStack Labs). On directories like Clutch, most listed firms advertise rates under $50 an hour — overwhelmingly offshore teams, which can work, but which move the burden of specification, time zones and quality control back onto you. There’s no free lunch between those columns, just different places for the cost to show up.
What the premium over a freelancer buys is continuity and structure: a team instead of a person (no single bus factor), project management and code review built in, and the ability to staff several skills at once — design, back-end, DevOps — without running three separate searches. For an SMB with no technical management capacity in-house, that structure is often the difference between shipping and stalling.
The risks concentrate on dependency. If the code, the infrastructure and the knowledge live at the agency, switching costs mount every month. The protections belong in the contract before you start: your repo and your cloud accounts, documentation as a standing deliverable, an explicit handover clause. An agency that resists those terms is telling you something about its business model.
The combination: external capacity ships while you hire
Now put the models together instead of choosing between them. Your permanent need justifies a hire, and that hire will take two to four months to write their first line of code for you. Your impact needs can’t wait those months without a cost of delay — features not shipping, customers waiting, a team compensating — that quickly rivals the external premium you were trying to avoid (we put numbers on it in the real cost of a developer in year one).
The sequence that resolves it: external capacity — a freelancer or a collective — starts within days and delivers the urgent work, while the recruitment runs at the pace good hiring requires. You stop interviewing under duress, which is how mis-hires happen; the codebase your future hire inherits is moving, documented and reviewed; and the handover is a planned deliverable rather than an afterthought. The neodev collective, for instance, works this way with SMBs: alongside your hiring, not instead of it.
Decision rules, compressed:
- Permanent core need, workload still full in 18 months: hire full-time — and budget about 1.3 × base, plus recruitment, plus the wait.
- Scoped deliverable or part-time expertise: freelancer — with your repo, documentation and handover written into the contract.
- Several skills at once, or nobody internal to manage the work: agency or collective — US-based if review capacity on your side is thin.
- Urgent roadmap and a hire in progress: combine — external ships now, the recruitment breathes, the handover is planned.
Key takeaways
- Stop framing it as internal versus external: sort each need into permanent (ownership → hire) or fast impact (speed → freelance/agency), and pick per need.
- A full-time hire costs about 1.3 × base fully loaded, plus nearly $4,700 to recruit in-house (SHRM) or 15–25% of base via a recruiter — and typically two to four months of hiring before any code ships.
- US freelancers run from marketplace rates to $100–$300 an hour for seasoned independents ($81–$100 average on vetted networks): fastest start, but a bus factor of one, and the management stays with you.
- Credible US agencies run about $90–$250 an hour and buy you a structured team; guard against dependency with your repo, documentation and a handover clause from day one.
- Combining models — external delivers while you recruit — usually beats both waiting and panic-hiring; the cost of delay is what makes the external premium rational.