Founders default to "fixed price please" the way kids default to "extra cheese please", it's the safe-feeling option. The problem is, fixed price is only safe when the scope is fixed, and most software projects don't have fixed scope.
Here's the honest comparison, with the model most experienced Australian developers actually use for serious work.
When fixed price wins
Fixed price genuinely works for projects where:
- The scope is well-understood by both sides. You can write it down in two pages and the developer agrees.
- The project is short, usually under twelve weeks. Long fixed-price projects accumulate scope risk that nobody can price for.
- Integrations are minimal or well-documented.
- You're not planning to learn anything from your users mid-build.
Brochure websites, Shopify theme builds, single-feature integrations, audits, and discovery sprints are all good fixed-price candidates.
When hourly wins
Hourly works when:
- The scope is genuinely undefined, you're exploring an idea, not building a known product.
- The work is research-heavy: reverse-engineering an old codebase, evaluating a stack, debugging.
- You need a developer on-call to fix things as they come up.
- You have your own technical team and are augmenting it, not delegating to it.
Done well, hourly is honest. Done badly, it's an unbounded liability. The fix is a weekly cap and weekly visibility.
The hidden third option: phased fixed price
Most senior Australian developers won't quote a single fixed price for a 16-week project. What they'll quote is:
- A small fixed-price discovery sprint (1–2 weeks, $1.5k–$5k) that produces a written scope.
- A fixed-price phase one based on that scope (4–8 weeks).
- Re-scoping at the end of phase one, then a fixed-price phase two.
This is the model that actually works. Each phase is short enough to estimate accurately. Each re-scope keeps the work aligned with what you've learned. And you can stop at any phase boundary without paying for unused work.
The honest middle ground is a series of small fixed prices, not one big one.
What scope creep does to each model
Scope creep is the silent killer of fixed-price projects. Here's why:
- Fixed price + scope creep + no change orders = the developer absorbs the cost, quality collapses, the relationship sours, the project ships late and bad.
- Fixed price + scope creep + formal change orders = transparent re-pricing, the project ships on the new terms, everyone's relationship survives.
- Hourly + scope creep = your bill goes up, but at least you can see it in real time.
If you go fixed price, the only safe path is a formal change order process. If you'd rather not deal with that, hourly with a cap is simpler.
Per-day vs per-hour
If you do go hourly, prefer per-day rates. Why: per-hour incentivises the developer to itemise their day into 15-minute chunks for billing, which is awful for everyone. Per-day means you both agree on whether they were "on it today" or not. Senior Australian rates land around $1,200–$1,800 per day for individuals, $1,800–$3,000 per day for small studios.
Retainers
For ongoing work after launch, retainers beat both. A typical retainer is 20–40 hours/month at a discounted blended rate, with a use-it-or-lose-it clause. The developer gets predictable income; you get a predictable response time and a predictable bill.
The bottom line
Use fixed price for known, short projects. Use hourly for genuinely undefined work. Use phased fixed price for everything else, which is most things.
If you want three quotes that all use the same billing model on the same brief, FindDevs gets you that comparison, free, in 24 hours.