Eloquent Performance Optimization: Techniques That Make a Difference

The Beauty and Beast of Eloquent

Eloquent is one of Laravel's crown jewels—an elegant ORM that makes database interactions feel natural and expressive. But that elegance can hide performance problems that only surface when your application reaches production scale. Understanding how Eloquent translates your code into SQL is essential for building performant applications.

Lazy Loading vs Eager Loading

The N+1 query problem is the most common performance issue I see in Laravel applications. It's easy to write, easy to miss, and can bring your application to its knees.

// This generates N+1 queries
$orders = Order::all();
foreach ($orders as $order) {
    echo $order->customer->name;
    foreach ($order->items as $item) {
        echo $item->product->name;
    }
}

// This generates 3 queries regardless of order count
$orders = Order::with(['customer', 'items.product'])->get();

Enable strict mode during development to catch lazy loading violations:

// In AppServiceProvider::boot()
Model::preventLazyLoading(!app()->isProduction());

Chunking for Large Datasets

When processing large datasets, loading everything into memory will crash your application. Use chunking to process records in batches:

// Memory efficient processing
Order::where('status', 'pending')
    ->chunk(1000, function ($orders) {
        foreach ($orders as $order) {
            $order->process();
        }
    });

// Even better for updates - uses less memory
Order::where('status', 'pending')
    ->chunkById(1000, function ($orders) {
        foreach ($orders as $order) {
            $order->update(['status' => 'processed']);
        }
    });

Query Scopes for Reusability

Query scopes keep your code DRY and your queries consistent across the application:

class Order extends Model
{
    public function scopeRecent($query, $days = 30)
    {
        return $query->where('created_at', '>=', now()->subDays($days));
    }

    public function scopeHighValue($query, $threshold = 1000)
    {
        return $query->where('total', '>=', $threshold);
    }
}

// Clean, readable queries
$recentHighValueOrders = Order::recent(7)
    ->highValue(5000)
    ->with('customer')
    ->get();

Using Database Features Directly

Sometimes Eloquent's abstraction gets in the way. For complex operations, don't be afraid to use raw queries or database-specific features:

// Use database aggregation instead of PHP
$stats = DB::table('orders')
    ->select([
        DB::raw('DATE(created_at) as date'),
        DB::raw('COUNT(*) as count'),
        DB::raw('SUM(total) as revenue'),
    ])
    ->groupBy('date')
    ->orderBy('date', 'desc')
    ->limit(30)
    ->get();

Indexing Strategies

Proper indexing is the single most impactful optimization you can make. Analyze your slow query log and add indexes for:

• Columns in WHERE clauses
• Columns used in JOINs
• Columns in ORDER BY statements
• Composite indexes for queries filtering on multiple columns

Schema::table('orders', function (Blueprint $table) {
    // Composite index for common query pattern
    $table->index(['customer_id', 'status', 'created_at']);
});

Conclusion

Eloquent performance optimization is about understanding the SQL your code generates and making intentional decisions about when to use its conveniences and when to bypass them. Profile your queries, add appropriate indexes, and always eager load relationships. Your users will thank you.