Laravel Queue Worker Crashes on cPanel VPS: 5 Dev‑Hardened Fixes to Stop Overnight Job Failures

You’re staring at a blank supervisorctl status screen at 3 AM, the logs are screaming “worker died” and your API endpoints are grinding to a halt. It’s the exact nightmare every Laravel engineer dreads when a queue worker sputters on a cPanel VPS. The good news? You can turn that chaos into a predictable, production‑grade pipeline with five hard‑earned fixes.

Why This Matters

A dead queue worker doesn’t just delay emails or push notifications—it can stall order processing, break webhook integrations, and cause revenue loss. When the issue lives on a shared‑resource cPanel VPS, the ripple effect spreads to WordPress sites running on the same box, choking PHP‑FPM, inflating MySQL latency, and dragging down overall API speed. Fixing the worker restores uptime, protects your brand, and keeps the monetization funnel flowing.

Common Causes of Queue Crashes on cPanel VPS

• Insufficient memory_limit or max_execution_time in php.ini
• Supervisor’s numprocs set too high for available RAM
• Redis connection time‑outs because of aggressive maxclients on the VPS
• MySQL innodb_buffer_pool size too low for job payloads
• cPanel’s Apache RLimitCPU throttling the Laravel process

INFO: The majority of crashes happen after 8–10 hours of continuous processing, when the VPS hits its soft memory ceiling and the OOM killer starts terminating PHP‑FPM workers.

Step‑by‑Step Fix Tutorial

1. Tune PHP‑FPM for Long‑Running Workers

Open the pool configuration used by your Laravel app. On cPanel the file lives at /opt/cpanel/ea-php*/root/etc/php-fpm.d/www.conf (replace * with your PHP version).

[www]
pm = dynamic
pm.max_children = 30          ; increase based on RAM
pm.start_servers = 6
pm.min_spare_servers = 4
pm.max_spare_servers = 12
php_admin_value[memory_limit] = 512M
request_terminate_timeout = 0 ; allow infinite runtime for workers

After saving, reload PHP‑FPM:

systemctl reload php-fpm

2. Configure Supervisor with Graceful Restarts

Supervisor controls the queue daemon. Edit /etc/supervisord.d/laravel-queue.conf (or create it if missing):

[program:laravel-queue]
process_name=%(program_name)s_%(process_num)02d
command=php /home/username/laravel/artisan queue:work redis --sleep=3 --tries=3 --queue=high,default
autostart=true
autorestart=true
user=username
numprocs=3
stopwaitsecs=3600
stdout_logfile=/home/username/logs/queue.log
stderr_logfile=/home/username/logs/queue_error.log

Notice stopwaitsecs is set to 1 hour, giving the worker time to finish long jobs before a forced kill.

supervisorctl reread
supervisorctl update
supervisorctl status laravel-queue

TIP: Keep numprocs lower than pm.max_children to avoid memory contention.

3. Harden Redis Connection Limits

On the VPS, edit /etc/redis/redis.conf and raise maxclients to match your concurrency:

maxclients 10000
tcp-backlog 511
timeout 0

Restart Redis:

systemctl restart redis

4. Optimize MySQL for Queue Payloads

Large JSON payloads in the jobs table can saturate InnoDB buffers. Add the following to /etc/my.cnf.d/server.cnf (or /etc/mysql/my.cnf on Ubuntu):

[mysqld]
innodb_buffer_pool_size = 2G
innodb_log_file_size = 512M
max_allowed_packet = 64M

Then run:

systemctl restart mysqld

5. Adjust cPanel Apache Limits (if using Apache)

cPanel can throttle processes via mod_ruid2 or RLimitCPU. Edit the vhost include:

RLimitCPU 3000 4000
RLimitMEM 131072000 157286400

Reload Apache:

systemctl reload httpd

WARNING: Changing Apache limits may affect other shared sites. Test on a staging copy first.

VPS or Shared Hosting Optimization Tips

• Swap file: Create a 2 GB swap on low‑memory VPS to give the OOM killer breathing room.
• Cloudflare cache: Route static assets through Cloudflare to reduce PHP‑FPM load during spikes.
• Composer autoloader: Run composer dump-autoload -o after each deployment.
• OPcache: Enable opcache.enable=1 and set opcache.memory_consumption=256.
• Docker isolation: If you can, containerize the queue worker; limits become explicit and reproducible.

Real World Production Example

Acme Media runs a Laravel‑based newsletter platform on a 4 vCPU, 8 GB RAM cPanel VPS. After applying the five fixes, their queue:work process stayed alive for 72 hours straight, processing 1.2 M jobs without a single crash.

Before vs After Results

Metric	Before	After
Avg. Worker Uptime	5 hrs	>72 hrs
Memory Usage (PHP‑FPM)	~1.2 GB	~720 MB
Failed Jobs	112	3 (manual retries)
CPU Load (peak)	2.8	1.9

SUCCESS: The same VPS now hosts three WordPress sites with PageSpeed > 92 on mobile, proving the fixes benefit the whole stack.

Security Considerations

• Run queue workers under a dedicated system user with the least privileges.
• Disable exec and shell_exec in php.ini unless absolutely required.
• Enforce SSL between Laravel, Redis, and MySQL – use REDIS_TLS_PORT and MYSQL_SSL_CA.
• Set Supervisor’s stopasgroup=true and killasgroup=true to avoid orphaned processes.

Bonus Performance Tips

1. Batch jobs: Use dispatch(new ProcessBatch($items))->onQueue('high') instead of single‑item jobs.
2. Lazy collections: Model::cursor() prevents loading all rows into memory.
3. Redis pipelines: Group multiple hset calls into a single pipeline.
4. Use php artisan schedule:work for lightweight cron tasks instead of cron.
5. Turn on APCu for config caching in Laravel (php artisan config:cache).

FAQ

Q: My queue still dies after 48 hours. What else can I check?
A: Verify the OOM logs (dmesg | grep -i kill) and increase swap or lower numprocs. Also check for memory leaks in any custom job listeners.

Q: Does this work on a shared cPanel plan?
A: You can apply most PHP‑FPM and Redis tweaks, but Supervisor may be blocked. In that case, use cron with php artisan queue:work --daemon and monitor with crontab -e.

Final Thoughts

Queue reliability is a silent revenue driver. By tightening PHP‑FPM, Supervisor, Redis, MySQL, and Apache limits, you turn a flaky cPanel VPS into a rock‑solid Laravel worker farm. The same budget‑friendly server can power both high‑traffic WordPress blogs and complex API back‑ends—just remember to monitor, automate restarts, and keep security tight.

Ready to scale without breaking the bank? Check out a low‑cost, high‑performance VPS that ships with pre‑configured PHP‑FPM and Redis optimizations: Cheap Secure Hosting from Hostinger.