Middle Event-Driven & Streaming Interview Questions (50 MCQs)

Question 1

Several teams want to consume order events independently, and analytics must be able to reprocess last week's data. Which choice fits best?

Accepted Answer

A distributed log like Kafka with enough retention and a separate consumer group per team

Answer

A single queue that all teams read from as competing consumers

Answer

A queue with a short TTL that deletes messages right after ack

Answer

Synchronous calls from the order service to every team's API

Question 2

A topic has 6 partitions and you scale the consumer group to 10 instances. What happens?

Accepted Answer

4 consumers sit idle because each partition goes to only one consumer

Answer

Throughput rises about 66% because load spreads over 10 instances

Answer

Kafka automatically increases the partition count to 10

Answer

Each partition is split between two consumers and ordering is lost

Question 3

You partition click events by `tenantId` and one large tenant generates 40% of traffic. What is the main problem?

Accepted Answer

One partition becomes hot and its consumer bottlenecks the whole system

Answer

That tenant's messages get randomly scattered across all partitions

Answer

The ordering of smaller tenants' events gets scrambled

Answer

Kafka rejects that tenant's messages due to high volume

Question 4

What is the risk of increasing the partition count of an existing keyed topic?

Accepted Answer

Key-to-partition mapping changes, temporarily breaking per-key ordering

Answer

All existing messages in the topic are immediately deleted

Answer

Consumer groups must be recreated from scratch with new names

Answer

Kafka only allows adding partitions to empty topics

Question 5

What is a common side effect of a consumer group rebalance (e.g. during a deploy)?

Accepted Answer

A temporary pause in consumption and possible reprocessing of uncommitted messages

Answer

Permanent loss of messages published during the rebalance

Answer

Reordering of messages within each partition

Answer

Automatic increase of every topic's replication factor

Question 6

How do you make a consumer that sends an email per message safe against duplicates?

Accepted Answer

Record the message id in a dedup store and check it before sending

Answer

Enable offset auto-commit with a shorter interval

Answer

Reduce the topic's partition count to one

Answer

Ack the message before sending the email so it never repeats

Question 7

How does the transactional outbox pattern solve the dual write problem?

Accepted Answer

The event is written to an outbox table in the same transaction as the business data, then relayed

Answer

The broker and database join one distributed transaction via two-phase commit

Answer

The event is sent to the broker first, then data is saved after confirmation

Answer

The consumer directly polls the producer's database tables

Question 8

What delivery semantics does the outbox relay provide, and what does it imply for consumers?

Accepted Answer

At-least-once; so consumers must be idempotent

Answer

Exactly-once; so consumers need no deduplication

Answer

At-most-once; so consumers must recover lost events

Answer

Best-effort; so consumers must poll the producer's database

Question 9

What is the advantage of log-based CDC (like Debezium reading the WAL/binlog) over polling with an `updated_at` query?

Accepted Answer

It captures all changes, including deletes and intermediate updates, with low DB load

Answer

It requires no access or configuration on the source database at all

Answer

It guarantees consumers never receive a duplicate event

Answer

It automatically protects table schemas from breaking changes

Question 10

What is the downside of exposing raw table changes from CDC as public events to other services?

Accepted Answer

The internal DB schema becomes a public contract, making refactoring hard

Answer

CDC cannot deliver changes in the correct commit order

Answer

CDC events are always larger than Kafka's message limit

Answer

CDC can only be used on NoSQL databases

Question 11

In event sourcing, what problem do snapshots solve?

Accepted Answer

The load time of aggregates with very many events

Answer

Schema incompatibility between event versions

Answer

Duplicate events when publishing to the broker

Answer

The need to delete old events to free disk space

Question 12

In an event-sourced system you need a new report that includes historical data. What is the usual approach?

Accepted Answer

Build a new projection and replay all events from the beginning into it

Answer

Rewrite old events to include the new fields

Answer

Collect data only from now on since history cannot be recovered

Answer

Run complex ad-hoc queries directly on the events table

Question 13

In CQRS, a user places an order, goes to the list page, and does not see it. What is a good fix?

Accepted Answer

Return the write version and wait, or show it optimistically, until the read model catches up

Answer

Remove the read model entirely and always read from the write model

Answer

Turn all events into synchronous calls between services

Answer

Increase message retention in the broker to several months

Question 14

As a saga grows from 3 to 8 steps, what is choreography's biggest problem?

Accepted Answer

The overall flow is visible in no single service, making it hard to trace and change

Answer

Each step must wait for synchronous approval from all other services

Answer

The broker only allows three subscribers per topic

Answer

Choreography requires a shared database among services

Question 15

What is the main risk when designing a saga with orchestration?

Accepted Answer

The orchestrator may absorb too much business logic, leaving services anemic

Answer

There is no way to run compensating transactions

Answer

Services must subscribe directly to each other's events

Answer

The saga's state cannot be stored anywhere

Question 16

Since sagas lack isolation, what problem can occur?

Accepted Answer

Other transactions can see an unfinished saga's intermediate data (dirty reads)

Answer

Each saga step is committed to the database twice

Answer

Saga messages always arrive at services out of order

Answer

Sagas cannot involve more than one service

Question 17

What does a schema registry (like Confluent Schema Registry) do in an event-driven platform?

Accepted Answer

Stores versioned schemas and checks new changes for compatibility on registration

Answer

Routes messages to different partitions based on content

Answer

Removes duplicate messages before they reach consumers

Answer

Controls consumer access to topics with ACLs

Question 18

In schema registry terms, what does 'backward compatibility' mean?

Accepted Answer

A consumer on the new schema can read data written with the previous schema

Answer

A consumer on the previous schema can read data written with the new schema

Answer

Old and new producers cannot write to the same topic simultaneously

Answer

The new schema must have exactly the same fields as the previous one

Question 19

Why do many teams prefer Avro or Protobuf over schemaless JSON for events?

Accepted Answer

Explicit schemas, defined evolution rules, and more compact messages

Answer

Because JSON is not supported by Kafka and modern brokers

Answer

Because these formats eliminate the need for schema versioning

Answer

Because only these formats support end-to-end encryption

Question 20

You want to rename the `amount` field to `totalAmount` in a widely consumed event. What is the safest approach?

Accepted Answer

Add the new field, publish both for a while, then remove the old one after consumers migrate

Answer

Rename the field in a single deploy and notify consumers

Answer

Rewrite the existing events in the topic with the new name

Answer

Temporarily disable compatibility checks in the schema registry

Question 21

To compute 'average transactions over the last 10 minutes, updated every 1 minute', which window type fits?

Accepted Answer

A sliding (hopping) window of size 10 minutes with a 1-minute hop

Answer

A tumbling window of size 1 minute with no overlap

Answer

A session window with a 10-minute inactivity gap

Answer

A global window that never closes

Question 22

To group a user's clicks into 'visits' that end after 30 minutes of inactivity, which window fits?

Accepted Answer

A per-user session window with a 30-minute gap

Answer

A 30-minute tumbling window for all users

Answer

A 30-minute sliding window with a 1-minute hop

Answer

A count window grouping every 30 events

Question 23

What role does a watermark play in stream processing (e.g. Flink)?

Accepted Answer

Declaring that events before time T have likely arrived, so windows can close

Answer

Tagging messages to detect tampering in transit

Answer

Setting the maximum number of messages per partition

Answer

Marking the consumer's last committed offset

Question 24

An event arrives after the watermark passed the end of its window. What are the usual handling options?

Accepted Answer

Allowed lateness to update the result, or routing it to a side output

Answer

Halting the whole pipeline until an operator decides

Answer

Sending the event back to the producer to resend with a new time

Answer

Adding the event to the current window based on processing time

Question 25

In Kafka Streams, how is the state of an aggregation (like a per-user count) made fault-tolerant?

Accepted Answer

The local state store is backed up to a changelog topic in Kafka

Answer

State lives only in memory and restarts from zero after a crash

Answer

Every state update is written synchronously to a relational database

Answer

State is fully copied to all instances so restore is never needed

Question 26

What is the best operational practice for a DLQ?

Accepted Answer

Alert on arrivals, store the failure reason, and have tooling to redrive after a fix

Answer

Automatically purging the DLQ every night to prevent it filling up

Answer

Immediately and automatically looping DLQ messages back to the main queue

Answer

Ignoring the DLQ since its messages are unprocessable anyway

Question 27

In Kafka, what is the trade-off of using separate delayed retry topics (e.g. `orders-retry-1m`)?

Accepted Answer

The main partition is not blocked, but ordering for that key is lost

Answer

Ordering is fully kept, but the main partition stalls until the retry succeeds

Answer

Messages never reach the DLQ since retries are unlimited

Answer

It has no cost and is always better than in-place retry

Question 28

Why can a poison message be more dangerous in Kafka than in a traditional queue?

Accepted Answer

Because the consumer cannot advance past it in that partition until it is skipped (head-of-line blocking)

Answer

Because Kafka copies the bad message to all other partitions

Answer

Because Kafka automatically removes the consumer after the first error

Answer

Because Kafka messages cannot be moved to any other topic

Question 29

Why does a pull-based model (like a Kafka consumer) naturally handle backpressure better than push?

Accepted Answer

The consumer requests only what it can handle and the rest stays in the broker

Answer

The broker sends messages faster than in push mode

Answer

Pull-based does not need to store messages on disk

Answer

In pull-based, the producer pulls data directly from the consumer

Question 30

For a live price dashboard that users only watch, why might SSE be preferred over WebSocket?

Accepted Answer

It works over plain HTTP, has auto-reconnect, and plays nicer with proxies

Answer

SSE transfers binary data better than WebSocket

Answer

SSE offers bidirectional messaging with lower latency than WebSocket

Answer

SSE requires no open connections to be held on the server

Question 31

When designing a webhook delivery system for customers, which set of practices is essential?

Accepted Answer

Retries with backoff, a unique event id for dedup, and an HMAC signature on the payload

Answer

Single-shot delivery with no retries to avoid duplicates

Answer

Keeping a permanent WebSocket open with every customer's server

Answer

Sending the webhook synchronously within the user request and awaiting a reply

Question 32

Your webhook endpoint needs about 20 seconds per event and the sender times out after 10 seconds. What is the right fix?

Accepted Answer

Validate and enqueue the event, return `2xx` quickly, and process async

Answer

Ask the sender to raise its timeout to several minutes

Answer

Return `500` so the sender retries later

Answer

Parallelize processing within the request using more threads

Question 33

In a social feed design, what trade-off does fan-out on write have versus fan-out on read?

Accepted Answer

Feed reads are fast, but posts by users with many followers cost huge writes

Answer

Writes are cheap, but every feed read must merge posts from all followees

Answer

They cost the same and differ only in implementation

Answer

Fan-out on write is only usable in systems without a cache

Question 34

Why is the common AWS pattern 'SNS topic to multiple SQS queues' used for fan-out?

Accepted Answer

Each subscriber gets its own durable queue to consume and retry at its own pace

Answer

SNS alone stores messages forever and makes them replayable

Answer

SQS alone broadcasts each message to multiple independent consumers

Answer

This combination guarantees global ordering of all messages

Question 35

Your events only carry `{ orderId }` and 10 services call the Order API upon receiving them. What is the main problem?

Accepted Answer

Heavy load on the Order service and a runtime dependency that defeats decoupling

Answer

Events become too large and fill the broker's capacity

Answer

Event ordering within partitions becomes scrambled

Answer

Consumers become unable to ack the message

Question 36

What is the main cost of 'fat' events that carry an entity's full state?

Accepted Answer

Larger messages, more data exposure, and a broader schema contract to maintain

Answer

Consumers must call the source service for every event

Answer

Partition keys cannot be used for these events

Answer

These events can only be used with point-to-point queues

Question 37

Your consumer has `enable.auto.commit=true` and processes messages async in a thread pool. What is the risk?

Accepted Answer

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

Answer

Messages are always processed twice even without a crash

Answer

Kafka forbids async processing and disconnects the consumer

Answer

Auto-commit causes all partitions to go to a single consumer

Question 38

Billing and Shipping must both receive all `orders` events, and each runs several instances. How do you configure them?

Accepted Answer

Each service has its own consumer group, with its instances in that group

Answer

All instances of both services share one consumer group

Answer

Every instance of each service gets its own separate consumer group

Answer

A separate copy of the `orders` topic is created per service

Question 39

What components make up the lambda architecture?

Accepted Answer

A batch layer for accuracy, a speed layer for fresh data, and a serving layer

Answer

Only a single stream processor that processes all data once

Answer

A set of serverless functions invoked over HTTP

Answer

An OLTP database with a cache in front of it

Question 40

What is the core idea of the kappa architecture compared to lambda?

Accepted Answer

A single streaming path; reprocessing is done by replaying the log

Answer

Dropping stream processing and doing everything in hourly batches

Answer

Adding a third batch layer to validate speed-layer results

Answer

Storing events only in memory to reduce latency

Question 41

Kafka's exactly-once semantics are built on which capabilities?

Accepted Answer

An idempotent producer plus transactions committing outputs and offsets atomically

Answer

Raising the replication factor to 5 and disabling retries

Answer

Removing consumer groups and reading directly from partition leaders

Answer

Sending every message synchronously with `acks=0` for speed

Question 42

A consumer may receive `CustomerUpdated` version 5 before version 4 (e.g. due to retries). How do we avoid overwriting new data with old?

Accepted Answer

Store each entity's version and ignore events with an equal or lower version

Answer

Always apply the most recently received event without checks

Answer

Compare using the consumer's receive timestamp

Answer

Buffer messages forever until all versions arrive

Question 43

For autoscaling a queue's workers, which metric is usually better than CPU?

Accepted Answer

Queue depth or consumer lag (and age of the oldest message)

Answer

The number of incoming HTTP requests at the API gateway

Answer

The amount of free memory on the brokers

Answer

The number of topics defined in the cluster

Question 44

What kind of data is Kafka log compaction suited for?

Accepted Answer

Data where only the latest value per key matters, like user profiles

Answer

Click events that must each be kept for analytics

Answer

Audit logs from which no record may ever be removed

Answer

Keyless messages sent round-robin

Question 45

For payment events that must not be lost even if a broker fails, which Kafka configuration fits?

Accepted Answer

Replication factor 3, `min.insync.replicas=2`, and `acks=all` on the producer

Answer

Replication factor 1 and `acks=1` for the lowest possible latency

Answer

Replication factor 3 and `acks=0` so the producer never waits

Answer

Replication factor 2 and `min.insync.replicas=2` with `acks=1`

Question 46

Why do many teams distinguish internal domain events from public integration events?

Accepted Answer

So the internal model can change freely while only a stable, minimal contract is exposed

Answer

Because integration events must never be sent through a broker

Answer

Because domain events are always sync and integration events always async

Answer

Because only domain events support schema versioning

Question 47

You need to pass multi-hundred-MB video files between services via events. What pattern fits?

Accepted Answer

Claim check: store the file in object storage and send only a reference in the event

Answer

Raise the broker's `max.message.bytes` to one gigabyte

Answer

Split the file into thousands of small messages on the topic

Answer

Compress the file with gzip and send it directly in the message body

Question 48

Implementing request/reply over async messaging usually requires what?

Accepted Answer

A reply queue and a correlation id to match responses to requests

Answer

An open HTTP connection between sender and receiver throughout

Answer

Putting sender and receiver in the same consumer group

Answer

Using the same partition key for all requests

Question 49

Urgent payment jobs get stuck behind millions of reporting jobs in one queue. What is a good architectural fix?

Accepted Answer

Separate queues per priority class with dedicated consumers

Answer

Lowering every job's timeout so the queue drains faster

Answer

Merging all jobs into one large batch message

Answer

Dropping reporting jobs whenever the queue gets long

Question 50

A user request passes synchronously through 5 services in a chain, each 99.9% available. What is the overall availability roughly, and how does async help?

Accepted Answer

About 99.5%; making non-critical steps async removes them from the critical path

Answer

Still 99.9%; async only reduces latency

Answer

About 99.99%; a sync chain increases availability

Answer

About 95%; async does not help availability