Squeezing Peak Performance from Laravel

Laravel has captured the hearts of PHP developers everywhere. The framework makes building full-featured applications straightforward thanks to powerful routing, eloquent ORM, and excellent documentation. With composer, building Laravel apps is accessible even to junior developers. The communitymomentum behind Laravel looks unstoppable.

Content Navigation show

Yet as applications grow from side projects to business critical software, one complaint remains all too common:

Laravel feels slow.

We‘ve all been there. As traffic and data volumes mount, pages take seconds too long to load. APIs calls hang despite otherwise low utilization. You add more web servers yet performance barely budges. Or worse – servers crash under now-crippling load.

Meanwhile infrastructure bills soar from inefficient resource usage. For small teams on a bootstrap budget, this performance tax threatens sustainability.

The culprit lies not with Laravel itself per se. Rather, by staying out of the way, Laravel doesn‘t concern itself directly with raw speed. All those modern "magic" features come at a cost. Eloquent, caching, routing – they add powerful abstractions but also extra work under the hood.

Out of the box, Laravel opts for developer happiness over outright performance. But thankfully as creators and stewards of your apps, the optimization reins remain in your hands.

You CAN have your cake and eat it too! With some targeted tuning and operational smarts, Laravel applications can shine even under substantial loads. This post shares battle-tested tips to eke out as much performance as possible.

We‘ll cover:

  • What to monitor when diagnosing performance needs
  • Most impactful application-level optimizations
  • Caching approaches that supercharge responses
  • Tuning databases, queues, assets, and beyond
  • Balancing productivity vs raw optimization

You may not implement every tactic here. Rather use this guide as a toolbox of techniques to apply judiciously. By sticking to optimizations that offer the biggest performance gains for the effort, you can build screaming fast Laravel applications with happy users and developers alike!

Let‘s get started.

Why Does Performance Matter Anyway?

Before jumping right to tool-specific optimizations, it helps reflecting on why this performance stuff matters in the first place. If optimizations incur substantial extra complexity which users may not even notice, what‘s the impetus?

Performance today makes a bigger impact on customer and business value than ever before. Consider a few core reasons:

Direct Revenue Impact

Study after study confirms that performance directly impacts revenue and conversion rates. Even minor slowdowns sees user drop off spike. Imagine submitting a key form and…nothing.

  • +100ms -> 1% conversion rate drop (source)
  • +1 sec -> 7% conversion rate drop (source)

Over 10 seconds, more than half of users abandoning forms altogether. That‘s lost business attributed directly to site speed.

Optimizing for performance in effect optimizes for revenue.

Differentiating From Competition

Performance today sets elite services apart from upstarts. When Instagram launched, a key differentiator was its lightning fast photo uploads compared to the status quo at the time. Speed signaled quality.

Google search favors faster loading pages with better rankings. Users perceive speed as a mark of overall polish and reliability. As competition grows, performance separates leading services from the rest.

Operational Efficiency

Most directly, efficient apps use fewer infrastructure resources per visitor served. You can support 2-3x traffic on the same hardware via optimizations. That means controlling or even reducing exploding cloud bills.

In a nutshell, performance tuning is required to scale successfully while supporting modern user experience expectations.

Okay, hopefully you‘re convinced that performance merits some attention! Before jumping to specific optimizations, it‘s important clarifying what exactly to monitor and measure…

Finding Optimization Opportunities

Premature optimization is evil. Blindly guessing where your application bottlenecks lie wastes effort. Fortunately Laravel provides fantastic visibility into application performance through telemetry. Leverage these tools to inform your optimization roadmap:

Application Metrics

Laravel integrates with services like Datadog, NewRelic, and Sentry to track key application metrics:

  • Request response times: Average and percentile response times for pages and API requests. Spikes indicate struggling endpoints.
  • Error rates: Signals failing requests that exacerbate slowdowns.
  • Throughput: Requests per minute successfully served. Lower throughput indicates capacity limits.
  • Apdex score: Blends response times and error rates into a general satisfaction indicator.

These metrics establish speed and capacity baselines critical for quantifying optimization impact.

Infrastructure Monitoring

Next inspect the whole technology stack:

  • Application utilization: CPU, memory, disk, network usage on app servers.
  • Database load: Connections, throughput, query performance.
  • Cache utilization: Hit rate, evictions indicating high churn or insufficient cache space.
  • Queue depth: Job wait times and throughput.

Identifying infrastructure bottlenecks complements application monitoring. For example, slow code may simply stem from an overloaded database. Optimization without isolating root causes wastes effort.

Leveraging Logs

Logs provide additional context for honing in on struggled endpoints. Laravel logs capture:

  • Per request summaries with timings
  • Job details like queued tasks and mail sending
  • Errors and exceptions

Review logs to pinpoint optimization targets by specific routes and behavior.

Running Optimization Tools

Finally specialized tools analyze running applications to surface additional inefficiencies:

  • Blackfire Profiler: Function-level timings quantify expensive code paths.
  • Query analyzers: Identify slow DB queries needing indexing or reformulation.

They complement high level telemetry for deep inspection into exactly where time gets consumed.

With holistic application visibility, you can strategically target optimizations for problematic components. Avoid premature or speculative optimization and let instrumented data guide your priority order.

Okay, enough setup – let‘s move onto the good stuff!

Database and Query Optimization

For the majority of Laravel applications, the database persists as ground zero for optimization. Whether MySQL, Postgres, or MSSQL, databases bear the brunt of traffic while running notoriously inefficiently under load.

The main culprit lies with joining complex entity relationships. For example:

foreach (Customer::all() as $customer) {
  echo $customer->recentOrders; // additional query per customer!
}

This innocuous loop incurs an egregious N+1 query problem:

  1. Query for all customers
  2. N additional queries for orders per customer

Just 1000 customers would fire over 1000 total queries! This exponential inefficiency kills database performance.

The canonical fix uses eager loading to join relationships:

$customers = Customer::with(‘recentOrders‘)->get(); // single query

For large aggregation queries, raw SQL circumvents Eloquent overhead entirely. While sacrificing some ergonomics, directly running SQL selects reduces total database time often over 50%.

Further database best practices like adding indexes, optimizing tables, or simply throwing more hardware could each warrant dedicated posts. We‘ll revisit caching strategies shortly as well.

For now, remember this universal rule when diagnosing Laravel slowdowns:

Check the database & queries first!

Configuration Caching

Laravel bootstrap involves parsing various configuration files covering caching, logging, mailer connections, and many other facets.

On each request, Laravel must rebuild this configuration model to determine runtime behavior. Repeat config parsing ads needless overhead.

We can avoid constantly rebuilding configs by enabling caching:

php artisan config:cache

This dumps all config parsing to a single cached file renewed only on cache clearing. The optimization cuts app startup time easily 20-40% by skipping unnecessary work.

Just beware cached configs do complicate environment changes. Most applications freeze configs anyways in production, but know that .env() calls fallback to null.

For most applications, the simplicity of caching configs makes it a quick win for faster boot.

Limit Bootstrapped Services

Further trimming boot work comes from reducing loaded services in config/app.php.

Out of the box, Laravel registers many services even for unused app functionality:

‘providers‘ => [
  SessionServiceProvider::class,
  HashServiceProvider::class
];

For an API, neither sessions nor hashing get used at all! Removing unnecessary providers avoids initializing excess dependencies.

Target services which don‘t apply to your app such as:

  • View composers
  • Queue workers
  • Notifications
  • Hash/session services

While requiring some testing for unexpected breaks, dropping unused services accelerates boot by 10-15%.

The next technique takes the opposite approach of doing more work smartly…

Queue The Universe

For any external IO like network calls, file access, notifications; leverage queues to make them asynchronous. Why make a user wait on an email to send or image processing for their uploaded profile picture?

Queues return control immediately while pipelining non-critical IO in the background. For tasks requiring 100+ milliseconds anyway, queues dramatically improve user experience.

Here‘s an example migrating from synchronous emails to queues:

// Blocking at high volumes with I/O waits 
Mail::to($user->email)->send(new OrderConfirmation());

// Async queues return fast while mailing later  
Mail::to($user)->queue(new OrderConfirmation());

By minimizing synchronous IO work, queues slash page load times even under background congestion. Plus queues ease scaling by isolating workload surges across worker cluster nodes.

Just take care not to overqueue business critical logic better run synchronously. But used judiciously, queues supercharge responsiveness, especially as traffic scales up.

Fine-Tune Middleware Usage

When needing custom app logic like user authorization or logging, Laravel makes composing new middleware beautifully simple. The temptation rises to sprinkle middleware liberally across all routes.

But beware global middleware traps! Each added layer incrementally slows down every request from doing unnecessary work:

// runs everywhere regardless of need
$middlewareGroups[‘web‘][] = CheckPermissions::class;

Instead manually specify middleware only for the routes requiring it:

// only where genuinely needed
$router->put(‘/orders‘, [
  CheckPermissions::class, 
  UpdateOrder::class  
]);

Extra middleware easily adds 100+ millisecond drags needlessly. Confirm usage through profiling before applying app-wide. Middleware balances power with responsibility!

Embracing Redis Caching

We‘ve covered query and service optimizations targeting app initialization and database access. Now let‘s discuss supplements that accelerate everything through…

Caching ALL the things!

While complex topic, caching boils down to:

  • Store costly queries, model fetches, or page chunks into a speedy backend
  • Return cached data directly on repeat requests
  • Eventually expire and re-run source logic when stale

Well-cached applications eliminate redundant operations by reusing prior computing. Given most web traffic repeats common access patterns, judicious caching drastically speeds responsiveness.

The premier caching option remains Redis – an in-memory data store with exceptional performance at scale. Benchmarks reveal Redis sustaining:

  • 100k read ops/second
  • 10k write ops/second
  • Sub 1 ms access times
    (source)

These in-memory speeds support 1000x the throughput of typical databases or file caches. By storing data in raw memory without serialization, Redis unlocks wildly fast gets and sets.

Here‘s an example applying Redis caching for application data:

public function getUserOrders($user) 
{
  // cache for 10 minutes 
  return Cache::remember("user.{$user->id}.orders", 600, function() use ($user) {
    return DB::table(‘orders‘)->where(‘user_id‘, $user->id)->get();    
  });
}

Now repeated calls avoid redundant queries by using cached data instead. The impact averages around 200-1000x faster dependent on complexity of generating the original data.

That‘s just one glimpse into power yielded through comprehensive caching. We could dive deeper on cache invalidation strategies, CDN integration, and more – but that alone warrants a dedicated treatment!

Squeezing Out Every Millisecond

Let‘s briefly cover some final techniques that eke out a few extra milliseconds:

  • Image optimization remains table stakes for snappy sites. Client-side compression, responsive sizing, content delivery networks all play a big role.
  • Frontend performance matters hugely, with tailored optimizations around JS/CSS bundling, transpilation, minification and more.
  • Third party dependencies like SDKs often bloat apps. Audit via Blackfire profiler and remove unnecessary plugins.
  • CDNs offload assets serving bandwidth while providing geographic performance gains.
  • HTTP caching via headers boosts repeat visit speed through reverse proxy caches.

No single big win here, but many smaller efficiencies to pick off. Avoid premature micro-optimization without evidence. But the collective impact from frontend, network and edge tuning tie together a comprehensive performance strategy.

It‘s All About Tradeoffs

By now we‘ve covered several major (and minor) optimization areas to review for faster Laravel applications:

  • Database query optimizations
  • Caching queries, routes configs
  • Migrating IO heavy operations to queues
  • Frontend asset builds and minification
  • Redis and HTTP caching
  • Image optimization
  • Stripping down frameworks bloat

This abundance of choice leads to the natural question – well, what should we actually optimize then?!

Like most aspects of software engineering, application optimization involves judiciously balancing tradeoffs:

Productivity vs Performance – At some point, excessive complexity hampers feature velocity more than the performance gains warrant. Profile judiciously but resist over-optimization absent clear data it resolves production issues. Know when "good enough" works over perfection.

Caching vs Correctness – Comprehensive caching risks serving stale, outdated application data in exchange for speed. Think carefully through cache invalidation lifecycles before aggressively caching models.

Cost vs Complexity – Migrating databases or adding extensive Redis clusters introduces new operational overhead. Model this TCO against expected performance gains and business impact.

These tensions will differ radically across applications and teams. Avoid one-size-fits all mandates. Gather evidence to inform where optimizations make sense for your specific ecosystem.

Optimizing web application performance remains equal parts science and art. Take ideas from this guide as inspiration to investigate within your own apps, not direct mandates.

The only universal rule? Application performance today sets apart good apps from great ones. Users, stakeholders, and developers all win with speed.

Conclusion & Next Steps

We covered a ton of ground exploring various optimizations that combined dramatically accelerate Laravel application speed and capacity.

Here‘s a quick recap of impactful performance tuning approaches:

  • Database query optimizations for fixing slow SQL queries
  • Caching configurations, routes, data, and responses
  • Queues to isolate slow background work
  • Asset packaging with Webpack, Rollup, or Laravel Mix
  • Redis caching for lightning fast hits
  • Image optimizations for faster page loads
  • Autoloader optimizations for snappier bootup

Put together, these strategies enable Laravel applications to shine even under substantial loads. You need not sacrifice the excellent development velocity or structure Laravel offers in the name of performance.

Now that you‘re armed with a toolbox of techniques, what next steps can put these into practice?

  • Profile your application through logs, APMs, and profilers to quantify bottlenecks
  • Implement monitoring so future optimizations tie directly to tangible gains
  • Prioritize optimizations by potential speedup versus complexity
  • Review periodically for new optimization opportunities

With an incremental, data-informed approach Laravel performance issues give way to fast, scalable application infrastructure. Don‘t prematurely optimize everything today – rather use this guide as inspiration where bottlenecks arise in your unique ecosystem.

If you found this post helpful, share it with other Laravel developers seeking snappier apps. Together we can transform Laravel‘s developer experience into exceptional end user performance too!

Tags: