Laravel Delayed Jobs & Scheduler Integration – Complete Guide

// All three are equivalent — pick the most readable for your context
SendReminderEmail::dispatch($user)->delay(now()->addMinutes(30));
SendReminderEmail::dispatch($user)->delay(1800);  // seconds
SendReminderEmail::dispatch($user)->delay(Carbon::now()->addDay());

// On user registration, schedule the whole onboarding sequence at once
public function registered(User $user): void
{
    SendWelcomeEmail::dispatch($user);                                           // immediately
    SendGettingStartedTips::dispatch($user)->delay(now()->addDay());             // day 1
    SendFirstFeatureHighlight::dispatch($user)->delay(now()->addDays(3));        // day 3
    SendCheckInEmail::dispatch($user)->delay(now()->addWeek());                  // day 7
    SendUpgradePrompt::dispatch($user)->delay(now()->addDays(14));               // day 14
}

// When user adds to cart, schedule a reminder if they don't complete
public function itemAddedToCart(Cart $cart): void
{
    // Cancel any previous reminder for this cart
    $this->cancelPreviousReminders($cart);

    // Schedule new reminder — will be cancelled if they complete the purchase
    $jobId = SendAbandonCartEmail::dispatch($cart)->delay(now()->addHour())->getJobId();
    cache()->put("cart_reminder_{$cart->id}", $jobId, now()->addHours(2));
}

public function orderCompleted(Order $order): void
{
    // Cancel the abandon cart reminder — they bought!
    $jobId = cache()->get("cart_reminder_{$order->cart_id}");
    if ($jobId) {
        // Note: cancelling delayed jobs requires driver-specific approach
        DB::table('jobs')->where('id', $jobId)->delete();  // database driver
    }
}

// When subscription is created, queue expiry warnings
public function subscriptionCreated(Subscription $subscription): void
{
    $expiresAt = $subscription->expires_at;

    // 7-day warning
    if ($expiresAt->subDays(7)->isFuture()) {
        SendExpiryWarning::dispatch($subscription, 7)
            ->delay($expiresAt->subDays(7));
    }

    // 1-day warning
    if ($expiresAt->subDay()->isFuture()) {
        SendExpiryWarning::dispatch($subscription, 1)
            ->delay($expiresAt->subDay());
    }

    // Expiry action
    HandleSubscriptionExpiry::dispatch($subscription)
        ->delay($expiresAt);
}

// app/Console/Kernel.php
protected function schedule(Schedule $schedule): void
{
    // Every night at 2am, dispatch jobs for all users who need a weekly digest
    $schedule->job(new DispatchWeeklyDigests)->weekly()->mondays()->at('08:00');

    // Every hour, sync stale CRM data
    $schedule->job(new SyncStaleCrmContacts)->hourly();

    // Every 5 minutes, dispatch a batch for pending report generation
    $schedule->call(function () {
        Report::where('status', 'pending')
            ->where('scheduled_for', '<=', now())
            ->cursor()
            ->each(fn ($report) => GenerateReport::dispatch($report)->onQueue('reports'));
    })->everyFiveMinutes()->withoutOverlapping();

    // Daily cleanup — queue a batch to prune expired data
    $schedule->job(new PruneExpiredSessions)->daily()->at('03:00')->onQueue('maintenance');
}

class PollPaymentStatus implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 1;  // Don't retry on failure — it will self-reschedule
    private const INTERVAL = 30;  // seconds between polls

    public function __construct(protected Payment $payment) {}

    public function handle(): void
    {
        // Don't poll if payment is in a terminal state
        if (in_array($this->payment->fresh()->status, ['paid', 'failed', 'cancelled'])) {
            return;  // stop polling — no reschedule
        }

        $status = PaymentGateway::checkStatus($this->payment->gateway_id);

        if ($status === 'completed') {
            $this->payment->update(['status' => 'paid', 'paid_at' => now()]);
            $this->payment->order->customer->notify(new PaymentConfirmed($this->payment));
            return;  // done — no reschedule
        }

        if ($status === 'failed') {
            $this->payment->update(['status' => 'failed']);
            return;
        }

        // Still pending — reschedule in 30 seconds
        static::dispatch($this->payment->fresh())->delay(now()->addSeconds(self::INTERVAL));
    }
}

// Start polling when payment is created
public function createPayment(Order $order): Payment
{
    $payment = Payment::create([...]);
    PollPaymentStatus::dispatch($payment)->delay(now()->addSeconds(10));
    return $payment;
}

class EscalateUnresolvedTicket implements ShouldQueue
{
    public function __construct(protected Ticket $ticket) {}

    public function handle(): void
    {
        $ticket = $this->ticket->fresh();

        // Only escalate if still unresolved after the deadline
        if ($ticket->status !== 'open') {
            return;  // resolved in the meantime — skip
        }

        $ticket->escalate();
        $ticket->assignedAgent->supervisor->notify(new TicketEscalated($ticket));
    }
}

// When ticket is created, schedule escalation 4 hours later
public function created(Ticket $ticket): void
{
    EscalateUnresolvedTicket::dispatch($ticket)->delay(now()->addHours(4));
}