A successful connection or installation message can be misleading when the actual operation still fails. In PHP-FPM, the specific symptom is this: A busy WordPress site sporadically returns 502 while lightweight static assets keep loading. The practical objective is to restore the affected feature, determine the actual failing layer, and confirm the result without sacrificing data or account protection.
Identify the symptom
A busy WordPress site sporadically returns 502 while lightweight static assets keep loading. The key distinction is whether the failure happens before the service, game, application or device becomes available, or only when the user performs the specific action. Check PHP-FPM logs for server reached pm.max_children at the exact outage minute.
- Exact observation: A busy WordPress site sporadically returns 502 while lightweight static assets keep loading.
- First useful comparison: Check PHP-FPM logs for server reached pm.max_children at the exact outage minute.
- Expected healthy state: A representative traffic test runs without worker-exhaustion warnings and memory remains stable.
Keep a short timeline: when did the behavior start, what software or network condition changed immediately beforehand, and is the failure consistent on every attempt? A successful unrelated feature should not be treated as proof that the affected layer is healthy.
Where the failure usually starts
All PHP worker slots may be occupied by slow application calls or a DB bottleneck. This is a hypothesis that should be confirmed through the comparison above. A front-end error may originate in an upstream proxy, runtime worker, database or identity claim. The right repair is determined by the first failing layer, not the most visible error page.
Use change windows, narrow rollback plans and minimal logging. A temporary 200 response does not prove correctness when a protected endpoint inadvertently begins serving unauthenticated requests If the test result contradicts the suspected cause, do not push forward with a broad reset. Return to the recorded baseline and investigate the next boundary instead.
Safety and baseline
Take a current application and database backup, preserve service config files and record the precise HTTP status or logged exception. Prefer staging for changes affecting authentication or user data.
- Check PHP-FPM logs for server reached pm.max_children at the exact outage minute.
- Correlate PHP slow logs, database query times and memory per worker; avoid applying oversized pools blindly.
- Note the original settings and capture any relevant error identifier without copying passwords or session tokens.
Do not begin with formatting a disk, deleting a player profile, disabling secure boot, bypassing TLS checks or running registry cleaners. The controlled tests below are designed to find the narrow failure before considering any operation that could affect unrelated data.
Step-by-Step Troubleshooting
Choose Beginner for reversible checks or Advanced for focused diagnostics.
Capture the exact failure in PHP-FPM
A busy WordPress site sporadically returns 502 while lightweight static assets keep loading. Record the product model, application build and time of failure. Check PHP-FPM logs for server reached pm.max_children at the exact outage minute. Use a screenshot or a non-sensitive log excerpt as the baseline; do not attempt three repairs at once.
Run the lowest-risk comparison
Check PHP-FPM logs for server reached pm.max_children at the exact outage minute. Compare the outcome with a known-working account, device, cable or network only where it is permitted and relevant. A front-end error may originate in an upstream proxy, runtime worker, database or identity claim. The right repair is determined by the first failing layer, not the most visible error page Keep the original settings written down so each test is reversible.
Apply a supported, targeted correction
Identify and fix the slow request or query before raising worker limits within available RAM. Confirm that the changed component actually belongs to PHP-FPM and is supported by the installed OS and hardware. Restart only the necessary app or device, and leave unrelated security settings intact.
Check the original workflow again
A representative traffic test runs without worker-exhaustion warnings and memory remains stable. Repeat the exact action that failed originally, not a different synthetic test. Record whether the problem is resolved completely, only on one connection, or only after a restart; that distinction determines the next action.
Identify the responsible subsystem
All PHP worker slots may be occupied by slow application calls or a DB bottleneck. Correlate PHP slow logs, database query times and memory per worker; avoid applying oversized pools blindly. Use the resulting difference to decide whether this is a client, runtime, transport, account or hardware problem rather than assuming all of them are defective.
Collect narrow technical evidence
Correlate PHP slow logs, database query times and memory per worker; avoid applying oversized pools blindly. Retain only timestamps, error identifiers, compatible versions and the relevant event sequence. Apply the least-privilege change that restores authorized access. Never log plaintext secrets, bypass TLS certificate checks or disable WAF controls globally to make a test succeed Mask identifiers, tokens and personal data before handing logs to anyone.
Isolate the change with rollback
Identify and fix the slow request or query before raising worker limits within available RAM. Test a second known-good configuration where available. Note the original setting and apply only one approved change; if the expected signal does not improve, restore the baseline before trying another hypothesis.
Confirm stability and document the limit
A representative traffic test runs without worker-exhaustion warnings and memory remains stable. Run a second test after a normal restart or reconnect if the original symptom involved state transitions. Use an authenticated and an unauthenticated control request after the repair, and check logs for new errors and resource saturation under realistic traffic If evidence points to unsupported hardware or organization policy, escalate rather than inventing a bypass.
Read the results
Use the following evidence map after completing the Beginner checks. Each row provides an interpretation, not an instruction to apply every possible fix.
| Layer | Evidence to compare | Next decision |
|---|---|---|
| Client and authentication | Check PHP-FPM logs for server reached pm.max_children at the exact outage minute. | Investigate the local setup or initial prerequisite. |
| Application/runtime or proxy | All PHP worker slots may be occupied by slow application calls or a DB bottleneck. | Compare the failing component with a known working control. |
| Upstream logs and persistence | Correlate PHP slow logs, database query times and memory per worker; avoid applying oversized pools blindly. | Keep only observations supported by a log or repeatable test. |
Correlate PHP slow logs, database query times and memory per worker; avoid applying oversized pools blindly. If the evidence points away from this layer, return to the previous row. The process is intentionally sequential: a configuration change only has diagnostic value when the prior state is recorded.
Optional read-only diagnostic — Linux (read-only; adjust the log path): Run this only on a system you administer. Replace example values with your own legitimate paths as needed.
journalctl -u php-fpm --since "1 hour ago" --no-pagerChanges to avoid
- Avoid changing unrelated layers. Apply the least-privilege change that restores authorized access. Never log plaintext secrets, bypass TLS certificate checks or disable WAF controls globally to make a test succeed
- Do not confuse a temporary workaround with a fix. All PHP worker slots may be occupied by slow application calls or a DB bottleneck.
- Do not erase the evidence. Keep the original settings and note whether a busy WordPress site sporadically returns 502 while lightweight static assets keep loading.
Decision rule: If the proposed change does not produce the expected result in a repeatable test, restore the previous configuration. A problem that remains identical needs better evidence, not a larger reset.
Proof that it works
A representative traffic test runs without worker-exhaustion warnings and memory remains stable. Use the same device, title, workload or service path on which the failure was observed. Compare the outcome directly with the original screenshot or error log, and repeat the test twice if the failure was intermittent.
Use an authenticated and an unauthenticated control request after the repair, and check logs for new errors and resource saturation under realistic traffic If one test passes but the underlying account, certificate, performance metric or data synchronization is still wrong, mark the result as partial and continue with the Advanced checks rather than claiming a complete repair.
Solution Checklist
Recovery and escalation
Correlate PHP slow logs, database query times and memory per worker; avoid applying oversized pools blindly. If PHP-FPM still fails the original operation, revert temporary test settings that did not help and capture the precise evidence for the vendor or administrator. Include what worked, what failed and whether the comparison was conducted on the same build and connection.
Do not keep repeating account resets, firmware flashes or driver removals when there is no measurable improvement. For unsupported hardware, managed work devices or possible physical failure, ask the relevant vendor or qualified technician to confirm the supported route forward.
Keep the configuration stable
Identify and fix the slow request or query before raising worker limits within available RAM. Keep the exact working driver, firmware version, app build or policy setting documented. Future changes should be tested against the same baseline, especially after operating-system, network or application updates.