CQRS pattern in Microservices - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding CQRS Command and Query Separation

In the CQRS pattern, what is the primary reason for separating commands and queries into different models?

A To optimize read and write operations independently for better performance and scalability

B To ensure all data is stored in a single database for consistency

C To combine read and write logic into one service for simplicity

D To avoid using any caching mechanisms in the system

💡 Hint

Think about how separating responsibilities can help improve system efficiency.

CQRS separates commands (writes) and queries (reads) so each can be optimized independently, improving performance and scalability.

❓ Architecture

intermediate

CQRS Architecture Components

Which component in a CQRS architecture is responsible for handling commands and updating the write database?

A Read Model

B Query Handler

C Command Handler

D Event Store

💡 Hint

Commands change data, so which component processes these changes?

The Command Handler processes commands and updates the write database or triggers events.

❓ scaling

advanced

Scaling CQRS Read and Write Models

In a high-traffic system using CQRS, which scaling strategy best improves read performance without affecting write throughput?

A Disable asynchronous event propagation to speed up writes

B Scale out the read model by adding more read replicas and caching layers

C Use a single database for both reads and writes to reduce complexity

D Scale out the write model by adding more command handlers

💡 Hint

Think about how to handle many read requests efficiently without slowing down writes.

Scaling out the read model with replicas and caching improves read performance independently, keeping writes unaffected.

❓ tradeoff

advanced

Tradeoffs of Eventual Consistency in CQRS

What is a common tradeoff when using eventual consistency between the write and read models in CQRS?

A Read data may be temporarily stale, causing slight delays in reflecting recent writes

B Write operations become slower due to synchronous updates to the read model

C The system loses the ability to scale reads independently

D Commands and queries must be handled by the same service

💡 Hint

Consider what happens when updates take time to appear in the read model.

Eventual consistency means the read model updates asynchronously, so reads might show old data briefly.

❓ estimation

expert

Estimating Capacity for CQRS Read Model

A CQRS system handles 10,000 write commands per minute and 96,000 read queries per minute. If each read query requires 5ms processing time on average, how many read replicas are needed to handle the load with 80% CPU utilization per replica?

A At least 7 replicas

B At least 12 replicas

C At least 15 replicas

D At least 10 replicas

💡 Hint

Calculate total processing time per minute and divide by capacity per replica.

Total read processing time per minute = 96,000 * 5 ms = 480,000 ms = 480 seconds. Each replica can process 60 * 0.8 = 48 seconds of CPU time per minute. Number of replicas = 480 / 48 = 10.