How to prevent performance issues in Laravel by using eager loading

In this guide, we’ll look at why eager loading should be considered a default practice when working with Eloquent models. It helps prevent hidden performance issues, reduces unnecessary database queries, and makes your application scale more predictably as it grows.

What eager loading solves in Eloquent

Before we start, let’s take a look at the issue eager loading is designed to solve. Eloquent makes working with relationships very easy. You can access related models as if they were simple properties, which makes code readable and expressive. However, this convenience can easily hide performance problems when relationships are not loaded efficiently.

By default, Eloquent will only load related data when you access it. This behavior is often fine for small datasets, but it becomes problematic once your application grows and more data is involved.

Understanding the N+1 query problem

Consider a simple example where a user has many posts.

<?php 

$users = User::get();

foreach ($users as $user) {
    echo $user->posts->count();
}

At first glance, this code looks perfectly reasonable. However, behind the scenes, Laravel will execute one query to retrieve all users and then an additional query for each user when the posts relationship is accessed.

If you have 100 users, this results in 101 queries. As the number of users increases, the number of queries grows linearly, which can quickly slow down your application.

This behavior is commonly referred to as the N+1 query problem.

Loading related data upfront

To avoid this issue, relationships should be loaded before they are accessed.

<?php

$users = User::with('posts')->get();

foreach ($users as $user) {
    echo $user->posts->count();
}

With this approach, Laravel executes one query to fetch the users and one additional query to fetch all related posts. The data is then mapped in memory, allowing you to access relationships without triggering extra queries.

This makes the performance characteristics of your code much more predictable.

Why using all() often leads to problems

One method that frequently causes performance issues is all().

<?php
  
$orders = Order::all();

Using all() retrieves every record from the database without expressing which relationships are required. This often leads to relationship access later in the codebase, introducing additional queries without making them obvious.

For example:

<?php
  
foreach ($orders as $order) {
    echo $order->user->email;
}

In this case, Laravel will execute an extra query for each order to retrieve the related user. These queries are easy to overlook during development but can become costly in production environments.

Making queries explicit and predictable

A better approach is to define exactly which relationships are needed at query time.

<?php

$orders = Order::with('user')->get();

This makes it clear which data is required and ensures that all necessary information is loaded efficiently. Anyone reading the code can immediately understand which relationships are involved and how the data is retrieved.

Explicit queries also make it easier to reason about performance and avoid accidental database bottlenecks.

Preventing performance issues as your application grows

Performance problems caused by missing eager loading often do not appear early in development. They usually surface once data volume increases or when the application starts receiving more traffic.

By consistently loading relationships upfront, you eliminate an entire class of performance issues before they occur. This approach requires very little effort but provides long-term benefits as your application scales.

Conclusion

Eager loading is not an optional optimization or something to add later. It is a fundamental practice when working with Eloquent models. By avoiding methods like all() and being explicit about your data requirements, you build applications that are easier to maintain, easier to reason about, and far more scalable.

Making eager loading a habit early on will save you from performance problems that are otherwise difficult to track down later.