The incentive problem with hourly
Hourly billing pays more when work takes longer. That doesn't make agencies dishonest — it makes the incentive structure point the wrong way. Every hour of an agency's learning curve, every rework, every scope ambiguity becomes your invoice.
It also makes budgets unknowable. You sign up for a rate, not a result, and the total only resolves at the end. For a founder who needs a specific platform shipped on a calendar, that's risk with no ceiling.
What fixed-price actually requires
Fixed-price only works if scope is real. You can't lock a price against a vague idea. That's why a proper fixed-price engagement starts with a scoping phase — architecture, success metric, and dependencies mapped — before a number is quoted.
Done right, the price is grounded in a plan, not a guess. The builder takes on the delivery risk, which means they're motivated to scope carefully and ship efficiently, because overruns come out of their margin, not your wallet.
Handling change without timesheet creep
The common objection is: what if requirements change? In a healthy fixed-price model, changes are handled explicitly as new, separately-priced work — visible and agreed, never silent creep on a timesheet.
That transparency is a feature. You always know what you're paying for, and the conversation about a change happens before the work, not after the invoice.
When hourly still makes sense
Hourly or retainer models fit genuinely open-ended work: ongoing product development where the roadmap evolves every sprint, or an embedded team acting as a permanent extension of your own.
The distinction isn't fixed-price versus hourly in the abstract — it's defined deliverable versus open-ended capacity. For a defined build, lock the scope and price. For continuous evolution, a sprint team or embedded pod with predictable monthly capacity is the better fit.