account_balance DDD - Entities Pattern

In the world of software development, Domain-Driven Design (DDD) has become a go-to tool for many developers. One of the fundamental components of DDD are Entities.

The Entities Pattern is a software design pattern that can be used to represent entities in a software system. This pattern is based on the concept of the domain model, which is a representation of the key concepts and relationships within the business domain. The entities pattern can be used to represent entities in a software system, such as people, places or things.

What are Entities?

In the context of DDD, an Entity is an object that has a unique identity that distinguishes it from others. Unlike Value Objects (which are defined by their state), Entities are defined by their identity, not their state. This means that even if the state of the Entity changes over time, it remains the same Entity due to its unique identity.

Why are Entities Important?

Entities are the core of the application we’re building. They represent key concepts in our domain. For example, in an e-commerce application, entities might include users, products, orders, etc. Each of these entities has a unique identity - one product is different from another product due to its unique identity, even if both products have the same characteristics.

How Do We Use Entities?

When using DDD, we tend to encapsulate business logic within the entities. This means the entity doesn’t just hold data; it also holds behaviors. These behaviors are tightly coupled with the state of the entity.

For example, we might have a User entity that has a changePassword() method. This method would change the state of the entity (the user’s password), but it would also contain business logic (e.g., checking that the new password complies with security policies).


Entities are a fundamental part of Domain-Driven Design, providing a richly behavioral representation of our domain concepts. Their unique identity and the coupling of state and behavior enable us to build more robust and understandable applications.

As developers, it’s vital to understand this pattern and how to effectively apply it to yield the best results in our code.