Every freelancer eventually has this argument with themselves: “Should I bill hourly or fixed-price?” The correct answer isn’t one or the other, it’s knowing which model fits which project. Pick wrong and your margins vanish, the client gets frustrated, or both. Pick right and the engagement runs smoothly and profitably.
Billing model is one of the most underweighted decisions in freelance work. Most freelancers default to whatever they used last time. The model should be chosen deliberately per project, based on the work type, the client’s behavior, and the risks.
A decision framework that actually works.
The three models (and their real tradeoffs)
Get the three models clear first.
Hourly billing
You charge: a rate per hour worked. Client pays based on hours logged.
Best for:
- Open-ended or exploratory work where scope truly can’t be pre-defined
- Strategic advisory and consulting
- Work where the client wants you “on call” in an unpredictable capacity
Worst for:
- Work with a clear, quantifiable deliverable
- Any project where you’re faster than the client expects (you get punished for being skilled)
- Clients who micromanage by the hour
Real risk: your income is capped by your hours. Better, faster work = less money. Creates misaligned incentives.
Fixed-price billing
You charge: a total price for a defined scope. Client pays regardless of hours spent.
Best for:
- Work with a clear deliverable and clear scope
- Projects where you can reasonably estimate effort
- Situations where the client wants predictable cost
Worst for:
- Scope that’s genuinely uncertain
- Clients with histories of scope creep
- Work requiring deep strategy that’s hard to pre-scope
Real risk: if scope expands or you misestimate effort, you eat the cost. Requires accurate estimation and strict scope control.
Milestone billing
You charge: a total price split across defined milestones. Client pays as each milestone completes.
Best for:
- Longer projects (6+ weeks)
- Phased work where each phase has a clear output
- Situations where client wants predictable cost but also wants to see progress before full payment
- Larger engagements where a single lump sum would stress client cash flow
Worst for:
- Short projects (under 3 weeks) where milestone overhead isn’t worth it
- Work with tightly-coupled phases that can’t be clearly delineated
Real risk: if the client wants to end the engagement mid-project, what you’ve earned vs what’s been delivered can get contentious.
The best freelance billing model is the one that aligns your incentives with the client’s. Hourly pays you more for slower work. Fixed-price punishes you for unexpected scope. Milestone balances predictability with progress. Pick the one whose incentives match the project you’re actually doing.
The decision framework
Four questions. Answer honestly. The answers dictate the model.
Question 1: Can I define the deliverable precisely?
Yes, with specific outputs and quality thresholds: fixed-price or milestone works.
Partially, but the scope is uncertain: hourly works, or milestone with flexible phases.
No, this is pure advisory/exploratory: hourly.
Question 2: Can I estimate the effort within 20%?
Yes: fixed-price or milestone.
Within ±50%: milestone (lets you adjust between phases).
No idea: hourly.
Critical caveat: if you can’t estimate effort within 20% for work you’ve done before, the issue might not be the work, it might be your scoping process. See how to write a statement of work.
Question 3: What’s the client’s history with scope and feedback?
Clear-minded, decisive, sticks to scope: fixed-price or milestone safe.
Hard to pin down, scope evolves, feedback in waves: milestone with strict change-order terms, or hourly.
New client with no history: default to milestone with clear phases, it’s the lowest-risk middle ground.
Question 4: How long is the project?
Under 2 weeks: fixed-price simplest.
2–8 weeks: fixed-price or milestone.
8+ weeks: milestone (cash flow for both sides).
Ongoing / open-ended: retainer (different model, see the retainer transition).
Worked examples
How the framework actually applies.
Example 1: “Rebuild our landing page”
- Clear deliverable? Yes (one page, defined format)
- Effort estimable? Yes (within 15%)
- Client scope history? Reasonable
- Timeline? 3 weeks
Answer: fixed-price. Clear scope, clear effort, short timeline = no reason to complicate.
Example 2: “Help us figure out why our onboarding is broken”
- Clear deliverable? No (diagnostic work)
- Effort estimable? No
- Client scope history? Uncertain, depends on what you find
- Timeline? Unknown
Answer: hourly, with a cap (“not to exceed $X without re-scoping”). The work is exploratory; pay should reflect that.
Example 3: “6-month marketing strategy + execution”
- Clear deliverable? Partially (strategy doc is clear, execution is flexible)
- Effort estimable? Within 30%
- Client scope history? Decent
- Timeline? 6 months
Answer: milestone. Phase 1 = strategy (fixed-price). Phases 2–4 = execution sprints (each fixed-price). Total known at signing, cash flow spread.
Example 4: “Fix the bugs in our app”
- Clear deliverable? Tricky, can’t know all bugs
- Effort estimable? Per bug, yes. Total unknown.
- Client scope history? N/A
- Timeline? Ongoing
Answer: hourly (or, better, productized as “X hours/month retainer”). Pure bug work has no ceiling; effort and output are decoupled from “a deliverable.”
Example 5: “Build a brand from scratch”
- Clear deliverable? Yes (logo, guide, assets)
- Effort estimable? Within 20% if you’ve done it before
- Client scope history? Will feedback be decisive?
- Timeline? 6–8 weeks
Answer: milestone, with explicit revision limits. Phase 1 = concept direction (fixed). Phase 2 = refinement (fixed). Phase 3 = final assets (fixed). Revisions beyond 2 per phase = change order.
The hybrid model (often the smartest choice)
Sometimes the right answer isn’t any single model, it’s a combination.
Common hybrid: fixed-price with hourly add-ons.
“$8K for the defined scope. Any additional work beyond scope billed at $200/hour with written change-order approval.”
This covers:
- Predictable pricing on the core work
- A clear path for scope additions without negotiation drama
- Hourly protection on the “one more thing” requests
Most senior freelancers default to this hybrid for 70%+ of their work. It’s the best of both worlds.
Another hybrid: milestone with hourly strategic component.
“Phases 1–4 = fixed price. In addition, 10 hours/month of strategy at $300/hour for ongoing advisory throughout the engagement.”
Useful when the execution work is well-defined but the client also wants your strategic input as things evolve.
What to include in each model’s contract
Hourly contract essentials:
- Rate per hour, stated clearly
- Minimum billing increment (e.g., 15 minutes)
- How hours are tracked (tool used, what counts as billable time)
- Invoicing cadence (weekly, biweekly, monthly)
- Any retainer/deposit structure
- Cap (if any) and what happens when approached
Fixed-price contract essentials:
- Total price
- Detailed scope (this is the key)
- Exclusions (see how to write a statement of work)
- Revision policy
- Payment schedule (deposit, milestones, final)
- Change order process
Milestone contract essentials:
- Total price, split into milestones
- Each milestone’s deliverable defined
- Milestone acceptance criteria
- Payment trigger per milestone (usually on delivery, sometimes on approval)
- What happens if a milestone is rejected
- Termination language per phase
Common billing model mistakes
Billing hourly when you’re efficient. If you’re 3x faster than competitors at the same work, hourly punishes you. Switch to fixed-price or value-based and capture that speed as margin.
Fixed-pricing genuinely uncertain work. If you don’t know what the work actually is, fixed-pricing means you’re betting on a guess. Do a paid scoping phase (1–2 weeks, hourly) to get to a fixed-price later.
Using hourly for work clients perceive as commodified. Clients who see your work as a commodity will always find someone cheaper to do the hours. Your job is to move the conversation off hours and onto outcomes, usually via fixed-price or milestone framing.
Milestones without clear acceptance criteria. “Phase 1 = strategy” isn’t a milestone. “Phase 1 = delivered strategy doc accepted by client via signed approval form” is. Without criteria, milestones drag.
Not repricing as work evolves. If you signed fixed-price at $10K and scope has grown 40%, that isn’t scope creep, it’s a pricing failure. Re-scope and re-price. See how to write a statement of work for the change-order process.
What to pick for your first few projects
If you’re newer and don’t have a sense of your estimation accuracy yet:
- Fixed-price for short, well-defined work (landing page, logo design, single deliverable)
- Milestone for medium projects with clear phases
- Hourly only for exploratory or pure advisory work
Avoid hourly for routine work until you’ve proven you can hold scope. Hourly for a freelancer who hasn’t mastered scope control is a trap.
Related reading
- How to write a statement of work, governs fixed-price and milestone
- The retainer transition, the fourth model, different case
- Client revisions: the 2-round rule, revision policy cross-model
The mindset shift
The freelancers who chronically underprice aren’t always cheaper, many are stuck in hourly billing on work that should be fixed-price. Moving to the right model for the right project can double effective hourly rate without changing your actual rate.
Audit your last 5 projects. Which billing model did you use? Would a different model have worked better for that specific project? The lessons from the audit inform the next 5.
The goal isn’t to pick a favorite model. It’s to have all three in your toolkit and pick deliberately for each engagement.
Ready to send stronger proposals?
Build, send, and track proposals in one place so follow-up is easier.
Start your free trial →
