Performance Optimization

Introduction

A PHP application that is correct and secure still needs to be fast enough for real users. As traffic grows, small inefficiencies — an uncached expensive calculation, a query running in a loop, a missing index — can turn a snappy page into a slow one.

This lesson covers the most impactful, practical performance techniques for PHP applications: caching compiled code with OPcache, reducing database load, caching results, choosing efficient built-in functions, and — just as importantly — measuring before you optimize.

Enabling OPcache

Normally, PHP re-parses and compiles a script into bytecode on every single request, then throws that compiled version away once the request finishes. OPcache is a built-in extension that stores compiled bytecode in memory, so subsequent requests can skip the parsing and compiling step entirely.

; Enable OPcache and reserve memory for cached bytecode
opcache.enable=1
opcache.memory_consumption=128
opcache.max_accelerated_files=10000
opcache.validate_timestamps=1
opcache.revalidate_freq=2

Minimizing Database Queries

Database access is typically the slowest part of a web request, far slower than PHP code execution itself. A common and costly mistake is the N+1 query problem: running one query to get a list, then one additional query per item in that list.

$posts = $pdo->query("SELECT id, title, author_id FROM posts")->fetchAll();

foreach ($posts as $post) {
    // One extra query per post — very slow with many posts
    $stmt = $pdo->prepare("SELECT name FROM users WHERE id = ?");
    $stmt->execute([$post['author_id']]);
    $author = $stmt->fetchColumn();
    echo $post['title'] . ' by ' . $author . "\n";
}

$posts = $pdo->query(
    "SELECT posts.title, users.name AS author
     FROM posts
     JOIN users ON users.id = posts.author_id"
)->fetchAll();

foreach ($posts as $post) {
    echo $post['title'] . ' by ' . $post['author'] . "\n";
}

How to Learn PHP by Priya Sharma
Understanding MVC by Diego Torres

The joined version runs one query no matter how many posts exist, instead of one query per post. Alongside writing efficient queries, adding a database index on frequently searched or joined columns (like author_id) dramatically speeds up lookups on large tables.

Caching Expensive Results

If a calculation, database query, or external API call is expensive and its result does not change on every single request, computing it once and reusing that result can save significant time.

function getExpensiveReport(): array
{
    $cacheFile = __DIR__ . '/cache/report.json';

    if (file_exists($cacheFile) && (time() - filemtime($cacheFile) < 3600)) {
        return json_decode(file_get_contents($cacheFile), true);
    }

    // Imagine this involves several slow queries or heavy computation
    $report = ['total_sales' => 48250, 'top_product' => 'Wireless Mouse'];

    file_put_contents($cacheFile, json_encode($report));

    return $report;
}

print_r(getExpensiveReport());

Array
(
    [total_sales] => 48250
    [top_product] => Wireless Mouse
)

This example writes a cache to a file for simplicity. Real applications often use a dedicated cache store like Redis or Memcached, but the underlying idea — do the expensive work once, then reuse it — stays the same.

Choosing Efficient Functions

PHP's built-in array and string functions are implemented in optimized C code, and are almost always faster than an equivalent hand-written loop in PHP.

$numbers = range(1, 5);

// Prefer built-in functions over manual loops where possible
$doubled = array_map(fn($n) => $n * 2, $numbers);
$evens = array_filter($numbers, fn($n) => $n % 2 === 0);
$sum = array_sum($numbers);

print_r($doubled);
print_r($evens);
echo "Sum: $sum\n";

Array
(
    [0] => 2
    [1] => 4
    [2] => 6
    [3] => 8
    [4] => 10
)
Array
(
    [1] => 2
    [3] => 4
)
Sum: 15

Beyond speed, using array_map(), array_filter(), and similar functions also makes intent clearer than an equivalent manual foreach loop.

Profile Before You Optimize

It is tempting to guess where an application is slow, but guesses are frequently wrong. Profiling tools measure exactly where time is actually being spent, so you optimize the part that matters instead of the part that merely looks suspicious.

Free Performance from Upgrading PHP

Each major PHP version has historically brought substantial performance improvements over the last, often with zero code changes required. Moving from an old, unsupported PHP version to a current one can be one of the easiest performance wins available — alongside the security benefits covered in the previous lesson.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Performance optimization in PHP is mostly about a handful of high-impact habits: caching compiled code with OPcache, minimizing and indexing database queries, caching expensive results, using efficient built-in functions, and measuring with a profiler before making changes. Combined with staying on a current PHP version, these techniques cover the vast majority of real-world performance problems.

In this lesson, you learned the core techniques for keeping a PHP application fast as it grows. Next, in the final lesson of this course, you will bring everything together into a set of overall PHP best practices.