Message Queues — System Design

Synchronous calls are tight coupling. If the receiver is slow or down, the caller waits or fails. A message queue decouples them: the producer fires and forgets, the consumer processes when ready. This makes systems more resilient, scalable, and independently deployable.

Producer ? Queue ? Consumer

Press Produce to fire messages into the queue. Press Consume to pull them out. Press Flood to see backpressure when the queue fills.

drag — scroll to zoom

Code example

A simple in-process queue using EventEmitter, and a pub/sub pattern.

MESSAGE QUEUE PATTERNS

// Simple queue with EventEmitter
const { EventEmitter } = require('events');

class MessageQueue extends EventEmitter {
    constructor() {
        super();
        this.queue = [];
        this.MAX = 100; // backpressure threshold
    }

    produce(msg) {
        if (this.queue.length >= this.MAX) {
            this.emit('backpressure'); // queue full!
            return false;
        }
        this.queue.push(msg);
        this.emit('message');
        return true;
    }

    consume() {
        return this.queue.shift(); // FIFO
    }
}

const q = new MessageQueue();
q.on('message', () => {
    const msg = q.consume();
    console.log('Processed:', msg);
});
q.on('backpressure', () => console.warn('Queue full!'));
q.produce({ type: 'order', id: 42 });
// Pub/Sub — one producer, many consumers
const { EventEmitter } = require('events');

class PubSub extends EventEmitter {
    subscribe(topic, handler) {
        this.on(topic, handler);
    }
    publish(topic, data) {
        this.emit(topic, data);
    }
}

const bus = new PubSub();

// Multiple consumers — all get every message
bus.subscribe('order.placed', (o) => sendEmail(o));
bus.subscribe('order.placed', (o) => updateInventory(o));
bus.subscribe('order.placed', (o) => chargePayment(o));

// Producer fires once — all subscribers react
bus.publish('order.placed', { id: 42, item: 'GPU' });

// Production: RabbitMQ, Apache Kafka, AWS SQS/SNS
      

Key concepts

📤

Producer

fire and forget — async

The service that creates and sends messages to the queue. It doesn't wait for processing — it fires and moves on. This is the key to async decoupling.

📬

Queue

FIFO — buffer — durable

A first-in, first-out buffer that holds messages until a consumer is ready. In production (RabbitMQ, Kafka), messages are durable — persisted to disk, survive restarts.

📥

Consumer

pull — acknowledge — retry

The service that reads and processes messages. It pulls from the queue at its own pace. On success, it acknowledges — if it crashes without ack, the message is requeued.

⏸

Backpressure

queue full — slow consumer

When producers publish faster than consumers process, the queue fills. Backpressure signals the producer to slow down or reject new messages — preventing unbounded memory growth.

→ Load Balancing System Design — Algo3DVerse Back to Catalog ?