Most founders evaluate agencies on portfolio, references, and price. Reasonable. But the pricing model — not the price — is the variable that most reliably predicts whether the project goes well.
Because the pricing model decides what happens when things get hard. And on a software build, things always get hard.
The two incentive structures
Hourly. The agency is paid for time spent. Their revenue rises with hours. Efficiency reduces their income.
Fixed scope. The agency is paid an agreed amount for an agreed deliverable. Their margin rises with efficiency. Extra hours come out of their pocket.
Nobody involved is dishonest. Good agencies exist under both models. But incentives are gravity — they do not force outcomes, they just make certain outcomes easier to fall into.
Here is where each model bends.
Where hourly bends
Discovery expands. Under hourly, the exploration phase has no natural stopping point. Every additional workshop, every extra stakeholder interview, is billable and defensible. Three weeks of discovery becomes seven. Nobody did anything wrong.
Nobody says "you don't need that." You ask for a feature that will not help you. Under hourly, building it is revenue. The agency may still tell you it is unnecessary — good ones do — but they are arguing against their own invoice, which is a thing you have to be quite principled to do consistently.
Rework is neutral. If a build has to be redone because a requirement was misread, you pay for both attempts. The agency has no financial reason to prevent the first mistake.
You cannot budget. "Roughly 200 hours" is not a number you can plan a runway around. Software estimates are famously unreliable, and under hourly the entire variance lands on you.
The relationship inverts. You start monitoring hours instead of outcomes. Every status call has a quiet subtext about burn rate. Trust degrades even when nothing is wrong.
Where fixed scope bends
Fixed scope is not the obvious winner. It has its own failure modes and they are just as real.
Scope becomes the battlefield. Every request triggers the question "is that in scope?" You wanted a partner; you have a contract negotiation running in parallel to the work. This is the single most common complaint about fixed-price engagements and it is legitimate.
Quality is where the margin hides. If the agency is losing money, the invisible things get cut first — test coverage, error handling, documentation, edge cases. You cannot see any of this at handover. You see it in month four when something breaks and nobody can fix it quickly.
Padding. A competent agency prices in risk. You are paying an insurance premium on their uncertainty. If the project goes smoothly, that premium was pure margin. This is fair — they carry the downside — but it means fixed price is rarely the cheapest option in the good case.
It punishes learning. The most valuable thing that happens on a software project is discovering, in week three, that the real problem is different from the one you scoped. Under a rigid fixed-scope contract, that discovery is a commercial problem rather than a win. Agencies under margin pressure become quietly incentivised not to surface it.
That last one is the serious objection, and it is why "just always do fixed price" is bad advice.
The variable that actually decides
Both models work when one condition holds and fail when it doesn't:
Fixed scope requires that the scope be knowable before you start.
That is it. Everything else is detail.
Some work is genuinely knowable in advance. Rebuild this specific workflow. Integrate these two named systems. Build a batch record module with these fields and this approval flow. You can specify it, price it, and hold both sides to it.
Other work is genuinely not. "Fix our operations" is not a scope. Neither is "we know things are broken but not exactly where." Trying to fix-price that produces either a padded number or a scope document written before anyone understood the problem — which is the same thing as no scope document.
The failure in most agency relationships is not choosing the wrong model. It is applying a fixed-price contract to unknowable work, or applying hourly to work that was perfectly specifiable.
The structure that resolves it
The way out is not to pick one. It is to separate the two phases.
Phase 1: a small, fixed-price engagement whose deliverable is the specification.
Short. Two weeks or so. Fixed cost, deliberately low. The output is not software — it is a documented map of the operation, a defined scope, a technical approach, and a fixed price for the build.
This works because scoping is knowable work even when building isn't. You can fix-price the discovery precisely because its deliverable is a document, not a system.
Phase 2: fixed-price build against that specification.
Now the scope exists, written by people who spent two weeks inside your actual operation rather than guessing from a sales call. Both sides can commit to it honestly.
The properties this structure has that neither pure model does:
- You can exit cheaply. After phase 1 you hold a specification and a price. If the agency was wrong for you, you have lost two weeks and a small fee, and you own a document you can take to someone else. Under hourly you find out three months and a large invoice later.
- The estimate is grounded. Fixed prices quoted before discovery are guesses with padding. Fixed prices quoted after discovery are estimates.
- Incentives align on the build. The agency profits from being efficient. You have budget certainty.
- Change requests are honest. Because there is a real baseline, "that's out of scope" is a factual statement rather than a negotiating posture.
The obvious critique is that the discovery phase is a sales mechanism. It is, partly. But it is a sales mechanism that leaves you with a usable asset if you walk away, which distinguishes it from a free proposal designed to be un-shoppable.
Questions to ask before signing
Regardless of model:
"What happens when we discover the scope was wrong?" The answer reveals more than any other question. A good answer describes a process. A bad answer is reassurance.
"Who owns the code and the repository, from day one?" Should be you, in your account, from the first commit. Not at final payment. If there is hesitation here, stop.
"What is the deployment and handover process?" Ask specifically about documentation, environment setup, and what happens if you want a different developer to take over in a year.
"Can I speak to a client whose project went badly?" Every agency has one. Willingness to connect you is a strong signal. Every reference is a success story; the informative case is the failure.
"Is testing in scope, and how is it evidenced?" Under fixed price this is where margin gets recovered. Make it explicit.
The short version
Hourly billing means the agency profits from the project taking longer. Fixed scope means they profit from it going faster — and from cutting things you cannot see.
Neither is a character judgement. Both are gravity.
The structure that works is: fix-price the discovery, produce a real specification, then fix-price the build against it. Small commitment, cheap exit, aligned incentives, and — importantly — a written artefact you own either way.
If an agency will not price the discovery separately, ask why. If they quote a fixed price for a build before understanding your operation, that number is a guess wearing a suit.
Custom Mango runs a two-week FoundationSprint — a fixed-price discovery that produces a documented operational map, a defined scope, and a fixed build price. The fee is credited against the build if you proceed. Book a FoundationSprint.
Custom Mango builds operational software for growing food, supplement and beauty brands. If this article hit close to home, book a free discovery call — the first conversation is about your business, not about software.