Freelance Developer Hourly Rate by Stack and Domain

Freelance developer hourly rate benchmarks are unusually noisy, because the same job title covers work whose consequences differ by three orders of magnitude. A React developer building a marketing site and a React developer building a trading dashboard are doing recognisably the same activity for very different money, and no rate table that ignores that will be much use.

Here is the 2026 US direct-to-client market, split by stack, followed by the domain multiplier that actually explains most of the variance.

Eight stacks, low to high, with the most common rate marked in gold. The spread inside each band is the interesting part.

Stack	Low	Typical	High
Quant / trading systems	$150	$225	$320
ML / AI engineering	$120	$175	$280
Cloud / DevOps / SRE	$100	$150	$230
Backend / distributed systems	$90	$135	$210
Mobile (iOS / Android)	$80	$125	$195
Full-stack	$70	$115	$200
Front-end	$60	$100	$165
WordPress / CMS	$40	$70	$120

The domain multiplier

Stack explains less of the spread than people assume. Domain explains more.

The same backend engineer, writing the same quality of Go, is priced differently depending on what breaks when it breaks:

Domain	Multiplier on base stack rate	Why
Trading, payments, health records	1.25 – 1.40×	Regulated; defects have immediate quantified cost; audit and compliance obligations
Enterprise internal systems	1.10 – 1.25×	Procurement, security review, long approval chains — the overhead is priced in
Funded startup product	1.00× (baseline)	Speed valued; risk tolerance high; budget finite but real
Agency subcontract	0.60 – 0.75×	The agency carries the client relationship and takes the margin for it
Platform marketplace	0.35 – 0.55×	Competing on price against a global pool with no relationship context

A full-stack developer at the $115 typical mark is billing $144 on a payments product and $63 through an agency. That is the same person, the same week, the same code. It is the most consequential pricing decision most developers never consciously make.

Why software should rarely be fixed-bid

There is a strong argument for project pricing in most freelance disciplines — you keep the upside of your own speed. Software is the discipline where that argument is weakest, and it is worth being explicit about why.

Software estimates are unreliable in a structurally asymmetric way. They are almost never wrong in your favour. Integration surprises, an undocumented API, a stakeholder who appears in week three with opinions, a legacy schema nobody warned you about — every one of these adds hours, and none of them subtracts any. When you fixed-bid, you have agreed to absorb an entire category of risk that you cannot inspect before quoting.

Watch what that does to a $12,000 fixed bid estimated at 90 hours:

Actual hours	Effective hourly	Outcome
80	$150	You won the estimate
90	$133	As planned
120	$100	Squeezed but fine
160	$75	Below most developers' floor
210	$57	You are subsidising the client

The 210-hour column is not a hypothetical; it is what happens when a "simple integration" turns out to involve an undocumented legacy system. Hourly vs project pricing works through when fixed fees do make sense, and the honest answer for software is: repeatable work you have shipped five or more times, with a written scope and a change-order clause.

The better middle ground for most engagements is weekly or sprint billing. The client gets a predictable number to budget against; you get paid for the weeks the work actually takes. A defined scope per sprint gives both sides the certainty that a fixed bid was supposed to provide, without transferring every unknown onto you.

Building your floor

Before you use any of the tables above, calculate the number below which the work does not pay. It is specific to you, and it is usually higher than developers expect because software carries real overhead.

A worked example for a mid-level backend developer:

• Take-home target: $115,000
• Tax gross-up at a 30% effective load: $115,000 ÷ 0.70 = $164,286
• Annual expenses: $9,400 — a machine on a three-year cycle, cloud and dev tooling, professional liability insurance, accounting, a conference, subscriptions
• Buffer at 12%: +$20,842
• Running total: $194,528
• Realistic billable hours: 1,150 (see how many hours do freelancers work for why this is not 2,080)
• Floor rate: $169 an hour

That developer cannot take agency subcontract work at $85 and call it a business. They can take it as pipeline filler in a slow quarter, knowing it is subsidised by the direct work — but only if they know the number. The freelance rate calculator formula walks the same arithmetic step by step, and the rate calculator will do it with your figures.

Retainers and why most developers should have one

Project work has a structural problem for developers: it ends. A month with two projects and a month with none average out to a fine year and feel like two different lives, and the gap is where developers accept work below their floor out of nervousness rather than arithmetic.

Retained maintenance is the usual fix, and it is priced differently from project work because you are selling availability as well as hours.

Retainer shape	Typical monthly	What the client is buying
Maintenance, best-effort	$2,500 – $4,000	Dependency updates, small fixes, no response guarantee
Maintenance + SLA	$4,000 – $6,500	Same, plus a guaranteed response window
Embedded, 1–2 days/week	$6,000 – $10,000	Reserved capacity, sprint participation, code review
On-call, critical systems	$8,000 – $15,000	Out-of-hours availability and incident response

Two pricing notes that developers get wrong more than any other discipline.

Price the response window separately. A four-hour guaranteed response has a cost in months where nothing breaks, because it constrains where you can be and what else you can commit to. That constraint is the product. Charging only for hours used means a quiet month pays you nothing for a promise you kept the whole time.

Do not discount below 20 hours a month. Small retainers cost more per hour to service, not less: the context reload on a codebase you last touched five weeks ago is real work. Anything under 20 hours should carry a premium over your standing rate. Freelance retainer rates has the full hour-band logic.

The salary comparison developers get wrong

A very common message: "I make $140,000 as a staff engineer, so $70 an hour freelance is the same, right?"

No, and the gap is large.

Line item	Employed at $140k	Freelance equivalent
Base	$140,000	must be replaced
Employer payroll tax share (7.65%)	paid by employer	+$10,710 you now pay
Health insurance for a family	mostly employer-funded	+$14,000 to $22,000
401(k) match at 4%	+$5,600	you fund it
Equipment, tooling, software	employer-provided	+$4,000 to $9,000
Paid time off, sick leave, holidays	~25 days paid	unpaid
True replacement cost	$140,000	~$180,000 to $190,000

At 1,150 billable hours, $185,000 requires $161 an hour — not $70. The naive salary-÷-2,080 conversion produces $67, which is off by 2.4×. Freelance hourly rate from salary does this conversion in full with a worked example.

This is not an argument that freelancing pays worse. It is an argument that the comparison has to be like for like, and that developers who convert naively spend their first year confused about why a "raise" left them poorer.

Where the top of each band comes from

The developers I know at the top of their band share three things, and none of them is raw technical skill relative to their peers.

They own an outcome, not a ticket. "I will take responsibility for your checkout reliability" prices differently from "I will implement these stories." Ownership is the single largest jump available.

They are legible to non-engineers. Being able to explain a trade-off to a CFO in one sentence is worth more, in rate terms, than most technical depth. It is what turns a contractor into an advisor.

They have a named domain. Not "backend" — "high-volume subscription billing," "HIPAA-compliant data pipelines," "Shopify Plus performance." A named domain is what lets a client believe the premium is justified rather than negotiated.

If you want a second reference point built from a different methodology, the US Bureau of Labor Statistics publishes occupational data for software developers that is useful as a floor sanity-check — bearing in mind it measures employment, so freelance rates should sit meaningfully above the implied hourly figures once benefits and unpaid time are accounted for.

---

The compressed version: US freelance developer hourly rates in 2026 run from about $40 for CMS work to $320 for quantitative systems, with most competent generalists between $100 and $150. Domain moves your rate more than stack does, weekly billing beats fixed bids for most software, and the number that matters is the floor you calculate from your own costs — not the median of somebody's survey. Run yours here before you quote anything.