PHP Performance Optimization: AI-Optimized Technical Reference

Critical Configuration Requirements

OPcache (Essential - Deploy First)

Impact: 3-5x performance improvement with zero code changes
Configuration that works in production:

opcache.enable=1
opcache.memory_consumption=128
opcache.max_accelerated_files=10000
opcache.revalidate_freq=2

Failure Mode: Without OPcache, PHP parses files on every request like 2005
Verification: Check phpinfo() for cache hit ratios or use opcache_get_status()

PHP-FPM Worker Sizing

Formula: Total available RAM ÷ Average PHP process size
Critical Calculation: If each process uses 50MB and you have 2GB for PHP, set pm.max_children = 40
Failure Consequences: Too few workers = request queuing; Too many = memory exhaustion
Monitoring: Use pm.status_path to detect limits being hit

Performance Bottlenecks by Severity

Critical (Application-Breaking)

1. Missing OPcache - 3-5x performance loss
2. N+1 Database Queries - 100+ database calls instead of 1
   • Common pattern: Load 100 users, then 100 separate profile queries
   • Fix: Use eager loading or proper JOINs
3. File-based sessions at scale - I/O bottlenecks under load
4. Xdebug enabled in production - Kills performance completely

High Impact (User-Noticeable)

1. Unindexed database queries - 500ms+ per query
2. WordPress plugins doing 47 SELECT statements per page
3. PHP serving static files instead of nginx - 10x slower than web server
4. Missing autoloader optimization - File system lookups on every class instantiation

Medium Impact (Scalability Issues)

1. Default session storage in /tmp - Disk I/O under load
2. No database connection pooling - 1000 connections instead of 25
3. Missing HTTP caching layers - Repeated processing of identical requests

Resource Requirements and Scaling Thresholds

Memory Management

• Shared-nothing advantage: Memory leaks die with each request
• Worker calculation: Monitor actual process sizes with ps aux | grep php-fpm
• Breaking point: Running out of available workers causes request queuing

Database Scaling Progression

1. Single database - Works up to moderate traffic
2. Master-slave replication - Handles most scaling needs (90% of applications)
3. Multiple read replicas - Geographic distribution required
4. Database sharding - Complex, rarely needed for PHP apps

Traffic Handling Capacity

• PHP 8.4 performance: Competitive with Node.js, faster than Python
• Horizontal scaling: Add servers linearly due to stateless architecture
• Auto-scaling: AWS can scale 2-10 instances based on CPU/memory metrics

Critical Warnings and Failure Modes

Production vs Development Gotchas

• Database location: Local DB vs remote with network latency
• Missing OPcache: XAMPP doesn't enable by default
• PHP version differences: Local 8.4 vs production 7.4
• Resource limits: Production has memory/CPU constraints

WordPress-Specific Failures

• Plugin audit essential: Use Query Monitor to identify bottlenecks
• Object caching required: Default per-request memory rebuilds everything
• Image optimization critical: 2MB JavaScript for blog posts

Session Management at Scale

• File sessions don't work: Each server has separate /tmp directory
• Users get logged out: Load balancer switches between servers
• Solution: Redis cluster or JWT tokens for stateless sessions

Tool Comparison and Decision Matrix

Monitoring Tools by Use Case

Tool	Cost	Best For	Critical Limitation
New Relic	$99-499/month	Production APM	Expensive for small sites
Blackfire	$30-200/month	Performance debugging	Complex for beginners
Xdebug	Free	Development profiling	Too slow for production
Query Monitor	Free	WordPress debugging	WordPress-only

Caching Solutions by Scenario

Solution	Performance	Complexity	When to Use
Redis	Fastest	Medium	Session storage, object caching
Memcached	Fast	Low	Simple key-value caching
Varnish	Extreme	High	High-traffic websites
Browser Cache	N/A	Low	Static assets (1 year expiry)

Implementation Priority Matrix

Immediate Wins (Deploy Today)

1. Enable OPcache - 3-5x improvement, zero code changes
2. Optimize Composer autoloader - composer install --optimize-autoloader --no-dev
3. Move static files to CDN/nginx - 60-80% server load reduction
4. Enable Redis sessions - Eliminates file I/O bottlenecks

Medium-Term Optimizations (1-2 weeks)

1. Database query optimization - Fix N+1 problems, add indexes
2. HTTP caching implementation - Varnish or nginx caching
3. PHP-FPM tuning - Right-size worker counts
4. WordPress plugin audit - Disable unnecessary plugins

Long-Term Scaling (1-3 months)

1. Database replication setup - Read replicas for scaling
2. Container orchestration - Kubernetes auto-scaling
3. Advanced monitoring - New Relic/Datadog implementation
4. Load testing and optimization - Continuous performance validation

Breaking Points and Thresholds

Memory Limits

• PHP process size: Typically 50-100MB per worker
• Server capacity: 2GB RAM = ~40 workers maximum
• Scaling trigger: >80% worker utilization

Database Performance

• Query threshold: >100ms indicates optimization needed
• Connection limits: 25 pooled connections handle 1000 requests
• Replication needed: When single database CPU >70%

Traffic Scaling

• Single server limit: ~1000 concurrent requests with proper tuning
• Horizontal scaling trigger: Response times >500ms
• CDN requirement: >60% static file requests

Deployment Configuration Templates

Production nginx Configuration

location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
}

Auto-scaling Configuration

{
  "MinSize": 2,
  "MaxSize": 10,
  "DesiredCapacity": 3,
  "HealthCheckType": "ELB",
  "HealthCheckGracePeriod": 300
}

Database Connection Pooling

[pgbouncer]
pool_mode = transaction
max_client_conn = 1000
default_pool_size = 25

Common Misconceptions and Reality Checks

Performance Myths

• "PHP is slow" - Reality: PHP 8.4 is competitive with Node.js
• "Need to rewrite in Node.js" - Reality: Fix database queries and enable OPcache first
• "WordPress can't scale" - Reality: WordPress.com serves 25 billion page views/month

Scaling Realities

• Facebook used PHP for years before custom tooling
• Limiting factors are rarely PHP itself: Database, caching, infrastructure
• Horizontal scaling advantage: Stateless architecture scales linearly

Emergency Troubleshooting Guide

High CPU, Slow Response

Check: Unindexed queries, image processing, XML/JSON parsing, Xdebug in production
Tool: New Relic or Blackfire for function-level analysis

WordPress 8-Second Load Times

Always: Install Query Monitor first
Look for: 30+ queries per page, unoptimized images, missing caching, 15 font requests
Solution: Disable plugins, enable caching, optimize images

Memory Issues

Monitor: ps aux | grep php-fpm for actual process sizes
Calculate: Available RAM ÷ Process size = Max workers
Adjust: PHP-FPM configuration based on real usage, not estimates