10 Laravel Performance Optimization Tips I Learned After 10+ Years in Production

Fred Castro — Mon, 16 Feb 2026 20:57:25 +0000

After 10+ years building scalable web applications with Laravel for everything from startups to government systems, I've learned that performance optimization isn't about premature optimization—it's about knowing which battles to fight.

Currently leading development for a federal government system (CAPES), I've had to optimize Laravel apps handling thousands of concurrent users. Here are the 10 most impactful performance tips I wish I knew when I started.

1. Eager Loading: Stop the N+1 Query Monster

The #1 performance killer I see in Laravel codebases:

// BAD: N+1 queries
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->user->name; // Query fired for EACH post
}

// GOOD: 2 queries total
$posts = Post::with('user')->get();
foreach ($posts as $post) {
    echo $post->user->name;
}

Impact: Reduced query count from 1,001 to 2 queries in a real project.

2. Database Indexing: The Silent Performance Booster

Add indexes to columns you filter/join on:

Schema::table('posts', function (Blueprint $table) {
    $table->index('user_id');
    $table->index('status');
    $table->index(['category_id', 'published_at']); // Composite index
});

Pro tip: Use EXPLAIN in MySQL to identify missing indexes.

3. Cache Expensive Operations

// Cache database queries
$users = Cache::remember('active_users', 3600, function () {
    return User::where('active', true)->get();
});

// Cache computed values
$stats = Cache::remember('dashboard_stats', 600, function () {
    return [
        'total_users' => User::count(),
        'active_sessions' => Session::where('active', true)->count(),
    ];
});

In production: This reduced our dashboard load time from 2.3s to 180ms.

4. Use Redis for Sessions and Cache

// config/database.php
'redis' => [
    'client' => 'phpredis', // Use phpredis extension, not predis
    'cluster' => false,
    'default' => [
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD', null),
        'port' => env('REDIS_PORT', 6379),
        'database' => 0,
    ],
],

Why Redis? Memory-based storage = 10-100x faster than database sessions.

5. Optimize Eloquent: Select Only What You Need

// BAD: Fetches all columns
$users = User::all();

// GOOD: Select specific columns
$users = User::select('id', 'name', 'email')->get();

// EVEN BETTER: Use pluck for single column
$emails = User::pluck('email');

6. Queue Heavy Operations

Don't make users wait for emails, notifications, or file processing:

// Dispatch to queue
ProcessVideoUpload::dispatch($video);
SendWelcomeEmail::dispatch($user);

// Chain jobs
ProcessOrder::withChain([
    new SendInvoice($order),
    new UpdateInventory($order),
])->dispatch($order);

Result: Page response time dropped from 4s to 300ms.

7. Optimize Autoloader with Composer

composer dump-autoload --optimize
composer install --optimize-autoloader --no-dev

In production: Always run with optimization flags.

8. Enable OPcache in Production

; php.ini
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=10000
opcache.validate_timestamps=0 # Disable in production
opcache.revalidate_freq=0

Impact: 30-50% performance boost for free.

9. Use Chunk for Large Datasets

// BAD: Loads 100k records into memory
User::where('active', true)->get()->each(function ($user) {
    // Process user
});

// GOOD: Process in chunks
User::where('active', true)->chunk(200, function ($users) {
    foreach ($users as $user) {
        // Process user
    }
});

10. Monitor with Laravel Telescope & Horizon

Install in development to identify bottlenecks:

composer require laravel/telescope --dev
composer require laravel/horizon

Telescope shows you:

Slow queries
Memory usage
Request duration
N+1 query problems

Bonus: Production Checklist

Enable OPcache
Use Redis for cache/sessions
Run php artisan config:cache
Run php artisan route:cache
Run php artisan view:cache
Use CDN for assets
Enable GZIP compression
Database connection pooling

My Stack for High-Performance Laravel Apps

After years of optimization, here's what I recommend:

Web Server: Nginx + PHP-FPM
Cache: Redis (with phpredis extension)
Database: PostgreSQL with proper indexes
Queue: Redis or RabbitMQ for complex workflows
Monitoring: Laravel Telescope + Horizon + New Relic

Wrapping Up

Performance optimization is a journey, not a destination. Start with the low-hanging fruit (eager loading, indexing, caching) and measure the impact.

In my work on the CAPES federal system, these optimizations reduced response times from 3-5 seconds to under 200ms, handling thousands of concurrent users smoothly.

What's your #1 Laravel performance tip? Drop it in the comments!

Building scalable Laravel apps for 10+ years | Currently: Senior PHP/Laravel Developer at CAPES | Available for consulting and architecture reviews

DEV Community: Fred Castro