DEV Community: Saiyam Jain

RabbitMQ Explained: How It Works, How It Differs from Kafka, and Where It Fits in Real Systems

Saiyam Jain — Thu, 28 May 2026 20:07:16 +0000

Modern applications are no longer simple monoliths. Today’s systems handle millions of requests, asynchronous workflows, distributed microservices, and background processing — all at once.

To make this reliable and scalable, applications rely on message brokers. One of the most widely used is RabbitMQ.

In this article, we’ll cover:

What RabbitMQ is and how it works internally
Real-world use cases with examples
RabbitMQ vs Kafka — the honest comparison
When to choose each
Modern messaging alternatives worth knowing

Why Do We Need Message Queues?

Imagine an e-commerce app. When a customer places an order, multiple things need to happen:

Payment processing
Inventory update
Invoice generation
Email notification
Shipping workflow

If everything happens synchronously:

User places order
  → API calls Payment Service (waits...)
    → API calls Inventory Service (waits...)
      → API calls Email Service (waits...)
        → Finally responds to user ❌ Slow. One failure = all fail.

With RabbitMQ:

User places order
  → API publishes one event → returns instantly ✅
    → Payment Service processes independently
    → Inventory Service processes independently
    → Email Service processes independently

The user gets an instant response. Each service works on its own. A crash in one doesn’t bring down the rest.

What is RabbitMQ?

RabbitMQ is an open-source message broker that lets applications and microservices communicate asynchronously. It implements the AMQP (Advanced Message Queuing Protocol) standard.

Think of it as a post office:

Role	What it does
Producer	Writes and sends a message
RabbitMQ	Stores and routes it reliably
Consumer	Receives and processes the message

Services don’t talk directly to each other. They talk through RabbitMQ. This decoupling is what gives you scalability, fault tolerance, and resilience.

How RabbitMQ Works Internally

RabbitMQ has four core components:

Producer → Exchange → Queue → Consumer

1. Producer

The service that sends messages. Examples: Order Service, Payment Service, Notification Service.

2. Exchange

The brain of RabbitMQ. It receives messages from producers and decides where they go. There are four types:

🎯 Direct Exchange — Routes by exact routing key match

Message key: "order.created"

Exchange ──→ order.q    ✅ (exact match)
         ──→ payment.q  ❌ (no match)
         ──→ shipping.q ❌ (no match)

📢 Fanout Exchange — Broadcasts to ALL bound queues

Message arrives

Exchange ──→ email.q    ✅
         ──→ sms.q      ✅
         ──→ push.q     ✅

Use case: notifications, cache invalidation, real-time updates.

🔍 Topic Exchange — Wildcard pattern matching (* = one word, # = many)

Message key: "order.paid.india"

Exchange ──→ order.*    ❌ (* matches only one word)
         ──→ order.#    ✅ (# matches one or more)
         ──→ user.#     ❌ (wrong prefix)

Very common in microservices architectures.

📋 Headers Exchange — Routes by message header attributes instead of routing keys. Less common but powerful for complex filtering.

3. Queue

Stores messages until a consumer is ready to process them. RabbitMQ guarantees delivery using acknowledgements, persistence, and retries.

4. Consumer

The service that reads and processes messages. Consumers can scale horizontally — spin up more instances to handle high load.

Real-World Example: Food Delivery App

When someone places an order on a platform like Swiggy or Uber Eats:

The Order API publishes one message:

{
  "orderId": 1001,
  "restaurant": "Pizza Hub",
  "customer": "Saiyam",
  "total": 540.00
}

RabbitMQ fans it out to multiple queues:

Order API (Producer)
      │
   RabbitMQ Exchange
      │
      ├──→ 💳 Payment Queue     → charges the customer
      ├──→ 🍳 Restaurant Queue  → notifies the restaurant
      ├──→ 🛵 Delivery Queue    → assigns a delivery agent
      └──→ 🔔 Notification Queue → sends SMS/email

Each service works independently. If the notification service crashes, payments still go through and orders still flow. Notifications retry automatically once it recovers.

This isolation is RabbitMQ’s biggest strength.

Key Features of RabbitMQ

Feature	What it does
Reliable Delivery	Messages persist to disk — survive broker restarts
Acknowledgements	Consumers confirm processing; unconfirmed messages are requeued
Retry Mechanisms	Failed messages retry automatically with configurable backoff
Dead Letter Queues	Unprocessable messages go to a DLQ for investigation
Priority Queues	High-priority tasks jump the queue
Delayed Messaging	Schedule retries, reminders, or deferred tasks
Horizontal Scaling	Add more consumer instances to handle load

RabbitMQ vs Kafka

This is the most common question in distributed systems. They look similar on the surface but solve fundamentally different problems.

The one-line mental model:

🐇 RabbitMQ — “Deliver this task reliably to someone who will act on it now.”

⚡ Kafka — “Persist and stream this event so anyone can consume it — now or in the future.”

Full Comparison

Feature	🐇 RabbitMQ	⚡ Kafka
Primary purpose	Message broker	Event streaming platform
Message model	Queue-based	Distributed log
Throughput	Moderate	Extremely high (millions/s)
Latency	Very low (< 1ms)	Low (few ms)
Message retention	Deleted after consumption	Long-term (days/forever)
Replay messages	Limited	Excellent (seek to any offset)
Routing flexibility	Very high (4 exchange types)	Moderate (topic-based)
Ordering	Per-queue	Per-partition
Best for	Task queues, workflows	Streaming, analytics, pipelines

When RabbitMQ is the right choice

Email / SMS / push notification pipelines
Payment and order workflows
Background job processing
Microservice orchestration
Any system needing complex routing logic

When Kafka is the right choice

Real-time analytics dashboards
Data lake ingestion pipelines
Clickstream and log aggregation
IoT telemetry at massive scale
Event sourcing and audit trails
Fraud detection systems (e.g., Netflix, banking)

Can they work together?

Absolutely. Many production architectures use both:

Operational layer   →  RabbitMQ  (process payments, send notifications)
Analytics layer     →  Kafka     (fraud detection, dashboards, audit logs)

Modern Messaging Technologies Worth Knowing

The ecosystem is evolving. A few alternatives gaining real traction:

Apache Pulsar — Combines RabbitMQ + Kafka capabilities in one system. Built cloud-native with multi-tenancy, geo-replication, and tiered storage. Many consider it a strong Kafka alternative.

NATS — Lightweight and blazingly fast. Born for Kubernetes and edge computing. Zero complex configuration — just run it.

Redis Streams — Event streaming built into Redis. If Redis is already in your stack, this adds streaming with zero new infrastructure.

Amazon SQS — Fully managed by AWS. Best for teams who want zero infrastructure management. Less routing flexibility, but operationally effortless.

Which Should You Learn First?

Start with RabbitMQ if you:

Work with microservices or enterprise systems
Build transactional workflows (payments, orders, notifications)
Want something easier to operate and reason about

Start with Kafka if you:

Work in big data, analytics, or data engineering
Build streaming platforms or event-sourcing systems
Work on large-scale distributed systems

Knowing both is extremely valuable for senior backend engineers and architects.

Final Thoughts

RabbitMQ remains one of the most reliable and practical messaging systems in modern software engineering. Its strengths — routing flexibility, operational stability, and battle-tested reliability — make it the preferred choice for business-critical workflows.

Kafka dominates large-scale event streaming. But both tools have their place.

The best engineers understand not just how these technologies work, but when to reach for each one. In distributed systems, choosing the right communication model matters more than choosing the trendiest technology.

Have you used RabbitMQ or Kafka in production? Do you prefer NATS or Pulsar? Drop your experience in the comments — would love to hear real-world war stories.

Understanding SQL Ranking Functions: RANK, DENSE_RANK, and ROW_NUMBER

Saiyam Jain — Thu, 25 Jul 2024 14:25:36 +0000

In SQL, ranking functions are used to assign a rank or a sequential number to rows in a result set based on the values of one or more columns. These functions are particularly useful for tasks like sorting, ranking, and partitioning data. The most commonly used ranking functions are RANK, DENSE_RANK, and ROW_NUMBER. This article explains these functions and demonstrates how to use them with SQL queries.

Key Concepts

RANK()
- Description: Assigns a rank to each row within a result set based on the specified ordering. Rows with the same values receive the same rank, and subsequent ranks are adjusted to account for ties, resulting in gaps in the ranking sequence.
- Example: If two rows share the highest rank (1), the next rank assigned will be 3, leaving a gap.
DENSE_RANK()
- Description: Similar to RANK, but without gaps in the ranking values. Rows with the same values receive the same rank, and the next distinct value gets the immediate next rank.
- Example: If two rows share the highest rank (1), the next rank assigned will be 2, without any gaps.
ROW_NUMBER()
- Description: Assigns a unique sequential integer to each row based on the specified ordering. It does not consider the values of the rows for ranking and does not create ties or gaps.
- Example: Each row is given a unique number starting from 1, regardless of the values in the rows.

Practical Example

Consider a table named StudentMarks with the following data:

Name	Marks
A	100
B	100
C	89

To apply these ranking functions, we need to order the data by the Marks column in descending order.

SQL Queries

Here’s how you can use RANK, DENSE_RANK, and ROW_NUMBER functions in SQL to get the ranking of each row:

1. `DENSE_RANK`

SELECT
    Name,
    Marks,
    DENSE_RANK() OVER (ORDER BY Marks DESC) AS DenseRank
FROM
    StudentMarks;

Output:
| Name | Marks | DenseRank |
|------|-------|-----------|
| A | 100 | 1 |
| B | 100 | 1 |
| C | 89 | 2 |

Explanation: Both A and B have the highest marks (100) and share rank 1. The next distinct mark (89) gets rank 2.

2. `RANK`

SELECT
    Name,
    Marks,
    RANK() OVER (ORDER BY Marks DESC) AS Rank
FROM
    StudentMarks;

Output:
| Name | Marks | Rank |
|------|-------|------|
| A | 100 | 1 |
| B | 100 | 1 |
| C | 89 | 3 |

Explanation: Both A and B share rank 1. The next distinct mark (89) receives rank 3, creating a gap because ranks 1 and 2 are taken.

3. `ROW_NUMBER`

SELECT
    Name,
    Marks,
    ROW_NUMBER() OVER (ORDER BY Marks DESC) AS RowNumber
FROM
    StudentMarks;

Output:
| Name | Marks | RowNumber |
|------|-------|-----------|
| A | 100 | 1 |
| B | 100 | 2 |
| C | 89 | 3 |

Explanation: Each row is assigned a unique sequential number based on the descending order of marks. There are no ties or gaps.

Conclusion

SQL ranking functions such as RANK, DENSE_RANK, and ROW_NUMBER are powerful tools for organizing and analyzing data. Understanding the differences between these functions allows you to choose the appropriate ranking method based on your needs, whether it’s handling ties, avoiding gaps, or simply numbering rows sequentially. By using these functions effectively, you can gain valuable insights and present data in a meaningful way.

5 ways to reverse a string in Python

Saiyam Jain — Sun, 07 Nov 2021 19:10:30 +0000

Hello everyone, in this post I will provide you 5 different ways to reverse a string using python programming.

1

Using Slicing

def StrRev(string):
    string = string[::-1]
    return string

s = input("Enter a string: ")

print (StrRev(s))

2

Using Reversed Function

def StrRev(string):
    string = "".join(reversed(string))
    return string

s = input("Enter a string: ")
print (StrRev(s))

3

Using Loop

def StrRev(s):
  strg = ""
  for i in s:
    strg = i + strg
  return strg

s = input("Enter a string: ")
print (StrRev(s))

4

Using Recursive function

def StrRev(s):
    if len(s) == 0:
        return s
    else:
        return StrRev(s[1:]) + s[0]

s = input("Enter a string: ")
print(StrRev(s))

5

Using Stack Operations

def StackCreate():
    stack=[]
    return stack


def isEmpty(stack):
    if len(stack) == 0:
        return true


def push(stack,item):
    stack.append(item)

def pop(stack):
    if isEmpty(stack): return
    return stack.pop()


def StrRev(string):
    n = len(string)


    stack = StackCreate()

    for i in range(0,n,1):
        push(stack,string[i])

    string=""

    for i in range(0,n,1):
        string+=pop(stack)

    return string

s = input("Enter a string: ")
print (StrRev(s))