🚀 WordPress Performance Optimization Guide

Section 1Understanding WordPress Caching

The Problem with Dynamic Content Generation

When a client requests a page from your WordPress site, the following process occurs:

The Caching Solution

Since most WordPress content changes infrequently, there's no need to rebuild pages on every request. Caching stores pre-built HTML pages either in RAM or on disk, dramatically reducing server load and improving response times.

Types of Caching

Cache Type	Description	Storage Location	Performance Impact
Page Cache	Stores complete HTML pages	Disk or RAM	⭐⭐⭐⭐⭐ Highest
Object Cache	Stores database query results	RAM (Redis/Memcached)	⭐⭐⭐⭐ Very High
OpCache	Caches compiled PHP bytecode	RAM	⭐⭐⭐⭐ Very High
Browser Cache	Stores static assets on client	Client Browser	⭐⭐⭐ Moderate

Section 2WordPress Post Revisions

WordPress automatically saves revisions of your posts and pages. While useful for recovering previous versions, unlimited revisions can bloat your database significantly, affecting performance.

Disable Post Revisions

Navigate to your WordPress installation directory and edit the configuration file:

Add the following line to disable revisions completely:

define('WP_POST_REVISIONS', false);

Restart PHP-FPM to apply the changes:

Section 3Maximum Memory Limit Configuration

Properly configuring memory limits prevents PHP scripts from consuming excessive resources while ensuring enough memory for complex operations.

PHP-FPM Pool Configuration

Configure memory limits at the pool level for granular control:

Update or add the memory limit directive:

; Comment out restrictive limits
;php_admin_value[memory_limit] = 32M

; Set appropriate memory limit
php_admin_value[memory_limit] = 256M

WordPress Configuration

Set the WordPress memory limit in wp-config.php:

Add the following configuration:

/** MEMORY LIMIT */
define('WP_MEMORY_LIMIT', '256M');

Section 4WP-Cron Optimization

By default, WordPress cron runs on every page load, which is inefficient. Converting to system cron improves performance and reliability.

Disable WordPress Built-in Cron

Edit wp-config.php to disable the default WP-Cron:

define('DISABLE_WP_CRON', true);

Restart PHP-FPM:

Configure System Cron

Set up a system cron job to trigger WordPress cron every 15 minutes:

Add the following cron job:

*/15 * * * * wget -q -O - https://example.com/wp-cron.php?doing_wp_cron >/dev/null 2>&1

Section 5PHP OpCache Configuration

OpCache stores precompiled PHP bytecode in memory, eliminating the need to parse and compile PHP files on every request. This dramatically improves PHP execution speed.

OpCache Configuration File

Navigate to your PHP-FPM pool configuration:

Development Server Configuration

For development environments, enable timestamp validation for immediate code changes:

; OPCACHE CONFIGURATION - DEVELOPMENT SERVER - Jul 2025
; OpCache is enabled by default, no need to set explicitly
; php_admin_flag[opcache.enabled] = 1
php_admin_value[opcache.memory_consumption] = 256
php_admin_value[opcache.interned_strings_buffer] = 32
php_admin_value[opcache.max_accelerated_files] = 20000
php_admin_flag[opcache.validate_timestamps] = 1
php_admin_value[opcache.revalidate_freq] = 2
php_admin_flag[opcache.validate_permission] = 1

Production Server Configuration

For production, disable timestamp validation for maximum performance:

; OPCACHE CONFIGURATION - PRODUCTION SERVER - Jul 2025
; OpCache is enabled by default
;php_admin_flag[opcache.enabled] = 1
;php_admin_value[opcache.memory_consumption] = 256
;php_admin_value[opcache.interned_strings_buffer] = 32
;php_admin_value[opcache.max_accelerated_files] = 20000
;php_admin_value[opcache.validate_timestamps] = 0
;php_admin_flag[opcache.validate_permission] = 1

Apply OpCache Configuration

Calculate Required max_accelerated_files

Count all PHP files in your WordPress installation:

OpCache Directive	Description	Recommended Value
memory_consumption	Total memory allocated for OpCache	128-256 MB
interned_strings_buffer	Memory for storing interned strings	16-32 MB
max_accelerated_files	Maximum cached PHP files	10000-20000
validate_timestamps	Check for file changes (dev: 1, prod: 0)	Dev: 1, Prod: 0
revalidate_freq	Seconds between timestamp checks	2-60 seconds

Reference: PHP OpCache Documentation

Section 6FastCGI Caching

FastCGI caching is NGINX's built-in page caching mechanism. It stores PHP-generated HTML pages and serves them directly from NGINX without invoking PHP or querying the database.

Configure NGINX FastCGI Cache

Edit the main NGINX configuration file:

HTTP Context Configuration

Scroll to just above the comment # Virtual Host Configs and add:

### FASTCGI CACHING
# fastcgi_cache_path directive - PATH & NAME must be unique for each site
# Add a new fastcgi_cache_path for each site and give a new keys_zone name
fastcgi_cache_path /var/run/SITE levels=1:2 keys_zone=NAME:100m inactive=60m;

# Applied to all sites
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header http_500;
fastcgi_ignore_headers Cache-Control Expires Set-Cookie;

Create Cache Exclusion Rules

Create a file to define which pages should bypass the cache:

# NGINX SKIP CACHE INCLUDE FILE
set $skip_cache 0;

# POST requests and URLs with query strings should always go to PHP
if ($request_method = POST) {
    set $skip_cache 1;
}

if ($query_string != "") {
    set $skip_cache 1;
}

# Don't cache URIs containing the following segments
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/feed/|index.php|sitemap(_index)?.xml") {
    set $skip_cache 1;
}

# Don't use cache for logged-in users or recent commenters
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

Configure Site-Specific Server Block

Add these directives to your server block:

include /etc/nginx/includes/fastcgi_cache_excludes.conf;
add_header X-FastCGI-Cache $upstream_cache_status;

# Inside the PHP location block (location ~ \.php$)
fastcgi_cache_bypass $skip_cache;
fastcgi_no_cache $skip_cache;
fastcgi_cache NAME;
fastcgi_cache_valid 60m;

Test and Apply Configuration

Verify FastCGI Cache Headers

Check if caching is working correctly:

Look for the X-FastCGI-Cache header in the response:

• HIT: Page served from cache
• MISS: Page generated and added to cache
• BYPASS: Page not cached (matches exclusion rule)

Manual Cache Purging

Configure a cache purge endpoint (optional but recommended):

location ~ /purge(/.*) {
    fastcgi_cache_purge NAME "$scheme$request_method$host$1";
}

To purge a specific page cache, visit:

Remove FastCGI Caching

If you need to disable FastCGI caching:

Comment out or remove these directives:

# include /etc/nginx/includes/fastcgi_cache_excludes.conf;
# add_header X-FastCGI-Cache $upstream_cache_status;

# In PHP location block:
# fastcgi_cache_bypass $skip_cache;
# fastcgi_no_cache $skip_cache;
# fastcgi_cache NAME;
# fastcgi_cache_valid 60m;

# Remove purge location:
# location ~ /purge(/.*) {
#     fastcgi_cache_purge NAME "$scheme$request_method$host$1";
# }

Section 7WP Super Cache Integration

WP Super Cache is a WordPress plugin that generates static HTML files. NGINX can serve these cached files directly without processing PHP.

Create WP Super Cache Exclusion Rules

# WP Super Cache NGINX Cache Exclusion Rules
set $cache_uri $request_uri;

# POST requests and URLs with query strings should always go to PHP
if ($request_method = POST) {
    set $cache_uri 'null cache';
}

if ($query_string != "") {
    set $cache_uri 'null cache';
}

# Don't cache URIs containing the following segments
if ($request_uri ~* "(/wp-admin/|/xmlrpc.php|/wp-(app|cron|login|register|mail).php|wp-.*.php|/feed/|index.php|wp-comments-popup.php|wp-links-opml.php|wp-locations.php|sitemap(_index)?.xml|[a-z0-9_-]+-sitemap([0-9]+)?.xml)") {
    set $cache_uri 'null cache';
}

# Don't use cache for logged-in users or recent commenters
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_logged_in") {
    set $cache_uri 'null cache';
}

# Use cached or actual file if they exist, otherwise pass to WordPress
location / {
    try_files /wp-content/cache/supercache/$http_host/$cache_uri/index-https.html $uri $uri/ /index.php?$args;
}

Configure Site Server Block

Add the include directive:

include /etc/nginx/includes/wp_super_cache_excludes.conf;

Uninstalling WP Super Cache

To remove WP Super Cache integration:

Remove the include directive:

# include /etc/nginx/includes/wp_super_cache_excludes.conf;

Uncomment the standard location block:

location / {
    try_files $uri $uri/ /index.php$is_args$args;
}

Section 8W3 Total Cache Configuration

W3 Total Cache is a comprehensive caching plugin for WordPress. Unlike WP Super Cache, it requires NGINX to include a dynamically generated configuration file.

Create NGINX Configuration File

W3TC generates its own NGINX rules. Create a file for the plugin to write to:

Secure the Configuration File

Prevent web access to the nginx.conf file:

Add this directive:

location = /nginx.conf { deny all; }

Create W3TC Cache Exclusion Rules

# ---------------------
# W3 TOTAL CACHE EXCLUDES FILE
# ---------------------
set $cache_uri $request_uri;

# POST requests and URLs with query strings should always go to PHP
if ($request_method = POST) {
    set $cache_uri 'null cache';
}

if ($query_string != "") {
    set $cache_uri 'null cache';
}

# Don't cache URIs containing the following segments
if ($request_uri ~* "(/wp-admin/|/xmlrpc.php|/wp-(app|cron|login|register|mail).php|wp-.*.php|/feed/|index.php|wp-comments-popup.php|wp-links-opml.php|wp-locations.php|sitemap(_index)?.xml|[a-z0-9_-]+-sitemap([0-9]+)?.xml)") {
    set $cache_uri 'null cache';
}

# Don't use cache for logged-in users or recent commenters
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_logged_in") {
    set $cache_uri 'null cache';
}

# Use cached file if it exists, otherwise pass to WordPress
location / {
    try_files /wp-content/w3tc/pgcache/$cache_uri/_index.html $uri $uri/ /index.php?$args;
}

Configure Site Server Block

Comment out the default location block and add W3TC includes:

# Comment out default location
#location / {
#    try_files $uri $uri/ /index.php$is_args$args;
#}

# Add W3TC includes
include /etc/nginx/includes/w3tc_cache_excludes.conf;
include /var/www/example.com/public_html/nginx.conf;

Install Required PHP Extensions

W3TC requires the PHP Tidy extension for HTML minification:

Uninstalling W3 Total Cache

To completely remove W3TC:

Restore the default location block and remove includes:

location / {
    try_files $uri $uri/ /index.php$is_args$args;
}

# Remove these lines:
# include /etc/nginx/includes/w3tc_cache_excludes.conf;
# include /var/www/example.com/public_html/nginx.conf;

Remove W3TC cache directories:

Remove the NGINX configuration file:

Section 9Redis Object Caching

Redis is an in-memory data structure store used as an object cache for WordPress. It dramatically reduces database queries by caching query results in RAM.

Install Redis Server and PHP Extension

Verify Redis Status

Check Redis Logs

Configure Memory Overcommit

Create a sysctl configuration file to fix the overcommit warning:

vm.overcommit_memory = 1

Reboot to apply the change:

Verify Fix

Configure Redis Memory and Eviction Policy

Set maximum memory and eviction policy for Redis:

Add or modify these directives:

maxmemory 256mb
maxmemory-policy allkeys-lru

Restart Redis and reboot:

Configure WordPress for Redis

Add Redis configuration to wp-config.php:

/** REDIS OBJECT CACHE CONFIGURATION */
define('WP_CACHE_KEY_SALT', 'example.com');

WooCommerce-Specific Configuration

WooCommerce session data should not be cached in Redis. Configure exclusions:

/** PREVENT REDIS CACHING WOO SESSION DATA */
define('WP_REDIS_IGNORED_GROUPS', 'wc_session');

Reference: WooCommerce Caching Configuration

Section 10PHP-FPM Optimization

PHP-FPM (FastCGI Process Manager) manages PHP processes. Proper configuration is crucial for performance and resource utilization.

Display All PHP-FPM Pool Users

Calculate Average Memory per Process

Replace POOL_USER with your actual pool username:

OnDemand Configuration

OnDemand is recommended for sites with sporadic traffic:

pm = ondemand
pm.max_children = 50
pm.process_idle_timeout = 10s
pm.max_requests = 500

Directive	Description	Calculation/Value
pm.max_children	Maximum PHP processes	(Total RAM × 0.8) ÷ Avg Process Memory
pm.process_idle_timeout	Kill idle processes after X seconds	10s (recommended for ondemand)
pm.max_requests	Requests before process restart	500-1000 (prevents memory leaks)

Apply the configuration:

Monitor for max_children Warnings

Check PHP-FPM logs for capacity warnings:

Section 11Cloudflare Integration

When using Cloudflare as a CDN/proxy, NGINX logs show Cloudflare's IP addresses instead of actual visitor IPs. Configuring NGINX to read the real IP from Cloudflare headers fixes this.

Get Latest Cloudflare IP Ranges

Cloudflare publishes their IP ranges at:

• IPv4 Addresses
• IPv6 Addresses

Create Cloudflare IP Configuration

# Last updated OCT 2022 - Check for updates periodically
set_real_ip_from 173.245.48.0/20;
set_real_ip_from 103.21.244.0/22;
set_real_ip_from 103.22.200.0/22;
set_real_ip_from 103.31.4.0/22;
set_real_ip_from 141.101.64.0/18;
set_real_ip_from 108.162.192.0/18;
set_real_ip_from 190.93.240.0/20;
set_real_ip_from 188.114.96.0/20;
set_real_ip_from 197.234.240.0/22;
set_real_ip_from 198.41.128.0/17;
set_real_ip_from 162.158.0.0/15;
set_real_ip_from 104.16.0.0/13;
set_real_ip_from 104.24.0.0/14;
set_real_ip_from 172.64.0.0/13;
set_real_ip_from 131.0.72.0/22;
set_real_ip_from 2400:cb00::/32;
set_real_ip_from 2606:4700::/32;
set_real_ip_from 2803:f800::/32;
set_real_ip_from 2405:b500::/32;
set_real_ip_from 2405:8100::/32;
set_real_ip_from 2a06:98c0::/29;
set_real_ip_from 2c0f:f248::/32;
real_ip_header CF-Connecting-IP;

Include in Site Configuration

Add this directive to your server block:

include /etc/nginx/includes/cloudflare_ip_list.conf;

Performance Testing & Monitoring

Test Your Configuration

After implementing these optimizations, test your site's performance:

Key Performance Metrics

Metric	Description	Target
TTFB	Time to First Byte	< 200ms
FCP	First Contentful Paint	< 1.8s
LCP	Largest Contentful Paint	< 2.5s
CLS	Cumulative Layout Shift	< 0.1
TBT	Total Blocking Time	< 200ms

Monitoring Commands

Check NGINX Status

Check PHP-FPM Status

Check Redis Status

Monitor Redis Memory Usage

View Real-Time NGINX Logs

View PHP-FPM Error Logs

Check Disk Space

Check Memory Usage

Check CPU Load

Best Practices & Recommendations

Troubleshooting Guide

Common Issues & Solutions

Problem: 502 Bad Gateway Error

Possible Causes:

• PHP-FPM not running
• PHP-FPM socket permissions incorrect
• Insufficient PHP processes (max_children too low)

Solutions:

Problem: Cache Not Working

Verification:

Check for:

• X-FastCGI-Cache: HIT (should appear on second request)
• Verify cache directory exists and has correct permissions
• Check NGINX error log for cache-related errors

Problem: Redis Connection Failed

Verification:

Should return: PONG

Problem: High Memory Usage

Investigation:

Solutions:

• Reduce pm.max_children in PHP-FPM
• Lower OpCache memory allocation
• Reduce Redis maxmemory
• Consider upgrading server RAM

Problem: Slow Page Load After Cache Implementation

First Request (Cache MISS): May be slower as cache is being built

Subsequent Requests (Cache HIT): Should be significantly faster

If still slow:

• Check database optimization
• Analyze slow queries: Enable MySQL slow query log
• Review image optimization
• Check external API calls

Additional Resources

Conclusion

WordPress performance optimization is a multi-layered approach that requires careful configuration of various components. By implementing the strategies outlined in this guide—including page caching, object caching, OpCache, and proper server configuration—you can achieve significant performance improvements.

Remember that performance optimization is an ongoing process. Regularly monitor your site's performance, update configurations as needed, and stay informed about new optimization techniques and best practices.