Optimize Composer’s autoloader using composer install --optimize-autoloader --no-dev and composer dump-autoload --classmap-authoritative to speed up class loading. 2. Cache configuration and routes in production with php artisan config:cache and php artisan route:cache to reduce bootstrap overhead. 3. Optimize database performance by using eager loading to prevent N 1 queries, adding indexes on frequently queried columns, and caching expensive queries with Cache::remember(). 4. Use Laravel Octane with Swoole or RoadRunner to keep the application in memory, eliminating boot time and enabling high throughput for APIs and heavy traffic. 5. Optimize frontend assets by compiling and versioning with Mix or Vite, minifying CSS/JS, enabling Gzip/Brotli compression, and leveraging browser caching. 6. Offload heavy tasks like emails and file processing to queues using php artisan queue:work and manage workers with Supervisor for better performance. 7. Enable OPcache in PHP with proper settings in php.ini to store precompiled scripts and disable timestamp validation in production for faster execution. 8. Cache Blade templates using php artisan view:cache to avoid recompilation on every request and improve rendering speed. 9. Reduce middleware overhead by removing unnecessary middleware, avoiding heavy logic in global middleware, and using lazy or route-specific middleware where possible. 10. Monitor performance using tools like Laravel Telescope, Debugbar, or APM solutions such as New Relic and Datadog to identify slow queries, memory leaks, and redundant calls, ensuring continuous optimization through measurement and refinement.

Laravel is powerful and developer-friendly, but as your application grows, performance can become a concern. Here are practical optimization tips that can significantly improve your Laravel app’s speed and efficiency.

1. Optimize Autoloader and Composer

Composer’s autoloader can slow down your app if not optimized, especially in production.

Run:

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

This:

• Dumps an optimized autoloader (uses class maps for faster lookup)
• Excludes development dependencies

Also, consider using classmap authoritative for even faster autoloading:

composer dump-autoload --classmap-authoritative

2. Cache Configuration and Routes

Every time Laravel boots, it loads config files and parses routes. Caching these reduces overhead.

Cache config:

php artisan config:cache

Cache routes:

php artisan route:cache

?? Only run these in production. During development, use config:clear and route:clear as needed.

3. Optimize Database Queries

Slow queries are a common bottleneck.

Use Eager Loading

Avoid N 1 queries by preloading relationships:

// Bad: N 1 problem
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->user->name;
}

// Good: Eager load
$posts = Post::with('user')->get();

Add Indexes

Ensure database columns used in WHERE, JOIN, or ORDER BY clauses are indexed.

Use Query Caching (when applicable)

For expensive, infrequently changing queries:

$users = Cache::remember('users.active', 3600, function () {
    return User::where('active', 1)->get();
});

4. Use Laravel Octane (for High Performance)

Laravel Octane boots your app once and keeps it in memory using Swoole or RoadRunner.

Benefits:

• Eliminates boot time on every request
• Handles thousands of requests per second
• Great for APIs and high-traffic apps

Install via:

composer require laravel/octane
php artisan octane:install
php artisan octane:start

Note: Requires additional setup (e.g., Swoole extension) and careful handling of shared state.

5. Optimize Assets and Frontend

Even backend optimizations won’t help if the frontend is slow.

• Use mix() or vite() with versioning in production
• Minify CSS/JS
• Enable Gzip/Brotli compression on your web server
• Leverage browser caching with proper headers

Run in production:

npm run build

6. Use Queue Workers for Heavy Tasks

Move time-consuming tasks (emails, file processing, notifications) to queues.

Use database, Redis, or Amazon SQS:

php artisan queue:work --daemon

Better yet, use Supervisor to manage long-running workers.

7. Enable OPcache (PHP)

OPcache stores precompiled script bytecode in memory, eliminating parsing/compilation on each request.

Ensure it’s enabled in php.ini:

opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0 ; Set to 1 in development

Set validate_timestamps=0 in production to prevent file checks (clear manually after deploy).

8. Cache Views and Blade Templates

Blade compilation can be cached:

php artisan view:cache

This compiles .blade.php files into raw PHP and stores them, reducing parsing time.

Clear when updating templates:

php artisan view:clear

9. Reduce Middleware Overhead

Every middleware adds execution time. Review and remove unnecessary ones.

• Avoid heavy logic in global middleware
• Use route-specific middleware instead of global when possible
• Consider lazy middleware (Laravel 9 ) for conditional loading

10. Monitor and Profile Performance

Use tools to identify bottlenecks:

• Laravel Telescope (for dev)
• Laravel Debugbar
• Application Performance Monitoring (APM) tools like New Relic, Datadog, or Sentry

Look for:

• Slow queries
• Memory leaks
• Redundant HTTP calls
• Large payloads

Basically, Laravel performance tuning is about reducing repeated work—cache what you can, offload what you can, and measure what you can’t see. Most gains come from caching, query optimization, and switching to Octane where appropriate.

The above is the detailed content of Laravel performance optimization tips. For more information, please follow other related articles on the PHP Chinese website!