clean-architecture

Organize a modular monolith by isolating each bounded context as a complete vertical slice with its own domain logic, repositories, and entities. Enforce strict boundaries so contexts never import domain code from one another, communicating only through application services. This prevents coupling and keeps each context independently testable and maintainable.

A shared kernel should contain only minimal, universal infrastructure concepts—typically utilities, base types, and cross-cutting concerns like logging or error handling. Avoid placing domain entities, business logic, or repositories in the shared kernel. This constraint prevents the shared core from becoming a dumping ground that couples all contexts together.

Prevent cross-context dependencies by establishing file structure rules that make imports across context boundaries syntactically or organizationally difficult. Use application services as the only communication channel between contexts rather than direct domain imports. Regular architecture checks ensure no context pulls domain logic from another.

Use a modular monolith with bounded contexts when you need isolated domain logic and clear organizational structure without the operational complexity of microservices. It suits teams building backend systems where vertical scalability and simpler deployment outweigh the need for independent service scaling or technology diversity.

Design use cases within a bounded context by keeping them focused on that context's specific responsibility and domain. Use the context's entities, repositories, and value objects; never pull domain objects from other contexts. Apply principles like KISS and YAGNI to keep use-case logic simple and avoid unnecessary abstraction.

Duplication Over Coupling means it is better to duplicate a simple concept across contexts than to share domain code to avoid repetition. This preserves context independence and prevents tight coupling through shared libraries. Small, localized duplication is easier to manage than the complexity of cross-context dependencies.