1. Home
  2. Knowledge base
  3. Tutorials

Diagnosing and Mitigating PHP Worker Saturation

Last modified: October 9, 2025

This article explains how to identify and resolve PHP worker saturation issues on Pressable sites. Worker saturation occurs when too many uncached requests hit the PHP layer at once, causing slow load times or timeout errors. This guide walks through detection, diagnosis, and mitigation strategies that work within Pressable’s fixed environment (no PHP or NGINX configuration changes required).

Who This Guide Is For: Site owners, developers, and advanced users troubleshooting intermittent slowdowns or 502/504 errors.

You can also find more general information about PHP workers and concurrency here: PHP Workers, Concurrency, and What They Mean For Your Site.

What PHP Workers Do

Each uncached request consumes one PHP worker until the request completes. Pressable sites on Signature plans include 5 PHP workers by default (older plans may have 10). Each worker has 512 MB of memory and runs on a dedicated CPU core. Sites can burst beyond that baseline temporarily depending on available server pool capacity.

Cached requests do not use PHP workers. This means that efficient caching is usually the single most important factor for maintaining speed and stability during high traffic.

Recognizing Worker Saturation Symptoms

Worker saturation often presents as intermittent or escalating performance degradation rather than total downtime. Common symptoms include:

  • Pages intermittently load slowly or time out (502/504 errors).
  • The WordPress dashboard becomes sluggish or inaccessible.
  • TTFB (Time To First Byte) spikes during peak traffic.
  • Logs show connection timeouts or incomplete requests.
  • Monitoring tools indicate queueing or delayed responses.

If these symptoms occur during predictable spikes (e.g., sales, newsletter events, or marketing campaigns), PHP worker saturation is a likely cause.

How To Confirm Worker Saturation

Several diagnostic approaches can confirm whether worker limits are being reached:

  1. Check Pressable Metrics and Logs to identify queued or long-running PHP processes.
  2. Compare Cached vs Uncached Traffic Ratios. If most requests are uncached, caching improvements may be needed.
  3. Use WP-CLI Tests (where permitted) to benchmark specific endpoints or run lightweight concurrency checks.
  4. Review Slow Query Logs for recurring outliers using a plugin like Debug Bar or Query Monitor.
  5. Use APM Insights to visualize performance bottlenecks.

Common Causes Of Worker Saturation

Worker limits are typically reached due to one or more of these conditions:

  • Heavy uncached traffic (WooCommerce carts, logins, or dynamic user content).
  • Plugins making remote API calls during page load.
  • Database queries that fetch or join large datasets.
  • Cron jobs or scheduled tasks triggering during traffic spikes.
  • Large import/export or backup jobs running simultaneously.

Diagnostic Process

Use a structured approach to locate and confirm the cause of saturation:

  1. Measure: Note when issues occur (time, traffic source, campaign event).
  2. Identify: Use logs and APM traces to find which requests consistently occupy workers.
  3. Validate: Temporarily disable or bypass plugins to observe concurrency changes.
  4. Correlate: Match request spikes to user behavior or automated processes.
  5. Confirm: Retest under similar conditions after implementing optimizations.

Mitigation Strategies

Pressable’s server environment is locked-down for stability and security, so mitigation focuses on WordPress-level optimization.

Improve Caching Efficiency

  • Verify that pages are being cached and not excluded by unnecessary cookies or query strings.
  • Avoid using plugins that bypass cache or rely on PHP sessions (session_start()).
  • Consider using static caching or pre-warming critical pages before major traffic events.

Optimize Plugin and Theme Behavior

  • Disable features that make live external API calls on every page load.
  • Replace heavy plugins with lighter alternatives or custom code where practical.
  • Audit plugin load order and autoloaded data to reduce memory needs and execution time.

Control Expensive Operations

  • Batch or queue import/export, syncing, or email operations.
  • Use pagination for large admin views instead of fetching thousands of records at once.
  • Schedule heavy cron tasks for off-peak hours.

Optimize Database Queries

  • Add indexes to large tables when possible.
  • Limit SELECT * queries and use explicit fields instead.
  • Review slow query logs for unoptimized joins or subqueries.

Manage External Dependencies

  • Implement transient-based caching for API responses.
  • Use asynchronous webhooks where feasible instead of synchronous blocking calls.

Proactive Prevention

Prevent worker saturation before it impacts users:

  • Run controlled load tests before campaigns or new feature rollouts.
  • Set up uptime and response-time monitoring.
  • Schedule background jobs during low-traffic periods.
  • Review plugins and themes regularly for performance regressions.
  • Warm caches before expected surges (sales, content drops, email campaigns).

When To Escalate

If performance does not improve after optimizing caching and code:

  • Worker limits may consistently exceed burst capacity.
  • Custom code may require refactoring for better concurrency handling.
  • Database inefficiencies may need professional query optimization.

In these cases, additional review or architectural changes may be needed at the application level.

Key Takeaways

PHP worker saturation is one of the most common causes of WordPress slowdowns. With smart caching, efficient code, and informed scheduling, you can avoid these limits entirely. Pressable’s APM Insights and built-in caching layers give you the visibility and tools needed to keep your site responsive, even during peak demand.