Laravel

Web performance consultant for Laravel

Optimize web performance on Laravel applications

Laravel ships fast, and fast shipping opens the door to Eloquent N+1, unindexed queries, synchronous jobs and misconfigured opcache. I work on the Laravel backend to drop TTFB and stabilize Core Web Vitals.

100% satisfied clients Data 2023-2026 8+ years XP 35+ clients partnered
View my client cases

They trust me

CHANEL
DIOR
Decathlon
April Moto
SiriusXM
Make Up Forever
Camif
RIMOWA
Jimmy Fairly
Wecasa
Chronovet
CHANEL
DIOR
Decathlon
April Moto
SiriusXM
Make Up Forever
Camif
RIMOWA
Jimmy Fairly
Wecasa
Chronovet

Laravel symptoms calling for an audit

Poorly framed Laravel applications show specific symptoms that backend diagnosis exposes within hours.

🔁 TTFB climbing linearly with data volume

Eloquent N+1 pattern: the page loops on N entities and queries their relations one by one. Telescope exposes the pattern, with() refactor drops TTFB 30 to 60%.

🐢 Non-optimized Laravel bootstrap in production

Without config:cache, route:cache, view:cache and optimize, every request reloads config and compiles routes. Proper activation gains 50 to 150ms of TTFB.

💾 Sessions in database, not Redis

With database sessions, every request reads and writes SQL. Moving to Redis sessions (and global Redis cache) drops TTFB and frees MySQL for real queries.

📧 Synchronous emails and API calls

A synchronous Mail::send() adds 200-500ms to response time. Moving to Redis queue + Horizon shifts these tasks out of the request lifecycle. Perceived TTFB collapses.

⚙️ PHP 7.x or opcache disabled in production

PHP 8.x with opcache and JIT divides Laravel execution time by 2 to 4. PHP upgrade and opcache + JIT activation are the most cost-effective gains of any PHP stack.

🚀 Traffic climbing but latency drifting

Without Octane (Swoole, RoadRunner, FrankenPHP), Laravel bootstraps on every request. Octane keeps the app in memory and drops TTFB 40 to 100ms for free. Worth considering at sustained 500 req/s.

Laravel optimization methodology

4 steps to transform your performance

1
Step 1

1. Telescope or Debugbar profiling

Identify N+1, slow SQL queries, synchronous calls. Map LCP-critical endpoints.

2
Step 2

2. Eloquent and MySQL optimization

N+1 refactor (with(), load(), eager loading), SQL index addition on real usage, slow query optimization via explain().

3
Step 3

3. Caching and async

Redis for cache and sessions, Horizon queue for async jobs (emails, exports, API calls), routes/config/views cache in production.

4
Step 4

4. Octane where relevant

Octane evaluation (Swoole, RoadRunner, FrankenPHP) based on traffic profile. Incremental migration with compatibility testing (singletons, shared memory).

Mission commitments

-50% typical Laravel TTFB
N+1 eliminated on critical templates
Continuous Eloquent profiled on every release
Queues async on heavy jobs
FAQ

Frequently asked questions

Is Laravel Octane worth the complexity?
On high-traffic applications (sustained 500 req/s+) or with critical TTFB, yes. Octane drops TTFB 40 to 100ms for free. On moderate-traffic apps, the investment (singleton refactor, memory management) doesn't always justify itself. The audit decides.
Telescope or Debugbar for profiling?
Debugbar for local development and quick-debug (acceptable overhead). Telescope for continuous diagnosis, local or staging — particularly useful to identify N+1 and slow queries on realistic traffic. Telescope in production stays possible but with tight scoping to avoid memory cost.
Should I move to FrankenPHP?
FrankenPHP combines PHP + web server (Caddy) + worker mode + native early hints. A modern and performant alternative to PHP-FPM. Worth evaluating on new projects, migrating cautiously on existing ones (extension compatibility, monitoring).
How are your Laravel engagements structured?
My Laravel engagements run as continuous sprints. The first sprint frames the stack (Eloquent, opcache, queues, Octane if relevant) and the roadmap. Following sprints work optimizations with before/after measurement and release validation. An active Laravel application keeps evolving — N+1 debt rebuilds if nobody profiles every release.

Drop your Laravel TTFB

Eloquent N+1 eliminated
Cache + queues optimized
Octane where relevant
100% satisfied clients
Data 2023-2026
Testimonials

What my clients say

Excellent work.
Paul has significantly improved the site's speed and perfectly aligned it with Google's recommendations.
Professional, thorough, and efficient, I highly recommend.

Nicolas - April Moto

Digital & E-commerce Director

We are very satisfied with Paul's work. He is quick, available, and particularly effective. Since his arrival, very good results have been observed, both in terms of performance and responsiveness. A real asset for our team.

Léo - Luxury brand

E-commerce Product Owner

I don't know if we've said it enough.
But if you want to improve your loading speed,
Make Google happy and get your Core Web Vitals in the green,
Contact Paul Delcloy.

Florian Darroman - Les Makers

Co-founder

Laravel, high productivity and performance to frame

Laravel powers a significant share of French and international PHP backends, from SMBs to scale-ups. Its productivity (Eloquent, queues, broadcasting, Livewire) ships fast — and that speed easily masks performance problems that only show up at real load: Eloquent N+1, synchronous jobs that should be async, opcache disabled in production, forgotten route and config caches.

The web performance optimization angle on Laravel is mostly backend: Eloquent profiled with Telescope or Debugbar, MySQL indexed on real usage, opcache + PHP 8.x JIT active, Redis for cache and sessions, Octane (Swoole or RoadRunner) when traffic profile justifies it, async queues via Horizon.

Eloquent and N+1, first work-stream

The Eloquent ORM makes joins nearly invisible — that's its strength and its trap. A page looping on 50 entities and accessing their relations without with() triggers 51 SQL queries. On LCP-critical templates, this pattern is among the leading causes of drifting TTFB.

Laravel Telescope or Laravel Debugbar diagnosis exposes N+1 immediately. Refactoring (with(), load(), optimized scopes) drops TTFB by 30 to 60% on affected pages. On some applications, it's the lever that alone gets Core Web Vitals green.

Octane and queues for scale

Beyond classic optimizations, Laravel offers Octane (Swoole, RoadRunner, FrankenPHP) which keeps the application in memory between requests. Laravel bootstrap no longer runs on every request, TTFB typically drops 40 to 100ms for free. On high-traffic stacks, Octane changes scale economics.

Queues (via Redis or SQS, monitored by Horizon) move everything async-able out of the request lifecycle: email sending, PDF generation, third-party API calls, heavy computations. Every synchronous call that becomes async frees perceived latency.