Mid Microservices Interview Questions

Event-driven architecture means services communicate via published events instead of synchronous calls.

This improves loose coupling, scalability, and resilience. Events can be domain events, integration events, or system events.

Request-driven: Services call each other synchronously using HTTP/gRPC.

Event-driven: Services publish/subscribe to events asynchronously.

Event-driven provides higher decoupling and responsiveness.

Message brokers handle asynchronous communication.

Examples: Kafka, RabbitMQ, AWS SQS/SNS.

They ensure durability, ordering, and delivery guarantees.

Pub/Sub: Publisher sends events to multiple subscribers.

Message Queue: Messages are consumed by one or more consumers.

Both enable async processing and load leveling.

Kafka is a distributed event streaming platform.

Supports partitioning, replication, high throughput, and fault tolerance.

Use acknowledgments, retries, DLQs, idempotent consumers, and transactional outbox pattern.

Events are written to an outbox table inside the same DB transaction.

A background process publishes them to the message broker to guarantee consistency.

Through horizontal scaling, partitioning/sharding, and stateless services.

CQRS: Separates read/write models.

Event sourcing: Stores state as events.

Together, they boost performance, auditability, and resilience.

Eliminates blocking, increases throughput, smooths spikes, and makes the system resilient.

Data converges over time instead of instantly.

Enabled by sagas, compensating actions, and idempotent operations.

Backpressure occurs when consumers can't keep up with event producers.

Solved via throttling, buffering, or rate limiting.

DLQs store messages that fail processing.

Used for debugging and preventing message loss.

Using CDC, event streams, materialized views, and distributed caching.

Orchestration: Central controller directs saga.

Choreography: Services react to each other's events.

Monitor throughput, consumer lag, processing errors using logs, metrics, tracing, and dashboards.

Non-blocking async programming using data streams.

Frameworks: Reactor, RxJava, Spring WebFlux.

Horizontal: Add more instances (preferred).

Vertical: Add more CPU/RAM to a single instance (limited).

Kafka ensures ordering per partition; RabbitMQ ensures FIFO per queue.

Idempotent consumers ensure consistent processing.

Use async communication, caching, stateless services, monitoring, circuit breakers, retries, and backpressure handling.