There’s a difference between a PHP developer who has used Laravel and a Laravel developer who can build something you’ll actually want to maintain a year from now.
The job title won’t tell you which one you’re getting. The skills breakdown below will.
These aren’t skills for their own sake. Each one is here because its absence causes specific, predictable problems in production applications.
1. PHP 8.x : The Modern Version, Not the Legacy One
This is the foundation everything else sits on. But PHP in 2026 is genuinely a different language from the PHP of five years ago. The skills to verify:
* Comfort with union types, named arguments, and fibers
* Object-oriented fundamentals: interfaces, abstract classes, traits, dependency injection
* Understanding of when to use typed properties and when they’re unnecessary overhead
**Why it matters:** Developers who haven’t moved past PHP 7 thinking often write code that’s technically valid but stylistically out of step with modern Laravel conventions. That creates friction for every other developer who touches the codebase later.
**How to test it:** Ask them to walk you through a service class they’ve written recently. The code structure tells you instantly where their PHP knowledge sits.
2. Eloquent ORM : Beyond Basic CRUD
Almost every Laravel developer can write a `User::find($id)`. What separates genuinely skilled developers is how they handle data relationships and query performance.
Skills to verify:
* `hasMany`, `belongsTo`, `belongsToMany`, and polymorphic relationships
* Eager loading with `with()` to prevent N+1 queries and knowing when to check for them
* Query scopes for reusable filter logic
* Knowing when Eloquent is the wrong tool and a raw query builder call is faster
**Why it matters:** N+1 query issues are the single most common cause of poor Laravel application performance. A developer who doesn’t proactively manage eager loading will hand you an application that falls over under real user load.
**How to test it:** Show them a simple model relationship and ask how they’d display a list of 100 orders with their associated customer names efficiently.
3. REST API Design and Implementation
Laravel makes building APIs straightforward. That doesn’t mean every developer builds them well.
Skills to verify:
* API resources and resource collections for consistent response shaping
* Proper HTTP status codes (not just 200 for everything and 500 when it breaks)
* API versioning strategy (URL-based `/api/v1/` vs header-based)
* Authentication via Sanctum (SPAs and mobile) or Passport (OAuth)
* Rate limiting and throttling
**Why it matters:** A poorly designed API is expensive to fix once clients are built against it. Breaking changes in an API affect every consumer mobile apps, third-party integrations, and your own frontend.
**How to test it:** Ask them to describe how they’d structure an API for a simple resource (say, blog posts with comments). Listen for decisions around authentication, versioning, and error response format.
4. Queue and Job Management
Any Laravel application handling email, notifications, reports, payments, or third-party API calls should be using queues. A developer who hasn’t worked with queues hasn’t built production applications at any meaningful scale.
Skills to verify:
* Job classes with `ShouldQueue`
* Redis or database queue drivers (and the tradeoffs between them)
* Laravel Horizon for monitoring queue workers
* Retry logic, failed job handling, and the `failed()` method
* Job batching and chaining for complex workflows
**Why it matters:** Queues are what separates applications that work in demos from applications that work under real load. Email that blocks the HTTP response, reports that time out, API calls that fail and don’t retry all of these are solved by proper queue usage.
**How to test it:** Ask them: “If a queued job fails, what happens? Walk me through your full failure-handling approach.”
5. Testing : PHPUnit or Pest, Doesn’t Matter. Writing Tests Does.
This is the skill most commonly omitted from job descriptions and most consequential when absent.
Skills to verify:
* Feature tests covering HTTP endpoints with real database interactions
* Using fakes `Mail::fake()`, `Queue::fake()`, `Storage::fake()` to avoid side effects in tests
* Database factories and the `RefreshDatabase` or `DatabaseTransactions` traits
* Testing authentication (acting as specific users in tests)
* Some experience with Pest’s architecture plugin for enforcing design constraints
**Why it matters:** Untested code is code that will break silently in production. Every serious codebase needs a test suite that gives developers confidence to refactor without fear. A developer who doesn’t write tests is handing you liability, not software.
**How to test it:** Ask them to describe how they’d test a controller endpoint that creates a new user and sends a welcome email.
If you’re planning to hire a Laravel developer, their testing habits will usually tell you more about their long-term engineering quality than their portfolio screenshots ever will.
6. Security Fundamentals
Laravel has excellent security defaults. A developer who doesn’t understand them will accidentally disable or bypass them.
Skills to verify:
* Mass assignment protection : defining `$fillable` or `$guarded` correctly
* SQL injection prevention : parameterized queries, never raw string interpolation
* CSRF protection : understanding when it applies and when to exclude routes
* File upload validation : rejecting executable file types, validating MIME types properly
* Sanctum vs Passport : knowing which authentication approach fits which use case
**Why it matters:** Most security vulnerabilities in Laravel applications aren’t framework bugs. They’re developer mistakes mass assignment vulnerabilities, missing authorization checks, and misconfigured file uploads.
**How to test it:** Ask them: “What security mistakes do you most commonly see in Laravel codebases you’ve inherited?”
7. Git and Collaborative Workflow
This matters more than most job descriptions acknowledge.
Skills to verify:
* Branch based workflow feature branches, pull requests, code review
* Meaningful commit messages that describe intent, not just action
* Conflict resolution in complex merges
* Understanding of `.gitignore` best practices (the `.env` file should never be committed)
**Why it matters:** Developers who’ve only ever worked solo develop habits that cause friction in team environments. Git history is project documentation. How someone uses Git tells you how they’ll work with your team.
**How to test it:** Ask them to describe their last team’s Git workflow. What was the branching strategy? How were code reviews handled?
8. Laravel Ecosystem Awareness
Beyond the framework itself, a strong Laravel developer should know the ecosystem tools that are now essentially standard.
Key tools to ask about:
* **Livewire or Inertia.js** : for full-stack features without a full SPA
* **Filament** : admin panel builder, now used extensively in production apps
* **Laravel Telescope or Debugbar** : for local debugging and profiling
* **Laravel Horizon** : for queue monitoring
* **Spatie packages** : permissions (`spatie/laravel-permission`), media library, activity log
**Why it matters:** A developer who’s aware of the ecosystem won’t reinvent the wheel. They’ll reach for a well maintained package where it makes sense and save you weeks of development time.
**How to test it:** Ask: “If I needed to add role based permissions to a Laravel application, how would you approach it?”
9. Database Design and Migrations
Laravel migrations are powerful. A developer who doesn’t think carefully about schema design will create migration files that are painful to reverse and databases that are expensive to query.
Skills to verify:
* Foreign keys and cascading deletes and when to use soft deletes instead
* Index strategy knowing which columns to index and why
* Migration naming that makes history readable (`add_status_column_to_orders_table` not `migration_1234`)
* Safe migrations for tables with large datasets avoiding table locks in production
**Why it matters:** Bad database design is one of the hardest technical debts to repay. Adding an index to a table with 10 million rows in production can lock the table for minutes. A developer who hasn’t thought about this will create a support incident.
**How to test it:** Ask: “If you needed to add a new column to a table that has 5 million existing rows in production, how would you handle the migration?”
10. Communication and Async Work Skills
This isn’t soft. It’s a technical requirement for remote collaboration.
Skills to verify:
* Clear written communication in pull request descriptions and comments
* Ability to ask good questions scoped, specific, with context rather than vague “I’m stuck” messages
* Proactive status updates without being chased
* Documentation habits READMEs, inline comments on non-obvious logic, Postman collections for APIs
**Why it matters:** A developer who can’t communicate clearly will bottleneck your team. You’ll spend more time managing them than they save you. This is especially critical for remote or offshore engagements where the communication channel is everything.
**How to test it:** Look at how they write during the hiring process itself. Their emails, their answers in a written questionnaire, their pull request descriptions in a trial task. It’s all data.
The Checklist
Use this during your next Laravel developer evaluation:
* [ ] PHP 8.x modern features — comfortable
* [ ] Eloquent: relationships, eager loading, scopes
* [ ] REST API design: resources, versioning, auth
* [ ] Queues: jobs, workers, Horizon, failed job handling
* [ ] Testing: feature tests, fakes, factories
* [ ] Security: mass assignment, CSRF, file uploads, SQL injection
* [ ] Git and collaborative workflow experience
* [ ] Ecosystem awareness: Livewire/Inertia, Filament, Spatie
* [ ] Database design: indexes, migrations, large-table safety
* [ ] Communication: written clarity, documentation habits
A developer who checks all ten is genuinely senior. Seven or eight, with a plan to close the gaps, is a solid mid-level hire. Fewer than six, and you’re taking on training that should be someone else’s job.
