What a PHP developer actually costs in 2026

Every few weeks somebody sends us a spreadsheet comparing our rate to a number they found for a US developer. Almost always the two numbers are not the same kind of number. One is an all-in hourly rate with no employer costs behind it. The other is a base salary that ignores payroll tax, benefits, equipment, recruitment, and the eleven weeks the seat sat empty.

That conversation always improves once both columns are built the same way, and it does not always end with us winning the work. Roughly one enquiry a fortnight leaves with us telling them to buy something cheaper, or nothing at all.

This is the arithmetic done properly. It will not tell you offshore is always cheaper, because for several kinds of work it is not.

The four ways to buy PHP work

There are really only four, and they fail in different ways rather than being simply cheap or expensive. Most bad decisions come from comparing the price of one against the failure mode of another.

A domestic in-house hire. Highest total cost, lowest coordination cost. They sit in your standup, absorb context by osmosis, and you own the relationship outright. You also carry recruitment, notice periods, holiday, and the risk they leave in month seven taking the only knowledge of your deploy process with them. The current market makes this slow: a senior PHP role in the US or UK regularly takes two to three months to fill, and that empty seat is a real cost nobody puts in the spreadsheet.

When it wins: the work is inseparable from the business and will still be running in five years.

A domestic contractor. Fast to start, no employment risk, and the highest hourly number you will see anywhere. Sensible for a defined piece of work with a hard edge to it. Expensive as a way to run a team for a year, and the good ones are rarely available for the eighteen consecutive months a platform needs.

When it wins: one specialist problem, short, with a clear finish line.

A marketplace freelancer. Cheapest headline rate, and by a distance the widest quality distribution. You are doing the screening, the code review and the project management yourself. The cost of getting that wrong never appears on an invoice, which is exactly why it keeps happening.

When it wins: small, self-contained, low consequence, and you can personally read the code that comes back.

An offshore agency or dedicated developer. Middle on rate, with the screening and the review already done and priced in. The trade is timezone, and the fact that you are buying through a company rather than employing a person. You get continuity and a replacement clause. You do not get someone who overhears your sales calls.

When it wins: ongoing work, a codebase that needs owning, and somebody on your side with half an hour a day.

The number that matters

Not the hourly rate. The fully loaded cost per productive hour. Two numbers, both of which most comparisons get wrong in the same direction.

A US in-house hire, built out properly

Take a US in-house mid-level PHP developer on a $110,000 base. That is not what they cost you.

Divide by the 2,080 hours in a working year and you get about $69 an hour.

Why 2,080 hours is not 2,080 hours

Nobody delivers 2,080 hours of engineering. The number comes off in predictable chunks, and they are not padding.

$144,415 across 1,700 hours is roughly $85 an hour, which is the number to put in your spreadsheet. It is 23% higher than the naive divide and 129% higher than the base salary implies.

The same sum for a dedicated offshore developer

Our published mid-level PHP rate is $22 an hour. There is no payroll tax line, no benefits line, no equipment, no recruitment fee, and no gap between contracts. The rate is the cost. On a 160-hour month that is $3,520, and on a full year of the same engagement, $42,240.

The holiday and sick leave deductions above do not apply either, because you are not paying for days not worked. If our engineer takes leave, that month is billed for the hours delivered. That is a structural difference between buying hours and employing a person, and it is worth more than it sounds.

So the honest comparison is $85 against $22, not $69 against $22, and certainly not $110,000 against $42,240. The gap is wider than the headline rates suggest, because one of those numbers was already loaded and the other was not.

A UK version of the same sum

The pattern holds with different constants. A £65,000 mid-level developer in London carries employer National Insurance at 15% above the secondary threshold, minimum 3% pension, and the same equipment and recruitment lines. Fully loaded lands near £82,000, which over the same 1,700 productive hours is about £48 an hour, or roughly $61. Lower than the US figure, still around 2.7 times ours.

What the gap does not include

Three things, and they are the reason this is not a slam dunk.

Your management time. Offshore does not remove management, it relocates it. Someone on your side answers questions, reviews pull requests and decides what gets built. Half an hour a day is realistic once an engagement is settled, more in the first fortnight. Cost that at your own loaded rate and add it back honestly: if you are a $90 an hour engineering manager, that is $11,700 a year against a $42,240 engagement, and it lifts the effective rate from $22 to about $28. Still a large gap, but a real number rather than a flattering one.

If nobody has that half hour, no arrangement survives it, ours included. It is the single strongest predictor we have of whether an engagement works, stronger than the size of the budget or the quality of the brief.

The overlap window. We get four hours with New York and five and a half with London. Enough for a standup, a same-day answer and a demo. Not enough for someone to sit in an all-day workshop or pair for an afternoon. If your work genuinely needs constant back and forth, the saving evaporates into waiting, and a nearshore team at $45 an hour will beat us on delivered value.

Ramp-up. A new engineer is not useful on day one wherever they sit. Ours are usually closing tickets without asking how the deploy works by the end of week two. That is faster than a domestic hire only because there is no three-month notice period in front of it, not because the learning is quicker.

There is a fourth item people discover rather than plan for: the admin. Contracts across borders, an IP assignment clause that actually holds, invoicing in a currency you do not hold, and a payment route that is not eating 3% on every transfer. It is a few hours of legal review once and then nothing, but it is a few hours, and it belongs in the column.

The regions, honestly

Rates below are what agency-employed engineers cost, not what freelancers post. Treat them as indicative bands rather than quotes.

India. The deepest pool for PHP specifically, because PHP has been the backbone of Indian software services for twenty years. That depth sits in the unglamorous work: inherited codebases, framework migrations, payment integrations, the CodeIgniter monolith nobody wants to touch. Which is what most buyers actually need, whatever the brief says. Timezone is the cost, and the quality distribution is wide enough that screening matters more here than anywhere.

Eastern Europe. Strong engineering culture, excellent European overlap, roughly $35 to $60 an hour. If you are in the UK or the EU and want most of a working day shared, this is your real comparison, not India. Rates have risen sharply since 2021 and the gap to Western Europe keeps narrowing, so a comparison you ran three years ago is out of date.

Latin America. The right answer for a US company that genuinely needs same-timezone collaboration. Expect $35 to $65. The PHP pool is smaller than either of the above because the region skews toward JavaScript and Python, so you may spend longer finding someone and pay more when you do.

Domestic. Worth it when the work is inseparable from the business: heavy product discovery, constant stakeholder contact, or a regulated environment where onshore is a contractual requirement rather than a preference. We have told people to hire locally for exactly this reason and do not regret any of those conversations.

Hourly, monthly, or fixed price

The pricing model changes your risk more than the rate does, and most buyers pick one by accident.

Hourly suits work with an unknown shape: an audit, a bug hunt, a support retainer, anything where the next task depends on what the last one found. You pay for what happens. The risk is yours, which is fine when the total is small.

Monthly dedicated suits a codebase that needs owning over quarters rather than weeks. You get the same named person, continuity of context, and a predictable number in the budget. The risk is paying for a month where you had nothing queued, which is a planning problem rather than a pricing one.

Fixed price suits a defined build with a boundary somebody has actually drawn. We will quote fixed scope, but only after a paid discovery, currently $2,400. Two weeks of reading the code and the requirements is what turns a guess into a number. Anyone quoting a fixed price for a build they have not read the codebase for is either padding by 40% to cover themselves or about to have an argument with you in month three.

The pattern we see most often on rescue work: a fixed price accepted without discovery, scope drift absorbed silently for two months, then a relationship that ends badly with half a system delivered.

Where the cheap option gets expensive

The failure mode is nearly always identical. Someone buys the lowest hourly rate they can find, gets code that works on the happy path, then discovers eighteen months later that nobody can change it without breaking something else.

What those codebases look like on arrival

We audit a lot of them, and the findings repeat with unsettling consistency:

• No tests at all. Not thin coverage. Zero. On one recent takeover we went from 0% to 74% on the paths that touch money before changing a single feature.
• Business logic in controllers, often the same rule implemented three times with two of them subtly different.
• A schema that grew by accident, with nullable columns standing in for states nobody named and foreign keys implied rather than declared.
• A deploy process living in one person’s head, usually involving FTP.
• Dependencies years past their support window. The worst we have taken over had 41 vulnerable dependencies and nine years without a patch.

None of that shows up in a demo. All of it shows up the first time you need a change delivered in a hurry.

The arithmetic of the rewrite

Say you saved $18 an hour by hiring at $12 instead of $30. Over a 1,200-hour build that is $21,600 saved, which is real money.

Now price the recovery. A two-week audit and regression suite, a security and dependency pass, then the refactor of whatever is load-bearing. On the codebases described above that has landed between $25,000 and $45,000, and it buys you back the position you thought you had paid for originally. The saving was real and the bill arrived later, on a different budget line, usually belonging to somebody who did not make the original decision.

Priced honestly: a $12 an hour developer whose work needs rewriting in year two cost you more than a $30 an hour developer whose work did not. You will not know which one you bought until later. That is precisely why the screening you skipped is the expensive part.

Five questions to ask both sides

Ask us these. Ask everybody else these. The answers separate vendors faster than any rate card.

1. What is your fully loaded cost per productive hour? Not the rate. The rate divided by the hours you will actually get. A good answer includes the deductions unprompted. A bad answer repeats the hourly rate back at you.

2. Who reviews the code? If the answer is “the developer”, then you are the reviewer, and that is your time at your loaded rate. Ours is reviewed by a second engineer before it reaches you, which is part of what the difference between $12 and $22 pays for.

3. What happens if this person leaves? A named replacement inside five business days is worth real money against a two-month gap. Get the answer in the contract rather than in an email, because this is the most common complaint about offshore agencies and it is a structural choice rather than an accident.

4. Who owns the code, and from when? On commit or on final payment changes your negotiating position entirely. Ours transfers on commit. If a vendor hesitates on this question, that hesitation is the answer.

5. What is the notice period? Thirty days against a twelve-month minimum is the difference between a decision and a bet. Anyone confident in the work does not need to lock you in for a year.

What we charge, and why it is on a page

Our rates are published in full. Every stack, every seniority band, one number per row, the same for every client in every market.

A hidden rate can be adjusted per client, which means somebody is subsidising somebody else. Ours cannot be, including for the clients who would happily have paid more and have occasionally said so.

Alongside the hourly card: a two-day code audit at a fixed $800, discovery at $2,400, and fixed-scope builds starting at $9,500 for PHP work and $8,500 for WordPress after that discovery. The whole card sits on the rates page with no gate and no call required.

When we tell people not to hire us

Roughly one enquiry a fortnight, and there are three usual cases.

The work is one defined job. One integration, one upgrade, one audit. Buy it hourly and stop when it is finished. Putting a monthly retainer against six weeks of work benefits us and not you.

Nobody has half an hour a day. Without product context a developer writes plausible code that solves the wrong problem, and plausible code solving the wrong problem is more expensive than no code. We would rather say this in week zero than invoice for it in month three.

A theme and a freelancer will do it. Fifteen marketing pages with ordinary requirements? A premium theme configured well beats anything we would build, on price and on time. We say so, and we mean it.

Common questions

Is $20 an hour too cheap to be any good?

It is roughly the market rate for an agency-employed mid-level engineer in Pune, where the cost of living makes it a good living. The rates that should worry you are the ones under $12, because at that point either nobody is reviewing the code or the person on the call is not the person writing it.

Why is Laravel more expensive than PHP?

Because the market prices it that way, and because the pool is shallower. It is a $2 an hour difference at mid level, which is not where your budget will be decided.

Can I hire one developer rather than a team?

Yes, and most engagements start that way. One named engineer, monthly, thirty days notice. Pods of three or four make sense once there is more parallel work than one person can hold, not before.

Does the rate go up after a few months?

No. The card is the card. If we needed to move a client to a higher seniority band we would say so and you would decide, but the rate for a band does not drift upward once you have signed.

What if the first two weeks go badly?

The first ten working days are risk-free. If the fit is wrong you stop and you do not pay for them. We would rather absorb two weeks than argue about month three, and it also keeps us honest about which enquiries we take.

The number on the invoice is the easy part of this decision. What it costs you to manage, and what it costs you to unpick later, is where the real money goes.