Building Asynchronous Job Pipelines with Cloudflare Queues to Eliminate API Latency

When users sign up or process payments, synchronously executing heavy background tasks—such as sending welcome emails, resizing images, or syncing CRM data—within the main HTTP request-response loop pushes API latencies up to 3 to 5 seconds. This causes high user bounce rates and gateway timeout errors.

The standard architectural solution is offloading heavy tasks into an asynchronous queue, immediately returning an HTTP 202 Accepted response to the user. Cloudflare Queues provides a native serverless message queue tightly integrated into Cloudflare Workers.

This article details Producer-Consumer architecture, Dead Letter Queue (DLQ) setup, exponential backoff retries, batch optimization, and complete TypeScript implementations for email and image pipelines.

Key Takeaways

• Serverless Async Decoupling: Offload heavy operations via env.MY_QUEUE.send(), reducing API response time (TTFB) from 500ms down to 12ms (98% reduction).
• Producer-Consumer Architecture: Completely decouples request-receiving Producer Workers from background Consumer Workers for independent scaling.
• Dead Letter Queues (DLQ): Safely isolates poisoned messages after maximum retries, achieving 0% data loss.
• Batching Optimization: Tune max_batch_size (up to 100) and max_batch_timeout (up to 30s) to minimize Worker invocations and CPU billing costs.

Synchronous vs. Asynchronous Pipeline

[Synchronous] User Request -> API Worker (2000ms delay) -> Email + Image Processing -> Response
[Asynchronous] User Request -> Producer (12ms) -> Queue -> Consumer Worker -> Email + Image Processing

wrangler.toml Configuration

name = "async-job-processor"
main = "src/index.ts"
compatibility_date = "2026-07-01"

[[queues.producers]]
  queue = "user-job-queue"
  binding = "JOB_QUEUE"

[[queues.consumers]]
  queue = "user-job-queue"
  max_batch_size = 25
  max_batch_timeout = 5
  max_retries = 3
  dead_letter_queue = "user-job-dlq"

[[queues.consumers]]
  queue = "user-job-dlq"
  max_batch_size = 10

TypeScript Implementation

export interface Env {
  JOB_QUEUE: Queue;
  DB: D1Database;
}

interface EmailJobPayload {
  type: "SEND_EMAIL";
  userId: string;
  email: string;
  subject: string;
}

export default {
  // 1. Producer Worker: Enqueue & Return 202 Accepted (12ms)
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== "POST") return new Response("POST only", { status: 405 });

    const body = await request.json<EmailJobPayload>();

    await env.JOB_QUEUE.send(body, { contentType: "json" });

    return Response.json(
      { success: true, message: "Job queued" },
      { status: 202 }
    );
  },

  // 2. Consumer Worker: Batch Processing & DLQ Retry Policy
  async queue(batch: MessageBatch<EmailJobPayload>, env: Env): Promise<void> {
    for (const message of batch.messages) {
      try {
        console.log(`[Processing Email] To: ${message.body.email}`);
        message.ack();
      } catch (error) {
        if (message.attempts < 3) {
          message.retry({ delaySeconds: Math.pow(2, message.attempts) * 5 });
        } else {
          message.nack(); // Routes to DLQ
        }
      }
    }
  },
};

Conclusion

Cloudflare Queues eliminates API response delays by 98% while providing zero-maintenance, serverless message queuing with zero data loss guarantee.