How to Price a Freelance Project (Fixed Fee vs Hourly)

Every freelance proposal eventually forces the same two decisions: fixed fee or hourly, and how much. Freelancers usually treat the first one as a personality trait — "I just don't do hourly" — but it isn't a preference, it's a risk allocation. A fixed fee puts the risk of a bad estimate on you; hourly puts it on the client. Neither is more professional than the other, and picking the wrong one for a given project is how a job that looked profitable on the proposal ends up paying less than minimum wage by the time it's delivered. Below is how to choose between them project by project, how to estimate the hours behind either number without lying to yourself, how big a buffer to build in for the scope creep that shows up on almost every job, and — the step most freelancers skip entirely — how to check the fee you quoted against what you actually earned per hour once the work is done.

Fixed fee or hourly: how to actually decide

Ignore which one sounds more "professional." Ask instead: who should hold the risk if the estimate is wrong?

Quote fixed fee when the scope is genuinely bounded. You have a written brief, a defined set of deliverables, a revision limit you can enforce, and — ideally — you've done something close to this before, so your hours estimate is based on real data rather than a guess. Under those conditions a flat fee is good for both sides: the client gets budget certainty for their own approval process, and you get rewarded for working efficiently instead of being paid more for being slower.

Quote hourly when the scope is not actually fixed yet. A client who says "we'll figure it out as we go," a project with no written brief, an early-stage startup that will pivot mid-build, or a scope so novel you have no reference point for how long it takes — none of that is fixed-fee territory, no matter how much the client wants a single number. Quoting a flat fee on undefined work isn't confidence, it's a guess wearing a quote's clothing, and you eat every hour past the guess at zero marginal pay. The honest move is to bill hourly, or to sell a short, explicitly hourly discovery phase first — a scoping call, a technical audit, a content outline — and only convert to a fixed fee once that phase produces a real brief.

Use a day rate when you're thinking in days, not hours. Consulting engagements, on-site work, workshops, and audits are often easier to scope and bill in days than in fragments of an hour. The math underneath is identical to an hourly or project rate — income needed, divided across the units you can actually bill — the Day Rate Calculator just runs it in day-sized units instead of hour-sized ones.

Attorney and small-business author Stephen Fishman puts the general principle plainly in Nolo's guide to pricing your services: you can't set a sensible fixed fee "unless you know roughly how many hours the job will take and what you need to earn per hour to make it worth your while." A flat number that skips that step isn't a price, it's a hope.

Estimate your hours like you'll be graded on it

Whichever pricing model you land on, the hours estimate underneath it is where most bad quotes actually go wrong — not the rate, the hours.

Break the project into its real phases — discovery, drafts, revisions, delivery, handoff — and estimate each one separately rather than eyeballing a single number for the whole thing. A single gut-feel total almost always undercounts, because it's easy to picture the "doing the work" hours and easy to forget the kickoff call, the file organizing, the three follow-up emails, and the last-minute export in a format nobody mentioned in the brief. Estimating phase by phase forces you to name those hours instead of letting them disappear into a rounding error.

Anchor the estimate in real data whenever you have it. If you've done similar work before, pull the actual hours a comparable project took — not the hours you quoted for it, the hours it really consumed — and start from there. If this is genuinely new territory, say so honestly to yourself: pad the estimate itself only as much as your actual uncertainty justifies, and let the separate risk buffer (below) absorb the rest. Mixing the two — quietly inflating the hours estimate because you're nervous, instead of naming a buffer explicitly — makes it impossible to tell later whether your estimating skill or your bad luck was the problem.

Resist estimating client-facing hours only. Revisions, status calls, and "quick" async questions are real hours that a client rarely sees as part of "the work," but they cost you the same as anything else on the timesheet. If you don't already track actual hours against your estimates on past projects, start now — the Effective Hourly Rate Calculator later in this guide is exactly the tool for turning a finished project into the data point your next estimate should be built on.

Turn the estimate into a price — with a real buffer

Once you trust the hours estimate, converting it into a fixed-fee quote is simple arithmetic with one deliberate extra step: hours × rate gets you a base price, and a percentage buffer on top of that base price is what actually protects you from the gap between what you estimated and what the project turns out to need.

How big should the buffer be? For a well-scoped project, a clear written brief, and a client you've worked with before, 10-15% is usually enough — most of the uncertainty is already priced out by a good hours estimate. For a vague scope, a first-time client, or a project that needs a lot of stakeholder sign-off (more people approving, more rounds of "one more thing"), push it to 20-30%. The less certain the estimate, the more the buffer needs to carry.

If the project also involves costs billed at cost rather than at your hourly rate — stock footage, a font or plugin license, a subcontractor for one piece of the job — add those in separately as fixed extras rather than folding them into the hourly math, so a client can see labor and pass-through costs as two different lines.

Say a project is estimated at 60 hours, your rate is $85 an hour, you're quoting a new client so you set a 20% risk buffer, and the project needs $250 of stock assets billed at cost:

• Base price: 60 × $85 = $5,100
• Risk buffer: $5,100 × 20% = $1,020
• Recommended price: $5,100 + $1,020 + $250 = $6,370

Treat that $6,370 as a floor, not a final answer. You can quote higher if the deadline is tight or the work is unusually high-value — but quoting lower means working for less than your own rate the moment the buffer gets used up, which, as the next section shows, happens more often than freelancers expect.

A buffer helps — it doesn't guarantee the math holds

A risk buffer improves your odds; it doesn't promise a specific outcome. The only way to know whether a fixed fee actually held up is to compute what it paid per hour once the real hours are in, counting every bit of time the project cost you — not just the hours you'd planned to bill.

That's a different number from your quoted rate. A quoted rate reflects the hours you priced for; an effective hourly rate divides the net fee by every hour the project actually consumed, billed or not. The gap between the two is the real, dollar cost of scope creep.

Continue the example above. You delivered the project for the quoted $6,370, with the same $250 in direct costs. The 60 hours you estimated turned out to be right for the billable work, but revisions and client calls added 15 hours you never separately charged for — 75 hours total — against a $85 target rate:

• Total hours: 60 + 15 = 75
• Net fee: $6,370 − $250 = $6,120
• Effective hourly rate: $6,120 ÷ 75 = $81.60
• Gap to target: $85 − $81.60 = $3.40 under target

The buffer didn't fully absorb the 15 extra hours, but it did most of the work. Run the same overrun against a fee that skipped the buffer entirely — just the $5,100 base plus the $250 in extras, or $5,350 — and the net fee of $5,100 spread across the same 75 hours comes out to an effective rate of $68, a full $17 under target instead of $3.40. That $13.60-an-hour difference is the buffer, in cash terms, doing exactly what it's for.

When hourly — or a discovery phase — is the safer quote

Some projects should never get a fixed fee, no matter how good your estimating process is. If the client can't describe the deliverable in writing, if "we'll know it when we see it" is the actual brief, or if the project is likely to change direction after you've started, a flat number isn't confidence — it's a guarantee that you'll eventually be working for free. Quote hourly instead, or sell a short, explicitly hourly discovery phase and convert to a fixed fee only once that phase produces a real, written scope. A client who resists paying for discovery at all is usually signaling that they don't yet know what they want either — worth knowing before you commit to a number.

Five pricing mistakes that quietly cost you

Quoting fixed fee on a scope that isn't actually fixed. A flat number attached to "we'll figure it out as we go" isn't a price — it's an unpaid discovery phase you agreed to do for free.

Estimating hours from how the work should go, not how it has actually gone. If you have real numbers from past projects, use them. If you don't, this project is your first data point — write down the actual hours when it's done so the next estimate is better than a guess.

Skipping the buffer because a client "seems easy." New clients are the least predictable ones you have, not the most — you have no track record with them yet, which is exactly the situation the buffer exists for.

Treating small extra requests as free because each one feels minor. Five 20-minute "quick fixes" a week for six weeks is 10 unpaid hours — the same pattern the risk buffer is meant to absorb, just delivered in pieces small enough to not notice. Run a finished project's real numbers through the Scope Creep Calculator to see the dollar cost in one figure instead of a dozen small ones. Using that tool's own default example — a 40-hour quote that ran to 55 hours at a $75 hourly rate for a $3,000 flat fee — scope creep cost $1,125 in lost value, dropped the effective rate to $54.55 an hour, and represented a 37.5% hours overrun on the original quote.

Never closing the loop. Quoting well is only half the skill. Comparing the quote to what the project actually paid per hour — the effective hourly rate calculation above — is what turns this project's mistakes into next quote's improvements instead of repeating them indefinitely.

Put the scope in writing, not just in your head

A buffer protects you from honest uncertainty; it isn't meant to absorb an undefined scope indefinitely. Before you send a fixed-fee quote, write down what's included in plain terms a client will actually read: the number of pages, the number of revision rounds, the deliverable formats, the response-time window. Anything a client asks for beyond that written list is a change order — a separate, paid addition — not scope you silently absorbed because saying so felt awkward. Freelancers who skip this step tend to blame their buffer for being too small; more often, the real problem is that nothing defined where "included" ended and "extra" began.

If your client is in a materially different cost-of-living market than you are, don't assume your usual rate transfers unchanged in either direction — the Freelance Cost-of-Living Index rebases living costs across 18 countries so you can adjust a baseline rate before running the rest of this math on top of it.

This guide offers general pricing frameworks and planning tools — it's not a substitute for professional financial or business advice tailored to your specific situation.

Methodology & sources

The fixed-fee math above matches the Project Price Calculator embedded in this guide exactly: basePrice = estimatedHours × hourlyRate, buffer = basePrice × riskBufferPercent, and recommendedPrice = basePrice + buffer + fixedExtras. The effective-rate check matches the Effective Hourly Rate Calculator: netFee = projectFee − directCosts, effectiveHourlyRate = netFee / (billableHours + nonBillableHours), and gapToTarget = targetRate − effectiveHourlyRate. The scope-creep example matches the Scope Creep Calculator: lostValue = (actualHours − quotedHours) × hourlyRate, effectiveHourlyRate = fee / actualHours, and overrunPercent = (actualHours / quotedHours − 1) × 100.

For the broader case that a defensible fixed fee has to start from an hours estimate and a target hourly rate — never the other way around — see Nolo's How Much Should You Charge for Your Services?, written by attorney Stephen Fishman for independent contractors and small-business owners pricing their own work.