10 Essential Laravel Performance Optimization Techniques

Published in Laravel, Performance on Mar 28, 2025

In today's competitive web landscape, application performance isn't just a technical consideration—it's a critical business factor. A slow Laravel application leads to poor user experience, reduced engagement, and ultimately lost revenue. This article explores ten proven techniques to supercharge your Laravel application's performance.

1. Database Optimization: The Foundation of Performance

The database layer is often the primary bottleneck in Laravel applications. Implementing proper optimization techniques here yields the most significant performance gains.

Eloquent Query Optimization

Laravel's Eloquent ORM provides a beautiful syntax for database operations, but used carelessly, it can generate inefficient queries:

Copied!

1// INEFFICIENT: Retrieving all columns when you only need a few
2$users = User::all();
3 
4// OPTIMIZED: Select only the columns you need
5$users = User::select('id', 'name', 'email')->get();

// INEFFICIENT: Retrieving all columns when you only need a few
$users = User::all();

// OPTIMIZED: Select only the columns you need
$users = User::select('id', 'name', 'email')->get();

Solving the N+1 Query Problem

The N+1 query problem occurs when your code retrieves a collection of models and then executes additional queries to retrieve related models:

Copied!

 1// PROBLEMATIC: Generates N+1 queries
 2$posts = Post::all();
 3foreach ($posts as $post) {
 4    echo $post->author->name; // Additional query for each post
 5}
 6 
 7// OPTIMIZED: Use eager loading
 8$posts = Post::with('author')->get();
 9foreach ($posts as $post) {
10    echo $post->author->name; // No additional queries
11}

// PROBLEMATIC: Generates N+1 queries
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Additional query for each post
}

// OPTIMIZED: Use eager loading
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name; // No additional queries
}

Eager loading can reduce dozens or hundreds of queries down to just two.

Strategic Indexing

Proper database indexes dramatically improve query performance. Add indexes for columns frequently used in WHERE, JOIN, and ORDER BY clauses:

Copied!

1// Add in a migration
2Schema::table('posts', function (Blueprint $table) {
3    $table->index('user_id');
4    $table->index('published_at');
5});

// Add in a migration
Schema::table('posts', function (Blueprint $table) {
    $table->index('user_id');
    $table->index('published_at');
});

2. Implement Robust Caching Strategies

Caching is one of the most effective ways to improve application performance, reducing database load and computation time.

Query Result Caching

Cache the results of expensive or frequent database queries:

Copied!

1$users = Cache::remember('users', 3600, function () {
2    return User::withCount('posts')->get();
3});

$users = Cache::remember('users', 3600, function () {
    return User::withCount('posts')->get();
});

Data Caching

Cache computed values or API responses:

Copied!

1$apiData = Cache::remember('api.data', 60, function () {
2    return Http::get('https://api.example.com/data')->json();
3});

$apiData = Cache::remember('api.data', 60, function () {
    return Http::get('https://api.example.com/data')->json();
});

Full-Page Caching

For pages that don't require user-specific content, consider full-page caching:

Copied!

 1// In a controller
 2public function index()
 3{
 4    if (Cache::has('homepage')) {
 5        return Cache::get('homepage');
 6    }
 7 
 8    $view = view('home', ['data' => $this->getData()])->render();
 9    Cache::put('homepage', $view, 3600);
10 
11    return $view;
12}

// In a controller
public function index()
{
    if (Cache::has('homepage')) {
        return Cache::get('homepage');
    }

    $view = view('home', ['data' => $this->getData()])->render();
    Cache::put('homepage', $view, 3600);

    return $view;
}

3. Route Caching for Production Environments

Laravel's route caching can significantly improve performance in production:

Copied!

1php artisan route:cache

php artisan route:cache

This command pre-compiles all your routes into a single file, eliminating the need to parse the route definitions on each request. Remember to clear and regenerate this cache whenever you update your routes:

Copied!

1php artisan route:clear
2php artisan route:cache

php artisan route:clear
php artisan route:cache

4. Laravel Optimization Commands

The `optimize` Command in Laravel

Laravel has a streamlined approach to application optimization with the optimize command:

Copied!

1php artisan optimize

php artisan optimize

This single command clears various caches and prepares your application for optimal performance by running:

Copied!

1php artisan cache:clear
2php artisan clear-compiled
3php artisan config:clear
4php artisan event:clear
5php artisan route:clear
6php artisan view:clear

php artisan cache:clear
php artisan clear-compiled
php artisan config:clear
php artisan event:clear
php artisan route:clear
php artisan view:clear

After clearing these caches, you can rebuild them for production:

Copied!

1php artisan config:cache
2php artisan route:cache
3php artisan view:cache
4php artisan event:cache

php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan event:cache

This two-step process ensures a clean slate before building optimized caches for your production environment.

5. Optimize Composer's Autoloader

When deploying to production, optimize Composer's autoloader:

Copied!

1composer install --optimize-autoloader --no-dev

composer install --optimize-autoloader --no-dev

This generates a class map, which improves class loading performance. The --no-dev flag ensures development dependencies aren't installed in production.

6. Use Laravel's Queue System for Background Processing

Move time-consuming tasks to background queues to improve response times:

Copied!

 1// Instead of processing directly in a controller:
 2public function processReport()
 3{
 4    // This blocks the user from getting a response
 5    $this->reportService->generateLargeReport();
 6 
 7    return redirect()->back()->with('status', 'Report processed');
 8}
 9 
10// Use a queue to process in the background:
11public function processReport()
12{
13    GenerateReportJob::dispatch();
14 
15    return redirect()->back()->with('status', 'Report queued for processing');
16}

// Instead of processing directly in a controller:
public function processReport()
{
    // This blocks the user from getting a response
    $this->reportService->generateLargeReport();

    return redirect()->back()->with('status', 'Report processed');
}

// Use a queue to process in the background:
public function processReport()
{
    GenerateReportJob::dispatch();

    return redirect()->back()->with('status', 'Report queued for processing');
}

Configure Laravel Horizon for improved queue monitoring and management:

Copied!

1composer require laravel/horizon
2php artisan horizon:install

composer require laravel/horizon
php artisan horizon:install

7. Implement Database Connection Pooling

Database connection pooling maintains a collection of reusable database connections, eliminating the overhead of establishing new connections for each request.

For AWS RDS databases, use RDS Proxy:

Copied!

1DB_HOST=your-proxy-endpoint.proxy-abcdefghijkl.region.rds.amazonaws.com
2DB_PORT=3306

DB_HOST=your-proxy-endpoint.proxy-abcdefghijkl.region.rds.amazonaws.com
DB_PORT=3306

For PostgreSQL, implement PgBouncer:

Copied!

 1# PgBouncer configuration
 2[databases]
 3laravel_db = host=127.0.0.1 port=5432 dbname=laravel_db
 4 
 5[pgbouncer]
 6listen_port = 6432
 7listen_addr = 127.0.0.1
 8auth_type = md5
 9pool_mode = transaction
10max_client_conn = 100
11default_pool_size = 20

# PgBouncer configuration
[databases]
laravel_db = host=127.0.0.1 port=5432 dbname=laravel_db

[pgbouncer]
listen_port = 6432
listen_addr = 127.0.0.1
auth_type = md5
pool_mode = transaction
max_client_conn = 100
default_pool_size = 20

8. Optimize Front-End Asset Delivery

Vite for Asset Bundling

Laravel now uses Vite by default for bundling and minifying CSS and JavaScript, which offers faster build times and improved performance:

Copied!

 1// vite.config.js
 2import { defineConfig } from 'vite';
 3import laravel from 'laravel-vite-plugin';
 4 
 5export default defineConfig({
 6    plugins: [
 7        laravel({
 8            input: [
 9                'resources/css/app.css',
10                'resources/js/app.js',
11            ],
12            refresh: true,
13        }),
14    ],
15});

// vite.config.js
import { defineConfig } from 'vite';
import laravel from 'laravel-vite-plugin';

export default defineConfig({
    plugins: [
        laravel({
            input: [
                'resources/css/app.css',
                'resources/js/app.js',
            ],
            refresh: true,
        }),
    ],
});

In your layout:

Copied!

1@vite(['resources/css/app.css', 'resources/js/app.js'])

@vite(['resources/css/app.css', 'resources/js/app.js'])

Implement a CDN

Serve static assets through a Content Delivery Network:

Copied!

1// In config/app.php
2'asset_url' => env('ASSET_URL', 'https://your-cdn.com'),

// In config/app.php
'asset_url' => env('ASSET_URL', 'https://your-cdn.com'),

9. Use Lazy Collections for Large Datasets

When working with large datasets, use Laravel's lazy collections to reduce memory usage:

Copied!

1// This loads all records into memory at once - problematic for large tables
2User::all()->filter(function ($user) {
3    return $user->is_active;
4});
5 
6// This processes records one at a time - much more memory efficient
7User::cursor()->filter(function ($user) {
8    return $user->is_active;
9});

// This loads all records into memory at once - problematic for large tables
User::all()->filter(function ($user) {
    return $user->is_active;
});

// This processes records one at a time - much more memory efficient
User::cursor()->filter(function ($user) {
    return $user->is_active;
});

10. Implement HTTP/2 and Edge Caching

Enable HTTP/2

HTTP/2 improves performance through multiplexing, header compression, and server push. Configure your web server accordingly:

For Nginx:

Copied!

1listen 443 ssl http2;

listen 443 ssl http2;

For Apache:

Copied!

1Protocols h2 http/1.1

Protocols h2 http/1.1

Implement Edge Caching with Laravel

Set appropriate cache headers in your responses:

Copied!

1return response()->view('home')
2    ->header('Cache-Control', 'public, max-age=60, s-maxage=300');

return response()->view('home')
    ->header('Cache-Control', 'public, max-age=60, s-maxage=300');

Or use middleware for broader application:

Copied!

 1class CacheControl
 2{
 3    public function handle($request, Closure $next)
 4    {
 5        $response = $next($request);
 6 
 7        $response->header('Cache-Control', 'public, max-age=60');
 8 
 9        return $response;
10    }
11}

class CacheControl
{
    public function handle($request, Closure $next)
    {
        $response = $next($request);

        $response->header('Cache-Control', 'public, max-age=60');

        return $response;
    }
}

Conclusion: Monitor, Measure, and Refine

Performance optimization is an ongoing process. Implement Laravel Telescope or other monitoring tools to continuously track application performance and identify bottlenecks:

Copied!

1composer require laravel/telescope --dev
2php artisan telescope:install

composer require laravel/telescope --dev
php artisan telescope:install

By applying these ten optimization techniques, you can significantly improve your Laravel application's performance, providing a better experience for your users and reducing server costs. Remember that optimization should always be data-driven: measure before and after implementing changes to ensure you're making meaningful improvements.

10 Essential Laravel Performance Optimization Techniques

#1. Database Optimization: The Foundation of Performance

#Eloquent Query Optimization

#Solving the N+1 Query Problem

#Strategic Indexing

#2. Implement Robust Caching Strategies

#Query Result Caching

#Data Caching

#Full-Page Caching

#3. Route Caching for Production Environments

#4. Laravel Optimization Commands

#The optimize Command in Laravel

#5. Optimize Composer's Autoloader

#6. Use Laravel's Queue System for Background Processing

#7. Implement Database Connection Pooling

#8. Optimize Front-End Asset Delivery

#Vite for Asset Bundling

#Implement a CDN

#9. Use Lazy Collections for Large Datasets

#10. Implement HTTP/2 and Edge Caching

#Enable HTTP/2

#Implement Edge Caching with Laravel

#Conclusion: Monitor, Measure, and Refine

1. Database Optimization: The Foundation of Performance

Eloquent Query Optimization

Solving the N+1 Query Problem

Strategic Indexing

2. Implement Robust Caching Strategies

Query Result Caching

Data Caching

Full-Page Caching

3. Route Caching for Production Environments

4. Laravel Optimization Commands

The `optimize` Command in Laravel

5. Optimize Composer's Autoloader

6. Use Laravel's Queue System for Background Processing

7. Implement Database Connection Pooling

8. Optimize Front-End Asset Delivery

Vite for Asset Bundling

Implement a CDN

9. Use Lazy Collections for Large Datasets

10. Implement HTTP/2 and Edge Caching

Enable HTTP/2

Implement Edge Caching with Laravel

Conclusion: Monitor, Measure, and Refine