Middle Message Queues & Async Interview Questions (50 MCQs)

Question 1

In a RabbitMQ topic exchange, which routing key matches the binding key `order.*.created`?

Accepted Answer

`order.eu.created`

Answer

`order.created`

Answer

`order.eu.de.created`

Answer

`order.eu.updated`

Question 2

How does a RabbitMQ headers exchange route messages?

Accepted Answer

By matching message header values, with `x-match` set to `all` or `any`

Answer

By wildcard patterns on the routing key

Answer

By the size of the message body

Answer

By the producer's IP address

Question 3

What's needed so RabbitMQ messages survive a broker restart?

Accepted Answer

A durable queue and messages published with `persistent: true` (delivery mode 2)

Answer

A durable queue alone is enough

Answer

Only `persistent: true` on the message is enough

Answer

Setting `prefetch(0)` on the consumer

Question 4

What problem do publisher confirms solve in RabbitMQ?

Accepted Answer

The producer learns the broker received and (if persistent) stored the message

Answer

The consumer learns the producer is still online

Answer

Messages are delivered to consumers exactly once

Answer

Order is preserved across multiple queues

Question 5

In RabbitMQ, if a published message matches no queue, what happens by default?

Accepted Answer

It's silently dropped unless `mandatory` or an alternate exchange is set

Answer

It's held in the exchange until a matching queue appears

Answer

It's sent to every queue

Answer

The broker errors and closes the connection

Question 6

In RabbitMQ, which events send a message to the dead-letter exchange (DLX)?

Accepted Answer

Reject/nack with `requeue: false`, TTL expiry, or exceeding queue length

Answer

Only when a consumer disconnects

Answer

Every time a message is acked

Answer

Whenever a message is delivered more than once

Question 7

What's a common way to do delayed retries in RabbitMQ without plugins?

Accepted Answer

Send failures to a retry queue with a TTL whose DLX routes back to the main queue

Answer

`nack` with `requeue: true`, which has built-in exponential delay

Answer

Calling `sleep` in the consumer before acking

Answer

Raising prefetch so the message comes later

Question 8

What's wrong with calling `nack(msg, false, true)` on every consumer error?

Accepted Answer

A poison message is redelivered immediately and endlessly, burning CPU

Answer

The message is deleted forever

Answer

The message goes to the DLQ and is never retried

Answer

The consumer stops receiving any messages

Question 9

What advantage does a RabbitMQ quorum queue have over a classic queue?

Accepted Answer

Data is replicated across nodes via Raft and survives a node failure

Answer

It keeps messages only in memory, so it's faster

Answer

It provides global ordering across all queues

Answer

It removes the need for acks

Question 10

If prefetch is very large (e.g. 1000) and processing is slow, what goes wrong?

Accepted Answer

One consumer hoards many messages while newly added consumers sit idle

Answer

Messages get auto-acked

Answer

The broker sends messages in reverse order

Answer

The queue gets automatically deleted

Question 11

In BullMQ, what does `concurrency: 5` on a `Worker` mean?

Accepted Answer

That worker processes up to 5 jobs at once in the same process

Answer

It spawns 5 new Node processes

Answer

Each job is retried up to 5 times

Answer

Only 5 jobs are kept in the queue

Question 12

In BullMQ, what is a 'stalled job'?

Accepted Answer

A job whose worker stopped renewing its lock (crash or blocked event loop) and gets moved back

Answer

A job waiting in the delayed state

Answer

A job that completed but wasn't removed

Answer

A job with low priority

Question 13

Which BullMQ option retries a job up to 5 times with exponential backoff starting at 2 seconds?

Accepted Answer

`{ attempts: 5, backoff: { type: 'exponential', delay: 2000 } }`

Answer

`{ retries: 5, delay: 2000 }`

Answer

`{ attempts: 5, repeat: { every: 2000 } }`

Answer

`{ maxRetries: 5, backoff: 'exp:2s' }`

Question 14

What's the advantage of BullMQ repeatable jobs over `node-cron` in each instance?

Accepted Answer

The schedule lives in Redis and each run is executed once by one worker

Answer

Repeatable jobs work without Redis

Answer

Repeatable jobs never fail

Answer

Repeatable jobs run simultaneously on all instances

Question 15

Why do production BullMQ setups usually configure `removeOnComplete` and `removeOnFail`?

Accepted Answer

So finished jobs don't pile up in Redis forever and exhaust memory

Answer

So failed jobs are automatically retried

Answer

So jobs execute faster

Answer

To prevent duplicate job execution

Question 16

Your email API allows at most 10 requests per second. How do you respect that in BullMQ?

Accepted Answer

Set `limiter: { max: 10, duration: 1000 }` on the Worker

Answer

Use `concurrency: 10`, which limits the rate by itself

Answer

Use `attempts: 10` on each job

Answer

Add every job with `delay: 100`

Question 17

During a deploy, what should a worker do on `SIGTERM`?

Accepted Answer

Stop taking new messages, finish in-flight work, then exit

Answer

Exit immediately with `process.exit(0)`

Answer

Ack every message in the queue and exit

Answer

Ignore the signal until Kubernetes kills it

Question 18

In SQS, what does `maxReceiveCount` in a redrive policy do?

Accepted Answer

After a message is received that many times without deletion, it moves to the DLQ

Answer

Sets the max number of concurrent consumers

Answer

Sets how many messages each `ReceiveMessage` returns

Answer

How many times the producer retries sending

Question 19

Processing takes about 2 minutes but the queue's visibility timeout is 30 seconds. What happens?

Accepted Answer

The message reappears before completion and another consumer processes it too

Answer

SQS waits until processing finishes

Answer

The message immediately goes to the DLQ

Answer

The consumer gets a timeout error and the message is deleted

Question 20

What's the benefit of enabling SQS long polling (`WaitTimeSeconds: 20`)?

Accepted Answer

Fewer empty responses and lower request cost, since it waits for messages to arrive

Answer

Messages are hidden from others for 20 seconds

Answer

Messages are retained for 20 days

Answer

Message order becomes guaranteed

Question 21

In an SQS FIFO queue, what's the role of `MessageGroupId`?

Accepted Answer

Order is guaranteed within each group, and different groups process in parallel

Answer

It's used to drop duplicate messages

Answer

It decides which DLQ the message goes to

Answer

It sets the message priority

Question 22

What does `MessageDeduplicationId` guarantee in SQS FIFO?

Accepted Answer

Messages with the same ID within a 5-minute window are accepted only once

Answer

The message is never accepted again, even a month later

Answer

Consumers process each message exactly once even across crashes

Answer

Messages are sorted by it

Question 23

What is an SNS subscription filter policy for?

Accepted Answer

Each subscriber receives only messages whose attributes match its filter

Answer

Reject messages larger than a set size

Answer

Encrypt messages before delivery

Answer

Preserve order across subscribers

Question 24

What's the risk of `enable.auto.commit=true` in a Kafka consumer?

Accepted Answer

Offsets may be committed before processing finishes, losing messages on crash

Answer

Offsets are never committed

Answer

Each message is processed exactly once

Answer

The consumer re-reads from the start on every poll

Question 25

If a Kafka consumer processes first and commits the offset afterward, what semantics do you get?

Accepted Answer

At-least-once

Answer

At-most-once

Answer

Exactly-once

Answer

Best-effort with no guarantee

Question 26

When does a Kafka consumer group rebalance happen?

Accepted Answer

When a consumer joins or leaves, misses heartbeats, or partitions change

Answer

Every time a producer sends a message

Answer

Only when a broker restarts

Answer

Every 24 hours on a schedule

Question 27

What happens if processing a batch takes longer than `max.poll.interval.ms`?

Accepted Answer

The consumer is considered dead, a rebalance occurs, and its next commit fails

Answer

Kafka waits for processing to finish

Answer

The batch's messages are deleted

Answer

The consumer automatically receives a smaller batch

Question 28

How is consumer lag computed in Kafka?

Accepted Answer

The difference between the partition's log end offset and the group's committed offset

Answer

Time between producer send and broker ack

Answer

The number of idle consumers in the group

Answer

The number of messages deleted by retention

Question 29

A 4-partition topic has high lag with 4 consumers. What does adding a 5th consumer do?

Accepted Answer

Nothing; you need more partitions or faster per-consumer processing

Answer

Throughput rises about 25%

Answer

Kafka automatically creates a new partition

Answer

Lag drops to zero immediately

Question 30

What ordering risk comes with increasing partitions on an existing topic?

Accepted Answer

New messages for a key may land in a different partition, breaking order relative to older ones

Answer

All existing messages are deleted

Answer

Kafka doesn't allow adding partitions

Answer

Old messages are automatically redistributed

Question 31

What does a replication factor of 3 mean for a Kafka topic?

Accepted Answer

Each partition has one leader and two followers on different brokers

Answer

Each message is delivered to consumers three times

Answer

The topic has three partitions

Answer

Three consumer groups can read the topic

Question 32

What's the risk of `acks=1` on a Kafka producer?

Accepted Answer

If the leader dies before replication, an acknowledged message is lost

Answer

The producer never receives an ack

Answer

Messages are always duplicated

Answer

Throughput drops sharply because it waits for all replicas

Question 33

What does Kafka log compaction (`cleanup.policy=compact`) retain?

Accepted Answer

At least the latest value for each key

Answer

Only messages from the last 7 days

Answer

It gzips messages and keeps all of them

Answer

Only the first message for each key

Question 34

Why do Kafka setups use retry topics and a DLT instead of retrying in place?

Accepted Answer

Because in-place retries block the partition and stall all following messages

Answer

Because Kafka doesn't support acks

Answer

Because Kafka deletes messages after reading

Answer

Because retry topics guarantee ordering

Question 35

What does backpressure mean in a messaging system?

Accepted Answer

A mechanism that slows intake or production when the consumer falls behind

Answer

Compressing messages to reduce network traffic

Answer

Returning messages to the producer after processing

Answer

Raising the priority of older messages

Question 36

Which consumer implementation is safe for a `PaymentReceived` event under at-least-once delivery?

Accepted Answer

In one transaction: insert `paymentId` into a processed table with a unique constraint, then update the balance

Answer

Just run `UPDATE accounts SET balance = balance + amount`

Answer

Check a cache for `paymentId` and then update, without a transaction

Answer

Use auto-ack so the message only arrives once

Question 37

What's the best source for a message's dedup key?

Accepted Answer

A stable ID generated by the producer when the event is created, like `eventId`

Answer

The consumer's receive timestamp

Answer

The broker's per-delivery delivery tag

Answer

A UUID the consumer generates per message

Question 38

What's the dual-write problem in: `await db.save(order); await kafka.send('OrderCreated');`?

Accepted Answer

If it crashes between the two, the order is saved but the event is never published

Answer

Kafka doesn't allow sending from an async function

Answer

The event is always published twice

Answer

The DB and Kafka share a lock and deadlock

Question 39

How does the transactional outbox pattern work?

Accepted Answer

The event is written to an outbox table in the same transaction as the business data, then a relay publishes it

Answer

The event is sent to the broker first, then to the database

Answer

Consumers read directly from the other service's tables

Answer

The broker and DB coordinate with two-phase commit

Question 40

What's the difference between event notification and event-carried state transfer?

Accepted Answer

Notification carries just the ID and type; state transfer carries the full data consumers need

Answer

Notification is always sync and state transfer always async

Answer

State transfer is only for sending files

Answer

Notification is Kafka-only and state transfer RabbitMQ-only

Question 41

What does CQRS mean?

Accepted Answer

Separating the write (command) model from the read (query) model, often with separate read stores

Answer

Using one queue per query

Answer

Caching every query in Redis

Answer

Running all commands synchronously

Question 42

In message schema evolution, which change is backward compatible?

Accepted Answer

Adding an optional field with a default value

Answer

Changing `amount` from number to string

Answer

Renaming a required field

Answer

Removing a required field with no default

Question 43

What role does a Schema Registry play alongside Kafka?

Accepted Answer

Storing schema versions and checking compatibility before registering new ones

Answer

Storing messages instead of brokers

Answer

Managing consumer group offsets

Answer

Assigning partitions to consumers

Question 44

In Redis Streams, if a consumer reads with `XREADGROUP` and dies before `XACK`, what happens?

Accepted Answer

It stays in the Pending Entries List and another consumer can take it with `XCLAIM` or `XAUTOCLAIM`

Answer

It's automatically redelivered to another consumer after 30 seconds

Answer

It's permanently removed from the stream

Answer

The whole consumer group stops

Question 45

Why is Redis Pub/Sub unsuitable for a reliable job queue?

Accepted Answer

Messages aren't stored; if no subscriber is connected at that moment, they're lost

Answer

Redis Pub/Sub supports only one subscriber

Answer

Redis Pub/Sub is very slow

Answer

Messages are always delivered twice

Question 46

Which set of metrics matters most for monitoring a queue's health?

Accepted Answer

Queue depth, age of oldest message, error rate and DLQ count

Answer

Only the broker's CPU usage

Answer

Only the number of producers

Answer

Consumer code size and dependency count

Question 47

Which signal is best for autoscaling queue workers?

Accepted Answer

Queue backlog or lag (e.g. using KEDA)

Answer

Only the worker pods' CPU

Answer

The number of HTTP requests to the API

Answer

Time of day

Question 48

After fixing a bug that sent thousands of messages to the DLQ, what's the right approach?

Accepted Answer

Redrive them to the main queue in a controlled way with idempotent consumers and error monitoring

Answer

Purge the DLQ since the messages are stale

Answer

Manually apply each message in the database

Answer

Delete the DLQ so it doesn't happen again

Question 49

What should a consumer do on a validation error (e.g. invalid JSON)?

Accepted Answer

Send it straight to the DLQ without retrying, since the error is permanent

Answer

Retry 10 times with exponential backoff

Answer

Ack and discard it with no logging

Answer

Restart the consumer

Question 50

In SQS, what's the maximum per-message delay with `DelaySeconds`?

Accepted Answer

15 minutes

Answer

12 hours

Answer

7 days

Answer

60 seconds