RabbitMQ Event Processing Patterns for Scalable Systems

Synchronous request-response works fine until one slow downstream service takes your whole API down with it. RabbitMQ decouples that — here are the patterns I've actually used, not just the theory behind them.

Core Concepts in 60 Seconds

• Producer — publishes messages to an exchange.

• Exchange — routes messages to one or more queues based on routing rules.

• Queue — buffers messages until a consumer acknowledges them.

• Consumer — processes messages from a queue.

Exchange Types

Setting Up a Publisher in Node.js

I use the amqplib library for all RabbitMQ interactions:

import amqp, { Channel, Connection } from 'amqplib';

let connection: Connection;
let channel: Channel;

async function connectRabbitMQ() {
  connection = await amqp.connect(process.env.RABBITMQ_URL!);
  channel = await connection.createChannel();

  // Declare a topic exchange
  await channel.assertExchange('events', 'topic', { durable: true });
  console.log('RabbitMQ connected and exchange declared');
}

function publishEvent(routingKey: string, payload: object) {
  channel.publish(
    'events',
    routingKey,
    Buffer.from(JSON.stringify(payload)),
    { persistent: true } // survive broker restarts
  );
}

Usage from a controller:

// After creating an order
publishEvent('order.created', { orderId: order._id, userId: order.userId });

Setting Up a Consumer

async function startConsumer() {
  await channel.assertQueue('email-notifications', { durable: true });
  await channel.bindQueue('email-notifications', 'events', 'order.created');

  channel.consume('email-notifications', async (msg) => {
    if (!msg) return;
    try {
      const data = JSON.parse(msg.content.toString());
      await sendOrderConfirmationEmail(data.userId, data.orderId);
      channel.ack(msg); // acknowledge success
    } catch (err) {
      console.error('Failed to process message:', err);
      channel.nack(msg, false, false); // reject — send to DLQ
    }
  });
}

Always acknowledge explicitly. If a consumer crashes mid-processing, RabbitMQ redelivers the message to another consumer automatically.

Dead-Letter Queues (DLQ)

Messages that fail repeatedly should not block the main queue forever. Configure a dead-letter exchange so rejected messages land in a separate queue for inspection:

// Main queue with DLX configuration
await channel.assertQueue('email-notifications', {
  durable: true,
  arguments: {
    'x-dead-letter-exchange': 'dlx',
    'x-dead-letter-routing-key': 'email-notifications.dead',
  },
});

// Dead-letter exchange and queue
await channel.assertExchange('dlx', 'direct', { durable: true });
await channel.assertQueue('email-notifications-dlq', { durable: true });
await channel.bindQueue('email-notifications-dlq', 'dlx', 'email-notifications.dead');

Now when a message is nack-ed without requeue, it moves to the DLQ where you can inspect it, fix the bug, and replay the message.

Retry with Exponential Backoff

Instead of immediately dead-lettering a failed message, introduce a delay queue that re-publishes to the original queue after a wait period:

// Delay queue — messages sit here for 30 seconds, then route back
await channel.assertQueue('email-notifications-retry', {
  durable: true,
  arguments: {
    'x-dead-letter-exchange': 'events',
    'x-dead-letter-routing-key': 'order.created',
    'x-message-ttl': 30000, // 30 second delay
  },
});

On failure, publish the message to the retry queue instead of dead-lettering immediately. After the TTL expires, RabbitMQ forwards it back to the main queue. Track the retry count in a custom header and dead-letter after 3 attempts.

Prefetch for Fair Dispatch

By default, RabbitMQ dispatches messages round-robin without considering consumer workload. Set a prefetch count so a busy consumer does not get flooded:

channel.prefetch(5); // each consumer handles at most 5 unacknowledged messages

Monitoring Queues

Use the RabbitMQ Management UI (port 15672) to monitor:

• Queue depth — a growing queue means consumers are too slow.

• Message rates — publish vs. deliver rate reveals bottlenecks.

• Unacknowledged count — high values indicate stuck consumers.

Wrapping Up

The primitives — exchanges, queues, acks — are simple. The reliability comes from the boring parts: durable queues, dead-letter handling, and retry with backoff, all of which are easy to skip when you're just trying to get a message from A to B.