Hire Laravel Developers: Rates, Vetting and What Good Looks Like

What a Laravel developer does, and where hiring goes wrong

Laravel is a batteries-included framework, which means most of the job is not writing routes. The real work is deciding how Eloquent models relate to each other, what runs in a request and what gets pushed to a queue, whether the interface is Blade, Livewire, Inertia or a decoupled API, where business logic lives so controllers do not turn into 200 line methods, and whether the thing survives a real traffic day.

We picked up a subscription billing app for a logistics client. The order dashboard took eleven seconds to load. Laravel Debugbar showed just over 1,800 queries on a single page render, because the Blade view looped over $orders and touched $order->customer->company->billingContact inside the loop. No with(), no eager loading, no index on the foreign key. The previous developer's fix had been to raise PHP memory_limit to 1G and cache the entire rendered page in Redis, so the dashboard was now stale as well as slow. Separately, the Stripe webhook controller generated a PDF inline, so Stripe timed out at ten seconds and retried, and because the handler had no idempotency check, some customers received three invoices for one payment. The failed_jobs table had 41,000 rows in it, because the queue worker had been started once by hand with php artisan queue:work inside a terminal session that died months earlier. Nobody had a monitor on any of it.

That developer was not lazy and he was not cheap. He was a competent PHP generalist who had learned Laravel from CRUD tutorials. Everything he built worked at 50 users. Nothing he built was designed for 5,000.

This is why hiring goes wrong. "Laravel developer" is one of the widest skill bands in software. The floor is someone who can scaffold Breeze auth and generate a resource controller. The ceiling is someone who can tell you why a job with a retry_after of 90 seconds and a timeout of 120 will quietly charge the same card twice. Both titles read "Senior Laravel Developer". Both portfolios are screenshots. The gap only surfaces six months in, when the invoices are already paid.

Engagement models: in-house, freelancer, agency, staff augmentation

In-house hire. Right when the Laravel app is the product, the roadmap runs past twelve months, and you already have at least one engineer who can review the work. You get accumulated domain knowledge, which matters enormously in business applications where the rules live in someone's head. The trade-off is time and pool size. Expect eight to fourteen weeks from opening the role to a first meaningful pull request, and accept that the senior Laravel pool in any single city is thinner than the JavaScript pool.

Freelancer. Suited to scoped, bounded work with a clear finish line: build a Filament admin panel, upgrade a Laravel 9 app to 11, add a Sanctum-authenticated API for a mobile client, fix a specific slow report. The trade-off is a bus factor of one. Freelancers become unavailable at exactly the moment your queue backs up on a Friday, and unless you ask explicitly, you will get no tests, no CI and no documentation.

Agency. Suited to work where you need architecture, build, DevOps and QA handled as one unit and you do not want to manage individuals. The trade-off is price and opacity: you often do not know who is touching your code. Non-negotiable conditions are that the repository lives in your GitHub organization, that servers are provisioned under your accounts (your Forge, your Vapor, your AWS), and that ownership is written down.

Staff augmentation. Suited to teams with a technical lead or CTO but no capacity. Engineers sit in your standups, your board, your review process. The trade-off is that this only works if somebody on your side reviews pull requests properly. Without that, staff augmentation quietly degrades into an agency with none of the accountability.

One thing specific to this stack: Laravel talent is unusually strong outside the US, partly because Laracasts and the community made high-quality training free and global. An onshore lead plus an offshore build team works better with Laravel than it does with most stacks.

What Laravel developers cost

These are the rates we quote and pay at Digital Heroes, plus what we see when clients bring us competing bids to look over. They move with region and seniority.

• Mid-level Laravel engineer through us: roughly $22 to $38 per hour. Comfortable with Eloquent, form requests, policies, Pest, and shipping features against an existing architecture.
• Senior Laravel engineer through us: roughly $38 to $60 per hour. Owns queue design, migrations on live data, multi-tenancy, performance work, and CI.
• Independent freelancers, South and Southeast Asia: roughly $15 to $35 per hour.
• Eastern Europe and Latin America: roughly $35 to $70 per hour.
• US, UK and Western Europe contractors: roughly $85 to $160 per hour.
• US or UK agencies: roughly $120 to $220 per hour blended.

Below about $15 per hour the pattern is predictable rather than random. You get $guarded = [] on every model, DB::raw concatenated with request input, and a controller that does the payment, the email and the PDF in one method. You then pay a senior twice to unpick it.

The in-house number people quote themselves is almost always wrong, because they quote base salary. Every client who has sat down and built the real spreadsheet with us has landed well above it. A senior Laravel engineer's base in the US commonly lands somewhere in the six figures depending on the market. Payroll taxes, health insurance, retirement match, equipment, and per-seat software (Forge, Envoyer, Sentry, GitHub, a JetBrains or similar licence) then push the landed cost up by roughly a third. If you use a contingency recruiter, add their fee, which is a slice of first-year salary and not a modest one. Then add four to eight weeks of ramp before the person produces at full rate, which you pay for and get nothing from. The base you thought was your budget is closer to your budget plus a third or more in year one. That maths is why a scoped engagement often wins the first six months even when in-house wins the long run.

How to vet a Laravel developer

Skip the trivia. Ask questions that only get good answers from someone who has run this stack in production.

Eloquent beyond CRUD. Ask: "Show me a page you made faster. What was the query count before and after, and how did you measure it?" A strong answer names Laravel Debugbar or Telescope, gives real numbers, explains the difference between with(), load() and loadMissing(), mentions withCount() instead of counting relations in a loop, and usually admits the real win was a missing index on a foreign key. Follow up with: "When would you use chunkById instead of chunk, and when would you reach for cursor() or lazy()?" Anyone who has exported a large report knows the answer.

Queues. Ask: "What is the difference between retry_after in config/queue.php and the timeout on a job, and what breaks when they are set wrong?" The correct answer is that retry_after must exceed the longest possible run time of the job, otherwise the queue releases the job back and you run it twice. Then ask how they supervise workers (Supervisor, Horizon, or a managed platform) and whether they run queue:restart on deploy. If they have never mentioned that a long-running worker keeps executing the old code until it is restarted, they have not operated queues.

Auth and authorization. Sanctum or Passport, and why. Sanctum for first-party SPAs, mobile apps and simple API tokens. Passport only when you need full OAuth2 for third-party clients. Reaching for Passport by default means a tutorial was copied. Then ask where authorization lives: policies and gates, or if statements scattered through controllers.

The interface decision. Ask them to argue Blade versus Livewire versus Inertia versus a decoupled API for your product. A good answer is about your team and your roadmap, not their preference. Livewire suits a small PHP-only team with a lot of forms. Inertia suits teams that want React or Vue ergonomics without maintaining a separate API. A decoupled API is worth the cost only when there is a mobile app or a separate frontend team.

Version literacy. Ask what changed with the Laravel 11 slim skeleton: middleware and exception handling moved into bootstrap/app.php, and the old Http/Kernel.php and Console/Kernel.php are gone. Then ask how they would approach a Laravel 5.8 app that is on PHP 7.4 and cannot go down for a week. Listen for incremental upgrades, Rector, and a test suite built before the upgrade rather than after.

Testing and tooling. Pest or PHPUnit, RefreshDatabase, factories, and what they fake: Queue::fake(), Http::fake(), Mail::fake(). Ask what level they run Larastan or PHPStan at. Anyone running level 5 or above on a real Laravel codebase has done serious work. Laravel Pint in CI should be assumed, not celebrated.

The take-home. Do not ask them to build a blog. Give them a small existing repository with three planted problems: a controller with an N+1 inside a Blade loop, a queued job that is not idempotent, and a route missing its policy check. Three to four hours, paid, delivered as a pull request with a written description. You are grading four things: did they measure before and after, did they write a test that fails before the fix and passes after, did they fix the actual bug rather than rewrite the architecture, and does the PR description read like someone you would want in a code review. If a take-home is not possible, ask for a screen share of production code and say: show me your slowest endpoint, show me a job class, show me a test. Then read a controller. A method that opens a transaction, calls Stripe, sends mail and writes a PDF inline tells you everything.

Red flags

• $guarded = [] everywhere, or Model::create($request->all()). This is mass assignment waiting to be exploited. Ask instead: "Walk me through how you handle mass assignment on your User model, and what happens if someone posts is_admin=1 to your profile update endpoint."
• Everything lives in the controller, or everything lives behind five layers of abstraction. Both are the same failure: no judgement. A repository interface wrapping Eloquent for every model with exactly one implementation is as much a smell as a 200 line controller. Ask instead: "Where does business logic live in your last app, and why did you put it there?"
• They never mention failed jobs, Horizon, or monitoring. Ask instead: "The last time a queued job failed in production, how did you find out?" If the answer is not Horizon, an alert on failed_jobs, or an error tracker, they have been lucky rather than careful.
• They cannot explain env() versus config() after caching. Ask instead: "What happens when you run php artisan config:cache and then call env() from inside a service class?" The answer is null, and half your app breaks in production only. It is a tiny question that reliably separates people who have deployed a Laravel app from people who have only run one locally.
• Package soup. A composer.json with sixty packages, several abandoned, one forked. Mature Spatie packages are fine and often the right call. A twelve-star GitHub package sitting in your payment path is not. Ask instead: "Which packages do you install on every project, and name one you ripped back out and why."

When to hire a Laravel developer, and how Digital Heroes staffs it

Do not hire one if your real problem is a WordPress or Shopify site with a plugin gap. A WordPress developer solves that for a fraction of the cost, and a Laravel engineer will quietly propose rebuilding it. Do not hire one if you need a mobile app first and have no backend at all: hire the mobile engineer and start on a managed backend. Do not hire one if the core need is data pipelines or machine learning. That is Python, and Laravel developers will tell you so if they are honest. And if what hurts is deployment, zero-downtime releases and worker supervision rather than code, the fix may be a two week Forge or Vapor engagement, not a hire.

Do hire one when you are building a business application with real domain rules: roles and permissions, billing, admin panels, reporting, imports, background jobs, audit trails. Laravel with Horizon and Filament puts a serious internal product in front of users faster than almost anything else, and the ecosystem for the boring parts is mature. That is where the money is well spent.

Digital Heroes staffs Laravel senior-led. A senior engineer owns the first sprint: schema and migrations, queue and job design, the interface decision (Blade, Livewire, Inertia or API) argued against your roadmap rather than our habits, and CI with Pint, Larastan and Pest running in GitHub Actions before feature work starts. Mid-level engineers then build against that spine with every change going through review. The repository sits in your GitHub organization from the first commit, infrastructure is provisioned under your accounts, and ownership of the code is yours on payment with no separate licence. If you have never worked with us, start with a scoped block, a performance audit on the slow page or one real feature end to end, and judge us on the pull request rather than the pitch.