How do queued jobs work in Laravel?

Question

Accepted Answer

Laravel's **queue system** lets you defer time-consuming tasks (sending emails, processing files, calling slow APIs) to run **in the background**, so the user gets a fast response. Tasks are encapsulated as **Jobs**, pushed onto a queue, and processed by separate **worker** processes.

## The problem queues solve

```text
Slow work done inline makes the user wait and risks request timeouts:
  ✗ sending emails, processing images/video, generating reports, calling slow APIs
  ✓ QUEUE it → respond to the user immediately → a worker handles it in the background
```

## Defining and dispatching a job

```php
<?php
// php artisan make:job ProcessPodcast
class ProcessPodcast implements ShouldQueue {
    public function __construct(public Podcast $podcast) {}

public function handle(): void {
        // the slow work — runs in a WORKER, not the web request
        $this->podcast->process();
    }
}
```

```php
// dispatch the job — pushes it onto the queue, returns IMMEDIATELY
ProcessPodcast::dispatch($podcast);
ProcessPodcast::dispatch($podcast)->delay(now()->addMinutes(10));   // delayed
```

Implementing `ShouldQueue` makes a job queueable. `dispatch()` pushes it onto the queue and returns at once — the user doesn't wait for the work.

## Processing jobs (workers)

```bash
php artisan queue:work          # run a worker to process queued jobs
# in production: run workers as a supervised process (Supervisor) or use Horizon
```

A separate **worker** process pulls jobs off the queue and runs them. Queue backends include Redis, database, SQS, etc.

## Reliability features

```php
class ProcessPodcast implements ShouldQueue {
    public $tries = 3;             // retry up to 3 times on failure
    public $backoff = 60;          // wait 60s between retries
    public function failed(Throwable $e): void { /* handle final failure */ }
}
```

```text
✓ Retries with backoff (resilience), failed-job handling
✓ Persistence (jobs survive restarts via the queue backend)
✓ Laravel Horizon → a dashboard for monitoring/managing Redis queues
```

## Why it matters

Queued jobs are essential for building responsive, scalable Laravel applications — offloading slow or deferred work from the request cycle is a common, important need, and Laravel's queue system makes it elegant.

Understanding it is valuable because doing time-consuming work inline (sending emails, processing media, generating reports, calling slow external services) makes users wait, risks request timeouts, and loses the work if it fails — whereas **queuing** it lets you respond to the user immediately while a background **worker** processes it reliably.

Beyond simple async offloading, Laravel's queues provide important production capabilities: **automatic retries with backoff** (resilience against transient failures), **persistence** (jobs survive crashes/restarts via the queue backend, so work isn't lost), failed-job handling, delayed dispatch, and monitoring via Horizon.

Understanding how to define jobs (`ShouldQueue`), dispatch them (returning immediately), process them with workers (`queue:work`, supervised in production), and configure reliability features is important knowledge for building applications that handle heavy or deferred work gracefully.

Since responsive applications routinely need to offload work to the background — and since Laravel's queue system is the elegant, idiomatic way to do it with built-in reliability — mastering jobs and queues is frequently-relevant, important knowledge for building production-grade Laravel applications that stay fast and reliable under real-world workloads.