TL;DR
For nearly every MVP, fixed-price is the right billing model: it forces scope clarity before anyone writes code, caps your budget, and aligns the vendor's incentive with shipping rather than logging hours. Hourly (time-and-materials) only makes sense when the work is genuinely open-ended research that cannot be scoped in advance. An MVP, by definition, can be scoped, one core flow, a defined outcome, so it should be.
The real catch is not choosing between the two in theory. It is that many agencies market "fixed-price" while running hourly underneath, using vague scope and change orders to bill more mid-project. So the practical skill is spotting fake fixed-price, covered below.
What each model actually is
- Fixed-price: the vendor quotes one price for a defined scope, locked in writing before work begins. If the scope does not change, the price does not change. The vendor carries the risk that the work takes longer than expected.
- Hourly (time-and-materials): you pay for time spent, at an hourly or daily rate, for as long as the work takes. You carry the risk that it runs long. There is no ceiling unless you impose one.
That single difference, who carries the risk of the work running long, drives everything else.
Fixed-price: what you gain and give up
The upside:
- A capped budget. You know the number before you commit. For a founder protecting runway, that predictability is the whole point.
- Scope clarity, forced. A fixed price cannot be quoted without a written scope, so both sides agree on exactly what "done" means up front. That single document prevents most disputes.
- Aligned incentives. The vendor is paid to ship the agreed scope, not to accumulate hours. Fast, efficient delivery is in their interest, not against it.
The trade-off:
- Less flexibility mid-build. Changing direction means a change order, re-scoped and re-priced, rather than just redirecting hours.
- Requires an up-front scope. You have to know what you want built before you start (which, for an MVP, you should, see how to scope an MVP).
Hourly: what you gain and give up
The upside:
- Total flexibility. Change direction any week; you are just buying time, so there is nothing to re-negotiate.
- Fits genuine unknowns. For open-ended R&D, an experimental algorithm, an unproven technical approach, where nobody can define "done" in advance, hourly is honest and appropriate.
The trade-off:
- No budget ceiling. The meter runs until the work is done, and "done" can drift. Overruns are the norm, not the exception.
- Misaligned incentives. The vendor is paid by the hour, so efficiency reduces their revenue. That does not make agencies dishonest, but the structure quietly rewards slower work.
- You become the risk-holder and the manager. Watching hours, questioning estimates, and policing scope all fall to you.
Fixed-price vs hourly: side-by-side
| Factor | Fixed-price | Hourly (T&M) |
|---|---|---|
| Budget | Capped, known up front | Open-ended, runs until done |
| Who carries scope risk | The vendor | You |
| Scope | Defined and locked before work | Can stay loose |
| Incentive | Ship the agreed scope efficiently | More hours = more revenue |
| Flexibility mid-build | Change orders | Redirect hours freely |
| Best for | Any scopeable MVP | Genuine open-ended R&D |
When fixed-price wins (which is nearly every MVP)
An MVP is a defined experiment: one core flow, built to test one hypothesis, with a clear "done." That is exactly the situation fixed-price exists for. If the work can be scoped, and an MVP always can, fixed-price transfers the risk to the party best able to manage it (the builder) and protects the party who cannot afford surprises (you). For a founder on limited runway, a capped, predictable price is worth more than the flexibility hourly offers, especially since the "flexibility" of hourly is mostly the flexibility to overrun.
When hourly actually makes sense
Hourly is the honest choice in a narrow set of cases:
- True R&D where the outcome is genuinely unknown and cannot be specified in advance.
- Ongoing iteration after launch, where you want a team on retainer to work a shifting backlog week to week.
- You have real technical capacity to scope, direct, and police the work yourself.
Notice none of these describe the initial MVP build. Post-launch iteration, maybe. The first build of a scopeable product, rarely.
How to spot fake fixed-price (hourly in disguise)
This is the part that actually matters, because the trap is not "fixed-price vs hourly", it is "real fixed-price vs hourly wearing a fixed-price label." Watch for these signals that a "fixed price" is really hourly:
- No written scope with an exclusions list. A real fixed price is quoted against explicit inclusions and exclusions. A two-line scope will be expanded into change orders.
- An hourly rate buried in the contract. If the agreement contains "additional work at $X/hour," the engagement is fundamentally hourly.
- No acceptance criteria. Without written criteria per feature, "done" is whatever the vendor decides, and revisions are unbounded.
- The quote moves after the first call. A genuine fixed price holds unless you change the scope in writing.
- A vague change-order process. "We'll figure it out as we go" means the meter is running.
A real fixed-price vendor will happily show you a scope document, a written change-order process, and code ownership from day one. If any of those is missing, you are looking at hourly billing in a fixed-price costume, which is exactly the risk you were trying to avoid. (More warning signs in our guide on choosing an MVP development agency, and the exact document to demand in our MVP RFP template.)
The honest recommendation
For the initial build of an MVP: insist on fixed-price, tied to a written scope with explicit exclusions, acceptance criteria per feature, a clear change-order process, and code ownership on day one. Reserve hourly for genuine post-launch iteration or true R&D. The billing model is not a detail, it decides who absorbs the risk when reality diverges from the plan, and for a founder, that should not be you.
This is exactly why we work the way we do at MVP Development: a fixed, scoped quote you approve before we start, a funding-ready MVP in 3–4 weeks, and code you own outright, so the price you agree to is the price you pay.
Want a real fixed-price scope for your MVP? Tell us what you're building and we'll scope it, in writing, before you commit.
Related guides
- Freelancer vs agency for an MVP — who to hire, before you decide how to pay them
- How to choose an MVP development agency — the criteria and red flags
- MVP RFP template — the document that locks fixed-price scope
- How much it costs to build an MVP — real budget ranges
Frequently asked questions
Is fixed-price or hourly better for an MVP?
For nearly every MVP, fixed-price is better. An MVP is a scopeable, defined build, so a fixed price caps your budget, forces scope clarity up front, and aligns the vendor's incentive with shipping rather than logging hours. Hourly is only the right choice for genuinely open-ended R&D that cannot be scoped, or for ongoing post-launch iteration.
Why do some agencies prefer hourly billing?
Because hourly transfers the risk of the work running long from the agency to you, and because efficiency reduces the agency's revenue under an hourly model. It is not inherently dishonest, but the structure rewards slower work and removes your budget ceiling, which is why founders are usually better served by a true fixed price.
What is a fake fixed-price contract?
A fake fixed-price contract markets a fixed price but runs hourly underneath, using a vague scope, an hourly add-on rate in the contract, and change orders to bill more mid-project. Signs include no written exclusions list, no acceptance criteria, a quote that changes after the first call, and an hourly rate buried in the terms.
What should a real fixed-price MVP contract include?
A written scope with explicit inclusions and exclusions, acceptance criteria for each feature, a defined change-order process (small changes rolled in, large ones re-scoped at a fixed price), a payment schedule, and code ownership from day one. If any of these is missing, the "fixed price" is effectively hourly.
Can I switch from fixed-price to hourly later?
Yes, and it is common. Many founders use fixed-price for the initial scoped MVP build, then move to an hourly or monthly retainer for post-launch iteration, where the backlog shifts week to week and a fixed scope no longer fits. Fixed-price for the build, flexible billing for what comes after, is a sensible default.
Sources & references
- Eric Ries, The Lean Startup — scoping an MVP to a defined experiment
- Y Combinator, Startup Library — practical guidance on hiring and contracting early
This guide reflects standard software-contracting practice applied to lean MVP builds; adapt the specifics to your project and jurisdiction.
