Hiring PHP Developers: How to Tell 2026 PHP From 2013 PHP

PHP runs 70.2% of every website whose server-side language can be identified. That single fact explains both why this role is easy to fill and why it is hard to fill well: the supply of people who will call themselves a PHP developer is enormous, and the supply of people who write the language the way it is written in 2026 is not.

Rates start at $20 an hour offshore, against a US software developer median of $135,980. But the price gap is not the interesting one here. The interesting gap is between two developers charging the same rate, one of whom stopped learning in 2013, and most hiring processes never test for it.

At Aipxperts we place PHP engineers into teams maintaining fifteen-year-old codebases and into teams building new services on PHP 8. Here is what the rates are, the single screening question that separates the two groups, and how long a hire realistically takes.

1. What PHP Developers Cost in 2026

Two numbers, and they answer different questions.

For the US benchmark, the most defensible public figure is the Bureau of Labor Statistics: a median annual wage of $135,980 for software developers in May 2025, ranging from under $82,460 at the tenth percentile to over $214,670 at the ninetieth. It is not broken down by language, and that is a feature rather than a limitation, because the PHP-specific numbers you will find elsewhere come from aggregators that disagree with each other by $30,000 on the same role in the same year. Whatever base you settle on, a US W-2 hire costs another 25% to 35% once payroll tax, benefits and the recruiting fee are counted.

Then there is what an agency charges. PHP sits in our development band at Aipxperts:

Level	Hourly	Weekly (40 hrs)	Monthly (160 hrs)
Beginner	$20	$800	$3,200
Intermediate	$25	$1,000	$4,000
Skilled	$30	$1,200	$4,800

Rates in USD. Monthly assumes 160 hours. Compliance-heavy work is quoted separately.

The language is worth a specific warning on price. Because the talent pool is so large, the floor is lower than for almost any other server-side language, and the bottom of that market is genuinely cheap. It is also where most of the horror stories come from. A developer at half these rates who writes it the way it was written in 2013 will hand you something that works on day one and cannot be safely changed by month six. The saving is real and it is temporary.

2. The “10 Years of PHP” Problem

This is the single most useful thing on this page, so it goes early.

PHP 8 changed the language substantially. Typed properties, union types, constructor property promotion, named arguments, match expressions and attributes are not cosmetic additions. They change how a codebase is structured and how errors surface.

The problem is that the install base is old, and a large number of people writing PHP every day are writing 5.6 or 7.0 patterns inside an 8.x runtime. Their working knowledge stopped years ago. It has not stopped them shipping, because the language is famously tolerant, and it will not stop them passing a generic technical interview either. A CV saying “12 years of PHP” tells you how long they have been employed, not which decade their habits belong to.

So ask this, and ask it early: what changed for you between PHP 7 and PHP 8, and what do you write differently now?

Someone current will talk about types, match, constructor promotion, or how attributes replaced docblock annotations in their framework. Someone whose knowledge stopped will talk about performance, because the JIT was the headline everyone read, and then run out of things to say.

3. Separating Current PHP from Stale PHP

Three things, and the first two are non-negotiable.

Start with how they handle user input reaching the database. This is not a trick question and it is not academic. Ask them to talk you through a query that takes a user-supplied value. The answer you want involves prepared statements with bound parameters through PDO or an ORM. If the answer involves string concatenation and a call to an escaping function, you have learned something important in ninety seconds. SQL injection remains one of the most exploited classes of web vulnerability, and the language’s long history means the bad pattern is still all over the tutorials people learned from.

Second, types and static analysis. Ask whether they run anything over their code before it ships, and what level they run it at. A developer who has worked in a typed codebase will name a tool and have an opinion about how strict is too strict. A developer who has not will say the tests catch it.

Third, dependency and framework currency. Not which framework they prefer. Whether they know what version their last project was on, whether it was in support, and what upgrading involved. Framework upgrades are where these projects quietly die, and someone who has been through one has a very different vocabulary from someone who has not.

Worth having but not disqualifying: queue and worker experience, Docker, and any exposure to asynchronous execution.

4. The Interview: Four Questions Worth Asking

Each of these has a right answer and a revealing wrong one.

1. “Write me a query that fetches a user by an ID that came from a URL. Talk me through what you are doing.” Prepared statement with a bound parameter. If they interpolate the variable into the SQL string and reach for an escaping function, stop there.
2. “What changed for you between PHP 7 and PHP 8?” Covered above. The best single filter on this list.
3. “A request in production takes forty seconds and is timing out. What do you do?” You want to hear the work moved off the request, into a queue and a worker, with the user getting a job status rather than a spinner. Candidates who reach first for raising the execution time limit are treating the symptom.
4. “You inherit a 200,000-line codebase with no tests and no documentation. What happens in your first week?” There is no single right answer, but there are wrong ones. Rewriting is wrong. The good answers involve getting it running locally, finding the highest-traffic paths, adding tests around what you are about to touch, and changing nothing structural until you understand why it is the way it is.

5. Where to Find PHP Developers

Five channels, and the pool depth differs sharply from other languages.

Channel	Typical rate	Best for	Watch out for
Freelance marketplaces	$15–$60/hr	Short bounded tasks	The largest pool and the widest quality spread of any language
Vetted talent platforms	$50–$140/hr	Fast senior placement	The vetting premium is most of what you pay
Job boards, direct hire	Salary + 20% fee	Permanent ownership	8–14 weeks elapsed, counter-offers
Development agencies	$20–$60/hr	Ongoing team capacity	Ask who is assigned, not who was in the pitch
Framework communities	Varies	Genuine senior specialists	Slow, and it does not scale past a couple of hires

The community route deserves more attention than it usually gets for PHP specifically. The framework ecosystems run their own conferences, forums and job boards, and the people active in them are self-selected for currency. Someone with a merged contribution to a major PHP package has been through code review stricter than most interviews.

6. Inheriting a Legacy PHP Codebase

Most PHP hiring is not for new builds. It is for something that already exists, has been running for years, and now needs to change.

That is a different hire, and the skill that matters most is not the one people screen for. Writing new code well is common. Reading unfamiliar code, working out why a decision was made, and changing it without breaking the three things quietly depending on it is rare.

Ask candidates what the oldest codebase they have worked on was, and what they did first. Then ask what they broke. The honest ones have an answer and it is usually specific.

Two practical signals when the work is legacy. Someone who asks about your deployment process before your architecture is thinking about risk, which is the right instinct on a system that is already carrying traffic. And someone who asks whether there are tests, and then asks what the tests actually cover rather than accepting a coverage number, has been burned before in a useful way.

If what you are looking at is less a hire and more a rebuild, that is a different conversation. Our legacy application modernization work exists precisely because the answer is often not one more developer on an old system.

On a licence management system Aipxperts took over, the existing platform was PHP and the client’s server estate already supported it. Rebuilding in something fashionable would have meant new infrastructure, a data migration and a longer path to the first working release. Staying on PHP was the faster and cheaper answer, and it was the right one. Several clients have written about that sort of decision from their side in our customer success stories.

7. Warning Signs in a PHP Candidate

• Escaping instead of binding. Covered above, and it is worth repeating because it is the fastest disqualifier available to a non-technical interviewer. You do not need to understand the code. You need to hear “bound parameter” rather than “escape the string”.
• Rewrite as the first answer. A developer who looks at your working system and proposes replacing it before understanding it is telling you they would rather write new code than read old code. That preference is understandable and expensive.
• No version awareness. Not knowing which PHP version production runs, or which version the framework is pinned to, on a system they have worked on for months.
• A quote before any questions. Nobody can price PHP work without seeing the state of the codebase. A number that arrives same-day with no discovery is a number that will move.
• No named individual. A supplier who will not tell you which specific person is doing the work, before you sign, is asking you to trust a process rather than a developer. Ask for the name and a conversation.

8. Time to Hire, by Level

Realistic elapsed time from open requisition to first commit, based on Aipxperts placements:

Level	Time to place	Why
Beginner (0–2 yrs)	1–2 weeks	Deepest pool of any language we staff
Intermediate (3–5 yrs)	1–3 weeks	Still comfortably supplied
Skilled (5+ yrs), modern PHP	3–5 weeks	Much thinner than the raw pool size suggests
Skilled + legacy migration	5–8 weeks	Rare combination, and usually employed

PHP is faster to staff than most languages at the junior and mid levels and no faster at the top. The size of the pool is misleading, because the filter that matters is currency rather than availability.

9. Which Engagement Model Fits PHP Work

Almost nobody publishes a straight comparison of this, so here is one.

	Staff augmentation	Dedicated team	Fixed-scope project
Who directs the work	Your manager	Our delivery lead	Our delivery lead
Suits	An existing codebase and a backlog you already own	A product surface handed over completely	A migration or integration with a firm boundary
Ramp-up	1–2 weeks	2–4 weeks	2–3 weeks incl. discovery
Billing	Hourly, per engineer	Monthly, per team	Fixed price
Changing scope	Any time	At a sprint boundary	Change request only
You must supply	Backlog, code review, direction	Product priorities	A specification that is genuinely settled
Goes wrong when	Nobody your side has time to review code	You want to direct daily work anyway	The specification was a wish

For PHP work specifically, the split is more even than it is for front-end hiring. Maintenance and feature work on an existing system usually suits staff augmentation, because your team already holds the context. A rebuild or a new service more often suits a dedicated development team. If the commercial structure is the harder question right now, our IT outsourcing page sets out how each is contracted.

Fixed-scope is the model to be careful with, and legacy PHP is where it fails most often. You cannot fix the price of work whose scope is hidden inside a codebase nobody has fully read.

10. Where PHP Hiring Goes Wrong

• Hiring on price. The floor here is genuinely low and the bottom of that market is where the expensive mistakes come from. Two intermediates writing modern code will outrun four cheap developers who do not, and the code will still be changeable in two years.
• Screening for the framework instead of the language. Someone who only knows one framework’s way of doing things struggles the moment they are outside it. Ask about the language. Framework knowledge follows.
• Treating “full stack” as a free upgrade. A PHP developer who also writes some front-end is common. One who is genuinely strong at both is not, and is priced accordingly. If your front end matters, hire for it separately.
• Underestimating the review load. Staff augmentation means someone on your side reads the code. If nobody has three hours a week, you want a team that reviews its own work instead.

11. How Aipxperts Staffs PHP Work

This has been part of our web application development practice since the company started, which here matters more than it sounds. Most of what we are asked to do is not greenfield. It is taking on something that already runs a business and making it safe to change again.

Practically: you get named engineers with CVs and a call before anything is signed, you are told which PHP version they last worked in and on what, and the rates above are the rates rather than an opening position.

The honest counterpart is that we are not always the answer. If your PHP system is small, stable and only needs occasional attention, a single trusted contractor will serve you better and cost less than an agency relationship. If nobody internally can review incoming code, augmentation is the wrong model and we will say so before you sign. And if the real problem is that the application should not be PHP any more, that is a modernization conversation rather than a hiring one.

For the technology rather than the people, we have written separately on choosing a PHP framework and on the Laravel framework in detail.

12. Frequently Asked Questions

How much does it cost to hire PHP developers?

Aipxperts rates are $20 an hour for beginner, $25 for intermediate and $30 for skilled, which is $3,200 to $4,800 a month at 160 hours. Hiring in-house in the US is a different sum entirely: $135,980 was the BLS median for software developers in May 2025, before you add a quarter to a third again for payroll tax, benefits and the recruiter.

Is PHP still worth building on in 2026?

For most web applications, yes. PHP runs 70.2% of all websites whose server-side language can be identified, according to W3Techs, and PHP 8 is a considerably better language than the one that earned the reputation. The stronger argument for PHP is usually practical rather than technical: your hosting supports it, your team knows it, and your data is already there.

What is the difference between a cheap PHP developer and an expensive one?

Usually the decade their habits come from. The market floor for PHP is lower than for any comparable language, and the gap between $10 an hour and $30 an hour is mostly the difference between code that works now and code that can still be changed in two years.

How quickly can you place a PHP developer?

One to two weeks at beginner level and one to three at intermediate, which is faster than most languages. Skilled engineers writing modern PHP take three to five weeks, and that is not much faster than anywhere else, because the constraint is currency rather than headcount.

Should I hire for PHP or for a specific framework?

Hire for PHP. Framework-specific hiring narrows your pool sharply for a skill a strong developer picks up in weeks. The exception is when a project is deeply committed to one framework’s conventions and you need someone productive immediately.

Who owns the code when I hire PHP developers offshore?

You do, provided the contract says so explicitly and covers derivative work as well as final deliverables, including build tooling and configuration. Settle it before work starts rather than at the end.

Can a PHP developer maintain a codebase written by someone else?

Some can and many cannot, and it is a distinct skill worth interviewing for separately. The section on inheriting a legacy codebase above has the questions that tell them apart.