Conquering the 7 Levels of Laravel Performance Optimization

Measuring Your Performance Gains#

Before you start optimizing, establish how to measure progress. Use simple counters for data volume and PHP's built-in functions for memory and timing metrics. This approach lets you quantify the impact of each optimization level you apply.

$posts_count = $posts->count(); // No. Of Posts
$users_count = $users->count(); // No. Of Users
$time_taken = round(microtime(2) - LARAVEL_START, 2) . ' Second'; // Time Taken
$memory_used = round((memory_get_peak_usage() / 1024 / 1024), 2) . ' MB'; // Memory Used

Track these metrics consistently as you move through each level. You'll see concrete differences in how much memory your queries consume and how long they take to execute.

Level 1: Eager loading to crush the N+1 problem from the start#

When you first begin optimizing Laravel, the initial hurdle is often the N+1 query problem. N+1 problems occur when additional queries are generated for each item in a dataset, multiplying the database load. Eager loading resolves this by loading related models in a single query.

$posts = Post::with('user')->get();

Level 2: Selective loading means data you need, nothing more#

At Level 2, you start questioning whether you really need to load all the data. Is every column essential for your task? Instead of loading everything, select only the necessary columns. This simplifies your queries, reduces memory usage, and makes your app faster.

$posts = Post::with('user:id,name')->select('id', 'user_id', 'title')->get();

Level 3: Split query optimization with smart separation#

You're stepping up your game now. Eager loading isn't always the answer. Instead, you manually separate queries, fetching posts first and then retrieving users in a more controlled and efficient way. This approach gives you finer control over what gets loaded and when.

$posts = Post::select('id','user_id','title')->get();
$users = User::query()->whereIn('id', $posts->pluck('user_id')->unique())->pluck('name', 'id');

Level 4: Database filtering for advanced querying#

You're exploring new techniques and letting the database do more work. Applying distinct filtering directly in your queries speeds up data processing and reduces the load on Laravel while keeping memory usage in check.

$query = Post::query();
$posts = (clone $query)->select('id', 'user_id', 'title')->get();
$users = User::query()
        ->whereIn('id', (clone $query)->select('user_id')->distinct())
        ->get();

Level 5: Speed mode on, skip Eloquent with toBase()#

At Level 5, you take optimization further by using the toBase() method to bypass Laravel's Eloquent overhead. This approach retrieves raw data directly, reducing processing time and memory usage. It's ideal for efficiently handling large datasets where you don't need Eloquent's model features.

$query = Post::query();
$posts = (clone $query)->select('id', 'user_id', 'title')
        ->toBase()
        ->get();
$users = User::whereIn('id', (clone $query)
        ->select('user_id')->distinct())
        ->toBase()
        ->get();

Level 6: Load data in chunks. The power move#

Now you handle large datasets efficiently by using chunkById. This method breaks data into smaller, manageable chunks, preventing memory overload and ensuring smooth processing, even with massive amounts of data. You process batches rather than loading everything at once.

$query = Post::query();
$posts = collect();
(clone $query)->select('id', 'user_id', 'title')
     ->toBase()
     ->orderBy('posts.id')
     ->chunkById(10000, function ($collection) use (&$posts) {
         $posts->push(...$collection);
     }, 'id');

$users = User::whereIn('id', (clone $query)
            ->select('user_id')
            ->distinct())
            ->toBase()
            ->get();

Level 7: Lazy loading for minimal memory, maximum performance#

Level 7 focuses on mastering lazy collections, which efficiently handles large datasets by combining chunking with Laravel's lazy processing. It processes data in smaller chunks, minimizing memory usage while maintaining high performance. This is the ultimate optimization for massive datasets.

$query = Post::query();
$posts = collect();
(clone $query)->select('id', 'user_id', 'title')
     ->toBase()
     ->orderBy('posts.id')
     ->chunkById(5000, function ($collection) use (&$posts) {
         $posts->push(...$collection);
     }, 'id');

$users = User::whereIn('id', (clone $query)
            ->select('user_id')
            ->distinct())
            ->toBase()
            ->get();

Your Application Is Now Supercharged#

You've mastered the seven levels of Laravel optimization, transforming your application into a high-performance powerhouse. By utilizing techniques such as eager loading, chunking, and lazy collections, you've significantly decreased memory usage and processing time. The result speaks for itself: reducing memory from 120 MB to just 6.7 MB is a 95 percent reduction that directly improves your users' experience.

Remember, enhancing your application is an ongoing journey. Continue refining your approach, experimenting with new strategies, and pushing the boundaries of efficiency. Each level you master gives you tools to handle bigger datasets and more complex queries without sacrificing speed or stability.