{"id":262,"date":"2026-05-21T13:01:35","date_gmt":"2026-05-21T13:01:35","guid":{"rendered":"https:\/\/abrarqasim.com\/blog\/laravel-queues-2026-defaults-i-stopped-trusting-in-production\/"},"modified":"2026-05-21T13:01:35","modified_gmt":"2026-05-21T13:01:35","slug":"laravel-queues-2026-defaults-i-stopped-trusting-in-production","status":"publish","type":"post","link":"https:\/\/abrarqasim.com\/blog\/laravel-queues-2026-defaults-i-stopped-trusting-in-production\/","title":{"rendered":"Laravel Queues in 2026: Defaults I Stopped Trusting in Production"},"content":{"rendered":"

The first Laravel queue job I ever shipped to production ran 47 times. It was a “send welcome email” job. The user got 47 welcome emails. I learned about queue retries that day, in the loudest possible way.<\/p>\n

That was 2019. I’ve gotten better. The queue I run today isn’t fancier, just less wrong. Most of the improvements were unlearning defaults I’d never actually thought about. Laravel’s queue API is good. The defaults are calibrated for “you’re playing around”, not for “you’re paying AWS for SQS by the message”.<\/p>\n

This is the short list of habits I’ve changed, with the actual config I run now. If you’ve ever had a job run more times than it should have, this one’s for you.<\/p>\n

tries vs maxExceptions, and why I always set both<\/h2>\n

For years I set --tries=3<\/code> on php artisan queue:work<\/code> and called it a day. I assumed it meant “retry up to 3 times, then stop”. It does. Sort of.<\/p>\n

Here’s the catch. tries<\/code> counts every attempt, whether the job failed because of an exception or because the worker crashed mid-run. So a job that hits an OOM kill three times in a row gets marked permanently failed without ever actually throwing. That’s fine. But a job that throws a recoverable exception (network blip, transient DB error) also burns a try. Three transient errors in an hour and you’re in the failed_jobs table forever.<\/p>\n

What I do now: I set tries<\/code> high (10) and maxExceptions<\/code> low (3). tries<\/code> is the hard cap on attempts including crashes. maxExceptions<\/code> is the cap on raised exceptions. The pair gives me “give up after 3 real errors, but let me reboot the worker without losing the job”.<\/p>\n

class ProcessPayment implements ShouldQueue\n{\n    public int $tries = 10;\n    public int $maxExceptions = 3;\n    public int $timeout = 60;\n    public int $backoff = 30; \/\/ seconds between retries\n}\n<\/code><\/pre>\n
I learned about backoff<\/code> separately. The default is zero. Zero means “retry immediately, possibly hammering the upstream that just rejected you”. 30s with jitter is fine for most cases. For external APIs, I use the array form: public array $backoff = [10, 30, 60, 300];<\/code> so I back off harder if it keeps failing.<\/p>\n
One more piece I always set: timeout<\/code>. The queue worker default is 60 seconds, but if you have a job that legitimately takes 4 minutes, it gets killed mid-run and the failure looks identical to a crash. Worse, depending on driver, the job can be picked up again before the timeout has actually elapsed, so you get two workers running the same job at the same time. I set timeout<\/code> per job to whatever the realistic upper bound is plus 30%, and I set the worker’s --timeout<\/code> to one second higher than the highest job timeout.<\/p>\n
Bus::chain vs Bus::batch, when each one earns its keep<\/h2>\n
This is where I see the most confusion in code review. Chains and batches are both ways to coordinate jobs, but they have different semantics, and people pick whichever feels familiar.<\/p>\n
Chains are for sequential, dependent work. Each job runs after the previous one succeeds. If any job in the chain fails, the rest don’t run.<\/p>\n
Bus::chain([\n    new ProvisionAccount($user),\n    new SeedDefaultProjects($user),\n    new SendWelcomeEmail($user),\n])->dispatch();\n<\/code><\/pre>\n
If ProvisionAccount<\/code> fails, the welcome email doesn’t go out. Good. That user doesn’t have an account yet.<\/p>\n
Batches are for parallel work with a shared completion signal. Jobs in a batch can run concurrently. You can hook then()<\/code>, catch()<\/code>, and finally()<\/code> callbacks.<\/p>\n
Bus::batch([\n    new SyncStripeCustomer($user),\n    new SyncMailchimpContact($user),\n    new IndexInAlgolia($user),\n])->then(function ($batch) {\n    Log::info('Synced user '.$batch->id);\n})->dispatch();\n<\/code><\/pre>\n
The trap I see in code review: people use a chain because the jobs “should run in order”, when the order doesn’t actually matter and a batch would be twice as fast. Or people use a batch and then are confused that one job depends on another’s output. Pick by data dependency, not by what feels organized.<\/p>\n
Idempotency is the part Laravel won’t do for you<\/h2>\n
This one took me longest to internalize. The Laravel queue docs<\/a> mention it briefly and move on. Every retry should be safe to run.<\/p>\n
That means: a job that charges a credit card needs an idempotency key. A job that sends an email needs a “have I sent this already?” check. A job that updates a database row needs to be idempotent or use firstOrCreate<\/code>\/updateOrCreate<\/code>. The framework cannot do this for you. The framework will happily run your job twice and let your business logic decide what that means.<\/p>\n
The pattern I default to now, especially around payments:<\/p>\n
public function handle(Stripe $stripe): void\n{\n    $key = "charge:{$this->order->id}";\n    if (Cache::has($key)) {\n        return; \/\/ already charged this order\n    }\n    $stripe->charge($this->order, idempotency_key: $key);\n    Cache::put($key, true, now()->addDays(7));\n}\n<\/code><\/pre>\n
That’s the minimum. For more serious systems, the idempotency check has to live in the same transaction as the side effect, so a worker crash between “I just charged” and “let me record that I charged” doesn’t leave you double-charging. Laravel hints at this in the events section of the docs, but the responsibility is yours.<\/p>\n
Horizon defaults I always change<\/h2>\n
I love Laravel Horizon<\/a>. I do not love its defaults.<\/p>\n
Things I change on every new project:<\/p>\n
balanceMaxShift<\/code> and balanceCooldown<\/code>. The default auto-balance is aggressive. On low-traffic queues it churns workers up and down constantly. I set balance => 'auto'<\/code>, maxShift => 1<\/code>, cooldown => 10<\/code> so it adjusts slowly and predictably.<\/p>\n
Per-queue worker counts. Horizon will happily put your high<\/code> priority queue on the same supervisor as low<\/code>. I split them into separate supervisors with explicit min\/max process counts. Email and webhook jobs go on medium<\/code>. Anything user-facing goes on high<\/code> with a smaller max. Reporting goes on low<\/code>.<\/p>\n
tries<\/code> at the supervisor level. Horizon respects the per-job tries<\/code>, but the supervisor default is 1, which silently overrides if you forgot to set it on the job. I set the supervisor tries<\/code> to 5 as a floor.<\/p>\n
'environments' => [\n    'production' => [\n        'supervisor-high' => [\n            'connection' => 'redis',\n            'queue' => ['high'],\n            'balance' => 'auto',\n            'maxProcesses' => 5,\n            'tries' => 5,\n            'timeout' => 60,\n        ],\n    ],\n],\n<\/code><\/pre>\n
I covered this kind of config debt in more detail in my Laravel 12 in production post<\/a>, but the queue config is the bit I tweak most often.<\/p>\n
Failed jobs are a queue. Treat them like one<\/h2>\n
The failed_jobs<\/code> table is not an archive. It is an inbox. I monitor its size and alert when it grows faster than I can investigate. If I ignore it, it grows until either I miss a real outage hiding inside what I assumed was noise, or I hit some other operational issue I should have caught earlier.<\/p>\n
What I run now:<\/p>\n