Domain-Driven Design basics in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Bounded Context

In Domain-Driven Design, what best describes a Bounded Context?

A A clearly defined boundary within which a particular domain model applies and has consistent meaning.

B A database schema shared by all parts of the system to ensure data consistency.

C A user interface component that handles all user interactions for the domain.

D A network boundary that separates microservices physically.

💡 Hint

Think about where a domain model's rules and language stay consistent.

A Bounded Context defines a clear boundary where a specific domain model is valid and consistent. It helps avoid confusion when different parts of a system use the same terms differently.

❓ Architecture

intermediate

Identifying Aggregates

Which of the following best represents an Aggregate in Domain-Driven Design?

A A UI form that collects user input for multiple entities.

B A database table that stores all entities of a domain.

C A cluster of domain objects treated as a single unit for data changes, with one root entity controlling access.

D A microservice that handles all domain logic.

💡 Hint

Think about grouping domain objects to maintain consistency.

An Aggregate is a group of related domain objects that are treated as a single unit for data changes. It has a root entity that controls all access to the group to maintain consistency.

❓ scaling

advanced

Scaling with Bounded Contexts

When scaling a large system using Domain-Driven Design, what is the best practice regarding Bounded Contexts?

A Split the system into multiple Bounded Contexts that can be developed and deployed independently.

B Combine all domain models into one large Bounded Context to reduce communication overhead.

C Use Bounded Contexts only for UI components, not for backend services.

D Ignore Bounded Contexts and focus on database normalization for scaling.

💡 Hint

Think about how to reduce complexity and allow teams to work independently.

Splitting a large system into multiple Bounded Contexts allows teams to work independently, reduces complexity, and enables independent deployment and scaling.

❓ tradeoff

advanced

Tradeoffs in Using Entities vs Value Objects

In Domain-Driven Design, what is a key tradeoff when choosing between Entities and Value Objects?

A Entities are used only in UI layers; Value Objects only in database layers.

B Entities have identity and lifecycle but add complexity; Value Objects are simpler but immutable and lack identity.

C Entities cannot be persisted; Value Objects must be stored in separate tables.

D Entities are always immutable; Value Objects always have a unique ID.

💡 Hint

Consider identity and mutability differences.

Entities have a unique identity and lifecycle, which adds complexity in tracking changes. Value Objects are simpler, immutable, and identified by their attributes rather than identity.

❓ estimation

expert

Estimating Capacity for Event-Driven Domain Model

You design a system using Domain-Driven Design with multiple Bounded Contexts communicating via events. If each context emits 1000 events per second and there are 5 contexts, what is the minimum event processing capacity your event bus must support to avoid bottlenecks?

A At least 10000 events per second

B At least 1000 events per second

C At least 2000 events per second

D At least 5000 events per second

💡 Hint

Multiply events per context by number of contexts.

The event bus must handle the total events emitted by all contexts combined, which is 5 contexts * 1000 events/sec = 5000 events/sec minimum capacity.

Practice

1. What is the main purpose of Domain-Driven Design (DDD)?

easy

A. To model software closely around real business concepts

B. To optimize database queries for performance

C. To create user interfaces quickly

D. To write code without any documentation

Solution

1. Step 1: Understand the goal of DDD

   DDD focuses on aligning software design with the core business domain and its logic.

2. Step 2: Compare options with DDD purpose

   Only To model software closely around real business concepts describes modeling software around business concepts, which is the essence of DDD.

3. Final Answer:

   To model software closely around real business concepts -> Option A

4. Quick Check:

   DDD = model software on business concepts [OK]

Hint: DDD = software models business ideas clearly [OK]

Common Mistakes:

• Confusing DDD with UI or database optimization
• Thinking DDD is about coding speed only
• Ignoring the business domain focus

2. Which of the following is the correct definition of an Entity in DDD?

easy

A. An object defined only by its attributes and no identity

B. A database table storing raw data

C. An object with a unique identity that persists over time

D. A service that performs calculations without state

Solution

1. Step 1: Recall Entity characteristics in DDD

   Entities have a unique identity that remains constant even if attributes change.

2. Step 2: Match definitions with Entity concept

   An object with a unique identity that persists over time correctly states that Entities have unique identity and persistence over time.

3. Final Answer:

   An object with a unique identity that persists over time -> Option C

4. Quick Check:

   Entity = unique identity object [OK]

Hint: Entity always has unique identity, not just attributes [OK]

Common Mistakes:

• Confusing Entities with Value Objects
• Thinking Entities have no identity
• Mixing Entities with Services

3. Consider this simplified DDD code snippet in Python:

class Order:
    def __init__(self, order_id, items):
        self.order_id = order_id
        self.items = items

order1 = Order(1, ['apple', 'banana'])
order2 = Order(1, ['apple', 'banana'])

print(order1 == order2)

What will be the output?

medium

A. True

B. False

C. SyntaxError

D. None

Solution

1. Step 1: Understand default equality in Python classes

   By default, Python compares object references, so two different instances with same data are not equal.

2. Step 2: Analyze the code output

   order1 and order2 are different objects with same data, so order1 == order2 returns False.

3. Final Answer:

   False -> Option B

4. Quick Check:

   Default object equality compares references = False [OK]

Hint: Default == compares object identity, not data [OK]

Common Mistakes:

• Assuming == compares data automatically
• Expecting True because attributes match
• Confusing syntax error with logic error

4. In a DDD model, a Value Object should be immutable. Which of the following code snippets violates this principle?

medium

A. class Money:
def __init__(self, amount, currency):
self.amount = amount
self.currency = currency

B. class Money:
def __init__(self, amount, currency):
self._amount = amount
self._currency = currency

C. class Money:
def __init__(self, amount, currency):
self._amount = amount
self._currency = currency
@property
def amount(self):
return self._amount

D. class Money:
def __init__(self, amount, currency):
self.amount = amount
self.currency = currency
def change_amount(self, new_amount):
self.amount = new_amount

Solution

1. Step 1: Recall immutability in Value Objects

   Value Objects should not allow changes after creation to keep consistency.

2. Step 2: Identify mutable code

   class Money: def __init__(self, amount, currency): self.amount = amount self.currency = currency def change_amount(self, new_amount): self.amount = new_amount has a method that changes the amount, violating immutability.

3. Final Answer:

   Code with method changing amount violates immutability -> Option D

4. Quick Check:

   Value Object must be immutable = no setters [OK]

Hint: Value Objects cannot change state after creation [OK]

Common Mistakes:

• Allowing setters or methods that modify attributes
• Confusing immutability with read-only properties only
• Ignoring methods that change internal state

5. You are designing a DDD model for an online store. Which of the following best represents an Aggregate?

hard

A. An Order object that contains multiple OrderItems and enforces business rules

B. A single Product object with price and description

C. A database table storing customer addresses

D. A utility service that calculates discounts

Solution

1. Step 1: Understand Aggregate in DDD

   An Aggregate is a cluster of related objects treated as a single unit with a root entity controlling consistency.

2. Step 2: Match options with Aggregate concept

   An Order object that contains multiple OrderItems and enforces business rules describes an Order with multiple OrderItems and business rules, fitting Aggregate definition.

3. Final Answer:

   An Order object containing multiple OrderItems and enforcing business rules -> Option A

4. Quick Check:

   Aggregate = root entity + related objects [OK]

Hint: Aggregate = root entity plus related objects as one unit [OK]

Common Mistakes:

• Confusing single entities with aggregates
• Thinking utility services are aggregates
• Mixing database tables with domain aggregates