Aggregates and entities in Microservices - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Aggregate Boundaries

In a microservices system, which statement best describes the role of an aggregate?

A An aggregate is a cluster of domain objects that can be treated as a single unit for data changes and consistency.

B An aggregate is a single database table that stores all entities in the system.

C An aggregate is a microservice responsible for handling all user requests directly.

D An aggregate is a UI component that displays multiple entities on the screen.

💡 Hint

Think about how data consistency is maintained within a group of related objects.

An aggregate groups related entities and value objects to enforce consistency rules within its boundary. It acts as a single unit for updates.

❓ Architecture

intermediate

Entity Identity in Aggregates

Which option correctly explains how entities within an aggregate are identified?

A Entities inside an aggregate share the same global identifier as the aggregate root.

B Entities inside an aggregate are identified by the microservice name and the aggregate root's ID combined.

C Entities inside an aggregate do not have identifiers and are identified only by their attributes.

D Each entity inside an aggregate has its own unique identifier, but only the aggregate root's ID is exposed externally.

💡 Hint

Consider which entity is responsible for external references.

Entities within an aggregate have unique IDs internally, but only the aggregate root's ID is used outside to maintain encapsulation.

❓ scaling

advanced

Scaling Aggregates in Microservices

You have a microservice managing orders as aggregates. Each order aggregate contains multiple line item entities. What is the best approach to scale this microservice when order volume grows rapidly?

A Store line items in a separate database and query them on demand without transactional consistency.

B Split the order aggregate into separate microservices for order header and line items to scale independently.

C Keep the order aggregate as one unit and scale the microservice horizontally by adding more instances.

D Cache all order aggregates in memory to avoid database calls and improve performance.

💡 Hint

Think about aggregate boundaries and transactional consistency.

Aggregates should remain consistent units. Scaling by adding instances horizontally preserves aggregate boundaries and consistency.

❓ tradeoff

advanced

Tradeoffs in Aggregate Size

What is a key tradeoff when designing very large aggregates containing many entities?

A Large aggregates reduce complexity by grouping all entities but make it impossible to maintain consistency.

B Large aggregates improve performance by reducing the number of database calls but increase the risk of contention and slower updates.

C Large aggregates always improve scalability because they reduce the number of microservices needed.

D Large aggregates eliminate the need for aggregate roots and simplify entity management.

💡 Hint

Consider how aggregate size affects database transactions and concurrency.

Large aggregates reduce calls but can cause contention and slow updates due to locking and transaction size.

❓ estimation

expert

Estimating Aggregate Load Capacity

A microservice manages a 'Customer' aggregate with 5 entities inside. Each aggregate update takes 100ms on average. The system must handle 1000 updates per second. What is the minimum number of microservice instances needed to meet this load without queuing?

A At least 100 instances, because each instance can handle 10 updates per second (1000ms / 100ms).

B At least 10 instances, because 1000 updates * 100ms = 100 seconds total processing time per second.

C At least 5 instances, because there are 5 entities per aggregate and each takes 100ms.

D At least 20 instances, because 1000 updates / 50 updates per instance per second = 20.

💡 Hint

Calculate how many updates one instance can handle per second, then divide total load by that.

Each update takes 100ms, so one instance can handle 10 updates per second (1000ms / 100ms). To handle 1000 updates, 1000/10 = 100 instances are needed.

Practice

1. In microservices, what is the main role of an aggregate root entity?

easy

A. It acts as a database for all microservices.

B. It stores unrelated data from different services.

C. It handles user interface rendering.

D. It controls all changes within the aggregate to keep data consistent.

Solution

1. Step 1: Understand aggregate root responsibility

   The aggregate root is the main entity that manages all changes inside its aggregate to ensure consistency.

2. Step 2: Eliminate unrelated options

   Options A, B, and D describe roles unrelated to aggregate roots in microservices.

3. Final Answer:

   It controls all changes within the aggregate to keep data consistent. -> Option D

4. Quick Check:

   Aggregate root controls changes = C [OK]

Hint: Aggregate root manages changes inside its group [OK]

Common Mistakes:

• Confusing aggregate root with database or UI component
• Thinking aggregate root stores unrelated data
• Assuming aggregate root handles external service data

2. Which of the following correctly represents an aggregate in a microservice domain model?

easy

A. Order (root) -> OrderItems (entities) -> PaymentDetails (entity)

B. OrderItems (root) -> Order -> PaymentDetails

C. PaymentDetails (root) -> Order -> OrderItems

D. Order -> PaymentDetails -> OrderItems (all roots)

Solution

1. Step 1: Identify the aggregate root

   In an order system, the Order is the root entity controlling related entities like OrderItems and PaymentDetails.

2. Step 2: Check the hierarchy correctness

   Order (root) -> OrderItems (entities) -> PaymentDetails (entity) shows Order as root with related entities under it, which is correct. Other options misplace roots or treat all as roots.

3. Final Answer:

   Order (root) -> OrderItems (entities) -> PaymentDetails (entity) -> Option A

4. Quick Check:

   Root entity is Order controlling others = A [OK]

Hint: Root entity leads related entities in aggregate [OK]

Common Mistakes:

• Assigning wrong entity as root
• Treating all entities as roots
• Ignoring aggregate boundaries

3. Given the aggregate root Customer with entities Address and Order, which operation should only be performed through Customer?

medium

A. Deleting Order independently from Customer

B. Directly updating an Order without Customer involvement

C. Adding a new Address via the Customer aggregate root

D. Querying Order data directly from the database

Solution

1. Step 1: Understand aggregate root control

   The aggregate root Customer controls all changes to its entities like Address and Order to maintain consistency.

2. Step 2: Identify allowed operations

   Adding a new Address should go through Customer. Direct updates or deletes bypassing root break consistency.

3. Final Answer:

   Adding a new Address via the Customer aggregate root -> Option C

4. Quick Check:

   Changes go through root entity = A [OK]

Hint: All changes pass through aggregate root only [OK]

Common Mistakes:

• Updating entities directly without root
• Deleting entities independently
• Confusing querying with updating

4. You have a microservice with an aggregate root Invoice and entities LineItem. The code allows direct modification of LineItem without Invoice. What is the main problem?

medium

A. Performance will improve due to direct access.

B. Data consistency may break because changes bypass the aggregate root.

C. It will reduce network calls between services.

D. It simplifies the codebase without side effects.

Solution

1. Step 1: Identify aggregate root role in consistency

   The aggregate root Invoice ensures all changes to LineItem are consistent and valid.

2. Step 2: Analyze direct modification impact

   Directly modifying LineItem bypasses Invoice, risking inconsistent or invalid data.

3. Final Answer:

   Data consistency may break because changes bypass the aggregate root. -> Option B

4. Quick Check:

   Bypassing root risks consistency = B [OK]

Hint: Bypass root risks data consistency [OK]

Common Mistakes:

• Assuming direct access improves design
• Ignoring consistency importance
• Confusing performance with correctness

5. You design a microservice for a shopping cart system. The cart is an aggregate root with entities like CartItem and Discount. Which design choice best ensures data consistency and scalability?

hard

A. Make Cart the aggregate root controlling all CartItem and Discount changes.

B. Use a single database table for Cart, CartItem, and Discount without aggregates.

C. Store CartItem and Discount in separate microservices with no coordination.

D. Allow CartItem and Discount to be updated independently without Cart involvement.

Solution

1. Step 1: Apply aggregate root principle for consistency

   Cart as aggregate root should control all changes to CartItem and Discount to keep data consistent.

2. Step 2: Consider scalability and design best practices

   Centralizing changes through Cart allows easier management and scaling of the microservice without data conflicts.

3. Step 3: Evaluate other options

   Options A and C risk inconsistency; B ignores aggregate design and can cause complexity.

4. Final Answer:

   Make Cart the aggregate root controlling all CartItem and Discount changes. -> Option A

5. Quick Check:

   Aggregate root controls changes for consistency and scale = D [OK]

Hint: Aggregate root controls related entities for consistency and scale [OK]

Common Mistakes:

• Allowing independent updates breaking consistency
• Splitting tightly coupled entities into separate services
• Ignoring aggregate design principles