Mastering DDD Tactical Design: Entities, Value Objects, Aggregates and More

Introduction

Following a previous discussion on strategic DDD, this piece explores the tactical side of Domain‑Driven Design (DDD), which provides concrete patterns for modeling rich business logic within the domain model.

Core Tactical Concepts

Entity

An entity is an object defined by its identity rather than its attributes; its state may change over time while the identity remains constant (e.g., a person remains the same even after a name change).

Value Object

A value object is immutable and defined solely by its value, lacking an identity (e.g., a color). Commands are a useful type of value object that represent actions the system must handle. Value objects should be preferred over primitive types for attributes that require validation, such as ensuring a quantity is non‑negative.

Aggregate and Aggregate Root

Aggregates group related entities and value objects to enforce business rules that span multiple entities, such as ensuring email uniqueness for new users. The aggregate root is the top‑level object through which all modifications to the aggregate must pass, and other aggregates may reference it only by its identifier.

Domain Event

Domain events capture significant occurrences within the domain and are handled by dedicated event handlers. Integration events may be distinguished to indicate whether they should be processed before or after a database transaction.

Supporting Patterns

Repository

Repositories encapsulate persistence operations for aggregate roots, allowing the domain model to retrieve and store aggregates without exposing infrastructure details. Modern ORMs often provide built‑in support for this pattern.

Application Service

Application services act as a thin orchestration layer that routes external commands to the domain model, injecting infrastructure concerns (e.g., repository implementations) and invoking public methods on aggregates.

Domain Service

When business logic spans multiple aggregates, a domain service provides the coordination logic inside the domain layer, similar to an application service but without crossing the domain boundary.

Example

An Order aggregate root might expose a Confirm() method that validates the order contains at least one order line, checks that its status is “Pending”, updates the status to “Confirmed”, and raises an OrderConfirmed domain event. Other aggregates can react to this event to trigger side effects such as shipping.

Conclusion

Understanding and applying these tactical patterns—entities, value objects, aggregates, domain events, repositories, application services, and domain services—enables developers to keep business rules centralized, expressive, and independent of external layers, leading to clearer and more maintainable domain models.