Agency, freelancer, or Sprint? How to actually pay for a software build

TL;DR

There are three honest ways to pay for a software build, and the right one depends on who should carry the risk of a wrong estimate:

• A freelancer (hourly) is right when the scope is a single, well-shaped task, your in-house team owns the product decisions, and your timeline is soft. You carry the estimate risk — every hour of scope creep is on your invoice.
• An agency on a retainer (hourly or monthly) is right when the work is continuous and priorities shift weekly. You still carry most of the estimate risk; the meter runs until the work is done.
• A fixed-price Sprint is right when the deliverable is clear and you want the vendor to carry the estimate risk. The price is set on day one; if it takes longer than planned, that's the agency's problem, not your budget's.

We're an agency that bills the third way — fixed-price 14-day Sprints — and this post is the argument for why, including the cases where we'll tell you to hire one of the other two instead.

The thing nobody prices: who eats the overrun

Every "how much does it cost" conversation starts in the wrong place — on the rate. A freelancer at CAD 80–180/hr looks cheaper than an agency at CAD 150–300/hr, which looks cheaper than a $15,000 fixed Sprint until you do the arithmetic on hours. So people pick the low hourly number and feel smart.

The rate is the part of the deal that's easy to compare, which is exactly why it's the wrong thing to compare. The number that actually decides what you pay is who absorbs the gap between the estimate and reality — and software estimates are wrong by default. The interesting question isn't "what's the rate," it's "when this takes 40% longer than anyone thought, whose problem is that?"

• Hourly freelancer: your problem. The meter runs through every surprise.
• Retainer: mostly your problem. The relationship is open-ended, so "a bit more time" is the path of least resistance for everyone.
• Fixed-price Sprint: the agency's problem. We quoted it; if we were wrong about the effort, we eat the difference.

That single line is the whole pricing philosophy. We moved to fixed-price Sprints because it's the only model where the people who write the estimate are the people who pay when it's wrong — which is the only model that makes us genuinely careful about scope.

When a freelancer is the right call (and we'll say so)

We publish this on our agency-vs-freelancer comparison page and we mean it: for a single, well-scoped task, hire a freelancer. If you need one LangChain pipeline built, or a model fine-tuned, or a specific feature shipped — and you have an in-house tech lead who can spec it and review the code — a good freelancer is faster to start and cheaper to finish. We'll sometimes refer you to one we trust.

The freelancer math works on exactly one condition: scope doesn't drift. A freelancer wins on cost only when the brief is so tight there's nothing to negotiate mid-build. The moment the work sprawls across disciplines — LLM and the UI and auth and billing and deployment — you've stopped buying execution and started buying coordination, and coordination is the thing one person can't sell you.

The honest risk to name is bus-factor: one person gets sick, takes a vacation, or takes a job at OpenAI, and your project stops. For a two-week task that's a rounding error. For a three-month build it's the single biggest threat to your launch date.

When an open-ended retainer earns its keep

Retainers get a bad reputation from people who've been burned by a meter that never stops. But the model is right for one real situation: continuous work where priorities shift weekly. If what you actually need is team augmentation — an ongoing partner who picks up whatever's on top of the backlog this week — then trying to express that as a series of fixed quotes is just friction. You'd spend more time scoping than building.

The trap is using a retainer for what is really a one-time build. That's an expensive way to test a relationship: you're paying for flexibility you don't need, and the open-ended structure removes everyone's incentive to finish. Our rule of thumb, which we also publish on the Sprint vs retainer page: start with a fixed-price engagement to test the relationship; move to a retainer once the work is genuinely continuous and you already trust the vendor.

Why we bet on the Sprint

A Creative Brain Sprint is a fixed deliverable, a fixed price, and a fixed window — 14 days for most builds, 5 days for a strategy Sprint. The price is on the pricing page before you ever talk to us. We don't bill hourly for net-new builds.

Three things follow from fixed price that don't follow from hourly:

1. Scope-creep risk moves to us. Because the number is locked on day one, we are the ones who lose when scope balloons. That makes us ruthless about defining the deliverable up front — which is a feature for you, not a restriction. A tightly-scoped two weeks ships more than a vaguely-scoped two months.
2. You can decide on day one whether you can afford it. A range you can see beats a quote you have to wait for. We built a Sprint Cost Estimator precisely so you can check the number against an agency or freelancer equivalent before booking a call — no email required.
3. It's a low-risk way to test us. Two weeks and a fixed price is a cheap audition. If we're good, you come back; if we're not, you've lost a defined, bounded amount. Compare that to discovering three months into a retainer that the fit is wrong.

The trade-off we'll admit: a Sprint is a poor fit for genuinely open-ended work. If your needs change weekly and there's no stable deliverable to point at, forcing it into a fixed scope is the wrong tool — that's a retainer, and we'll tell you so.

The honest comparison, in one table

This is the same framing the estimator uses — the alternative figures there are illustrative industry-average multiples of the Sprint price (roughly 2.4× for an agency, 1.5× for a freelancer on the same scope), not quotes from any named firm. The point isn't the exact dollar; it's the shape of the trade.

| | Freelancer (hourly) | Agency retainer | Fixed-price Sprint | |---|---|---|---| | Headline rate | Lowest (CAD 80–180/hr) | Highest (CAD 150–300/hr) | N/A — priced per deliverable | | Who carries overrun risk | You | Mostly you | The agency | | Cost known on day one | No | No | Yes | | Disciplines covered | One | Many | Many | | Bus-factor risk | High (1 person) | Low | Low | | Best for | One scoped task | Continuous work | A clear, bounded build | | Worst for | Cross-discipline builds | One-time builds | Open-ended work |

There's no universally correct column. There's a correct column for your situation, and the deciding variable is almost never the rate — it's whether the work is bounded, and who you want holding the risk when the estimate is wrong.

Where we land

We chose the Sprint model because it aligns our incentives with yours: we only make money by finishing, on time, at the price we quoted. That's not a moral position, it's a structural one — fixed price forces the discipline that hourly billing lets you skip.

But the model has edges, and pretending it doesn't would make this post marketing instead of a point of view. Hire a freelancer for a single sharp task. Use a retainer for continuous, shifting work with a vendor you already trust. Book a Sprint when the deliverable is clear and you want someone else holding the risk. We do the third one, and we'll happily point you to the first two when they're the right answer — because the client who hears "you don't need us for this" is the client who comes back when they do.

What's next

• This POV pairs with the two comparison pages it links — agency vs freelancer and 14-day Sprint vs monthly retainer — and the Sprint Cost Estimator. Together they're the "how should I pay for this" cluster.
• The remaining C2 content pieces (benchmarks, the Anthropic homepage teardown, the "we don't ship learning agents" POV) are independent and can ship in any order.
• If we ever publish real per-engagement numbers — average overrun absorbed, on-time-delivery rate — this is the post they belong in. Until we have an honest sample size, the argument stays structural, not statistical.