How Much to Charge as a Freelancer: Pricing Tools

What “charge” means: pick the right model first

When you ask, “how much to charge as a freelancer,” you’re really choosing a pricing model. The right model depends on how clear the work is and how much you want your time to control the price.

Here are the main options:

• Hourly: You charge for time spent. Best when the scope is uncertain or the work will evolve.
• Day rate (or half-day): You charge for a unit of time like a working day. Best for recurring meetings, on-site work, or consulting.
• Fixed project price: You charge one total for a defined scope. Best when deliverables are clear and you can estimate effort.
• Retainer (ongoing): The client pays a recurring fee for a set level of access or work. Best when there’s steady demand and you want predictable income.

Quick rule of thumb:

• If the client can clearly describe deliverables, go fixed project.
• If the work is exploratory or requirements may change, start with hourly or a time + not-to-exceed approach.
• If the client needs ongoing help, use retainer.
• If you’re showing up for workshops, audits, or sessions, a day rate can be cleaner than hourly.

---

Inputs to rate-setting (the math behind the number)

Before you pick a final number, you need inputs. Think of your rate like a formula that covers (1) your income goal and (2) the real costs of doing business, plus (3) risk.

Use these inputs:

1. Target income (what you want to personally earn)
2. Billable hours (realistic time you can sell, not the hours you work)
3. Overhead (tools, software, insurance, rent, utilities, coworking, etc.)
4. Taxes (set aside what you’ll owe)
5. Risk + complexity (how likely it is the work expands or gets hard)
6. Experience level (your track record, speed, and quality)

You’ll use them in different ways depending on your pricing model.

---

Common pricing models with example math

Let’s put numbers to it. These examples show the mechanics, not the “correct” industry rate—your math should match your situation.

A) Hourly rate calculation (baseline)

A simple baseline hourly rate:

Hourly rate ≈ (Target annual income + Taxes set-aside + Overhead) ÷ Billable hours per year ÷ (1 + risk premium)

Example (illustrative):

• Target income: $70,000
• Overhead: $15,000
• Taxes set-aside: $15,000
• Total: $100,000
• Billable hours per year (realistic): 1,400
• Risk premium: 20% (0.20)

Baseline hourly:

• $100,000 ÷ 1,400 = $71.43
• Apply risk premium: $71.43 × 1.20 = ~$85.70/hour

That’s your starting point. You can round to something publishable like $85 or $90/hour, then set ranges (more on that later).

B) Project pricing range (from hours + confidence)

Fixed pricing is often built from an estimate of hours, then adjusted for uncertainty.

A practical way to price a project:

1. Estimate effort in hours (best guess)
2. Convert to an hourly-equivalent rate (your baseline or slightly higher)
3. Add a confidence factor for uncertainty

Example:

• Best-guess effort: 24 hours
• Hourly baseline (hourly-equivalent): $90/hour
• Confidence factor: if you feel medium uncertainty, you might add 20%

Project price estimate:

• 24 × $90 = $2,160
• Add uncertainty: $2,160 × 1.20 = $2,592

Publishable range:

• Low confidence? you might offer $2,400–$3,000
• Higher confidence? you might offer $2,500–$2,700

C) Value-based vs time-based (and how to combine them)

Time-based pricing is easy to understand and defend: you charge for effort.

Value-based pricing targets the outcome: what the work is worth to the client.

For most freelancers, the best approach is hybrid:

• Use your time-based baseline as the safety floor
• Use value signals to set your target price above the floor

Value signals you can point to:

• Revenue impact (more leads, higher conversions)
• Cost reduction (less time spent, fewer errors)
• Risk reduction (compliance, reliability)
• Speed (launch faster)

A simple method:

• Compute your baseline price
• Then set a value target based on outcomes
• Choose the number that protects your time and matches the value story

D) Day rates and retainer math

Day rates are often just a cleaner unit.

If your hourly baseline is $90 and a working day is 6 billable hours:

• Day rate ≈ $90 × 6 = $540/day

Retainers are usually built from an agreed monthly amount of work plus a convenience premium (predictability for you).

Example retainer math:

• Monthly overhead/total income needs covered by baseline: let’s say the baseline implies you need 50 billable hours/month
• If each billable hour is effectively $90, that’s 50 × 90 = $4,500
• Add a predictability premium (say 10–20%) depending on how busy you are

Retainer target:

• $4,500 × 1.15 = ~$5,175/month

If the retainer includes access (priority responses, extra meetings), add cost for that time.

---

Price different scopes without losing your mind

The fastest way to underprice is to quote the same rate for wildly different scopes.

Instead, build pricing around scope size and uncertainty.

Create a scope ladder (small → big)

A scope ladder is a set of packages that scale in size. Each step costs more because it covers more outcomes and more risk.

A common ladder structure:

• Starter: small, clear deliverables
• Standard: full workflow, fewer unknowns
• Premium: includes more strategy/revisions, tighter timelines
• Retainer/Support: ongoing improvements and quick turnarounds

Each tier should have:

• A clear list of deliverables
• A revision policy (how many rounds)
• Included/out-of-scope items
• A response time expectation (if relevant)

Example scope thinking (common in design/dev/writing)

Here’s a generic way to differentiate scopes.

• Small fix: one change, one page/section, quick review, minimal dependencies
• Mid scope: multiple fixes, design and implementation, coordinated inputs from the client
• Full rebuild: new structure, migration, stakeholder reviews, more testing/QA, more risk

The point: full rebuilds usually involve coordination and uncertainty, so you should price them differently than small edits.

Add-ons

Add-ons are how you sell extras without blowing up your base price.

Common add-ons:

• Rush timeline / priority scheduling
• Extra revision rounds
• Extra deliverable formats (e.g., export sizes, copy variants)
• Additional meetings or stakeholder workshops
• Support after delivery (warranty window)

Tip: price add-ons as either fixed amounts or hourly blocks with a clear unit (like “2 extra hours”).

Ongoing support

Ongoing work should not be billed like random one-off requests unless you want chaos.

Good retainer structure includes:

• A weekly or monthly hour allowance
• What happens when you exceed it (extra blocks at a set rate, or carryover rules)
• What “done” means during the month (deliverables + response time)

---

Negotiation boundaries: minimums, discounts, and anchoring

Clients will negotiate. Your job is to keep your pricing method consistent and set boundaries.

Set your minimum acceptable rate

Your minimum acceptable rate is your “I won’t go below this” number.

Use your baseline rate and add a buffer for stress and uncertainty.

A practical approach:

• Your baseline floor comes from your formula
• Your minimum for negotiation might be baseline × 0.9 to 1.0 (only reduce if the deal is easy)
• If the project is risky, your minimum should be higher, not lower

If a client asks for a price cut, you can respond by adjusting scope, timeline, or included revisions, not just your hourly rate.

Discounts only when you can control the risk

Discounts make sense when:

• The client provides good inputs on time
• The scope is stable
• There are fewer revisions
• You can reuse assets or templates
• Delivery is straightforward

If the work is messy or likely to expand, don’t discount—add structure instead.

Ways to “discount” without giving away value:

• Offer a smaller package (Starter instead of Standard)
• Reduce revision rounds (e.g., 2 rounds included)
• Change the timeline (not rush)
• Move some work to add-ons

Anchor with tiers (sell options, not negotiations)

Anchoring means you present options that make your best value tier feel reasonable.

Instead of: “What’s your budget?”

Try: “We typically offer three options.”

Example tier strategy:

• Option A (basic): lowest price, fewer deliverables
• Option B (recommended): best fit, most common scope
• Option C (premium): higher price, added certainty and speed

Then you stop negotiating the number and start helping the client pick a package.

---

Quick decision tool

When you’re standing in front of a new client request, don’t start with a price. Start with the type of work.

Use these questions:

1. Are deliverables clearly defined?
   • Yes → consider fixed project
   • No → consider hourly or time + not-to-exceed
2. Will the scope likely change?
   • Yes → bill for learning (hourly) or add risk buffer to project price
3. Do they need ongoing help?
   • Yes → retainer
4. Is the work time-based (meetings, consulting sessions)?
   • Yes → day rate

Then: compute your baseline rate (or hourly-equivalent) and price the scope.

---

Not sure where your freelance business stands? The Freelance Business Check is a quick way to spot weak spots before they turn into late nights or lost income.

Sanity checks to avoid underpricing or overpricing

Your first draft should survive reality. Use sanity checks before you send your quote.

Utilization check (can you actually take this work?)

Ask: how many billable hours will you lose to this project?

If you’re nearly booked, you can charge more.

If you’re slow, you might accept a lower rate—but only if it doesn’t break your income floor.

A practical check:

• How many hours would this project require total (including communication + admin)?
• Can you still hit your monthly income target?

Delivery risk check (where will it go wrong?)

List the top 3 ways the project could become harder:

• Client feedback arrives late
• Requirements are unclear
• Dependencies on other teams
• More revisions than expected

Then adjust:

• Add a buffer to your fixed price
• Add milestones
• Add a revision cap
• Convert part of the scope to hourly

Repeatability check (can I do this again?)

Some projects are one-offs that take extra mental energy.

If you’re building a repeatable process, your delivery gets easier over time, which supports better pricing.

If it’s truly custom every time, you need a higher risk premium.

Ask:

• Can I reuse parts (templates, code, checklists, design system pieces)?
• Does this scope match what I’m best at?

Overpricing guardrails (avoid shrinking your market)

Charging more is fine, but don’t overshoot without a plan.

Guardrails:

• Make sure your scope definition is clear so clients trust the price
• Offer tiers so clients have a “yes” option
• Explain what’s included, what’s not included, and what could add cost

If everyone says no immediately, it may be too high for their budget range—or unclear for them to understand.

---

Related reading: Freelance Pricing That Works: A Repeatable Method · Freelance Hourly Rate: Calculate Yours (Step-by-Step)

A pricing script you can use on client calls

Use this as a guide. Your goal is to explain your method clearly, not to argue.

1. Confirm the scope
   • “To price this, I’ll make sure we agree on the deliverables, timeline, and what’s included.”
2. Explain the model
   • “Because the work is [clear/unclear], I’m recommending a [fixed project/hourly/retainer] approach.”
3. Talk about what’s included
   • “Here’s what you get in Starter/Standard/Premium, including revision rounds and turnaround times.”
4. Set expectations for changes
   • “If we add new features or additional pages, we’ll treat that as an add-on so the original price stays fair.”
5. Anchor and close
   • “Most clients choose Standard. If you want the fastest timeline and extra rounds, Premium is the best fit.”

One sentence follow-up

• “If you want, tell me your must-haves and your deadline, and I’ll recommend the tier that fits without surprises.”

---## Final checklist: your repeatable method Before you send a quote, run this checklist:

• Pick the pricing model: hourly, day rate, fixed project, or retainer
• Calculate your baseline rate from target income, billable hours, overhead, and taxes
• Add a risk premium based on uncertainty and complexity
• Price the scope using effort + confidence (or a hybrid value story)
• Define tiers (small → big) so clients can choose
• Add-ons are priced separately to protect the base scope
• Set a minimum acceptable rate and don’t discount risk
• Do sanity checks: utilization, delivery risk, repeatability
• Use a short pricing script and explain what’s included

If you follow this process, you won’t need to “guess” your way to pricing. You’ll have a clear baseline, publishable ranges, and a confident way to explain your numbers—so clients understand the value and you protect your time.