Core Concepts on Advanced Beginner

Strategic Design

d8lzz1gpw@mozmail.com (kimbenji) — Tue, 13 Jan 2026 00:00:00 +0000

Target Audience: Architects and senior developers who want to understand the big picture of DDD Prerequisites: Have read Quick Start or understand basic DDD concepts Estimated Time: About 30 minutes Key Question: “How should we divide the system, and how should each part collaborate?”

Summary
4 core concepts of Strategic Design: Subdomain (classify business areas) -> Ubiquitous Language (define common language) -> Bounded Context (set model boundaries) -> Context Mapping (define collaboration between boundaries)

Strategic design is high-level design that decides how to divide and integrate complex domains. It is the starting point of DDD and the core activity that determines the overall system architecture.

Tactical Design

d8lzz1gpw@mozmail.com (kimbenji) — Tue, 13 Jan 2026 00:00:00 +0000

Target Audience: Backend developers who want to implement DDD building blocks in code Prerequisites: Read Strategic Design or understand Bounded Context concept Time Required: About 40 minutes Key Question: “What patterns should be used to implement domain models?”

Summary
Tactical Design Building Blocks: Entity(distinguished by identity) + Value Object(distinguished by value) → Aggregate(consistency boundary) + Repository(persistence) + Domain Service(domain logic) + Domain Event(event communication)

Tactical design consists of patterns for concretely implementing domain models. If strategic design draws the “big picture,” tactical design provides “specific implementation methods.”

Aggregate Deep Dive

d8lzz1gpw@mozmail.com (kimbenji) — Tue, 13 Jan 2026 00:00:00 +0000

Target Audience: Developers who understand Aggregate basics and need deep dive into design Prerequisites: Entity, Value Object concepts from Tactical Design Reading Time: About 25 minutes Key Question: “How do I determine Aggregate boundaries, and what is the appropriate size?”

Summary
Aggregate design core: Invariant-based boundary setting → Keep it small → Reference by ID → Use eventual consistency

Aggregate Deep Dive#

A deep dive into Aggregate design principles, transaction boundaries, and practical patterns.

Aggregate Practical Patterns

d8lzz1gpw@mozmail.com (kimbenji) — Tue, 13 Jan 2026 00:00:00 +0000

Target Audience: Developers who have learned Aggregate basics and want to learn practical patterns Prerequisites: Understanding core concepts from Aggregate Deep Dive Reading Time: About 30 minutes Key Question: “What patterns should I apply when implementing Aggregates?”

Summary
Practical patterns: Factory Method (creation) + Domain Event publishing + Optimistic Locking (concurrency) + Soft Delete (deletion)

Aggregate Practical Patterns#

Implementation patterns and decision guides for Aggregate design.

Common imports for examples in this page:

Domain Model Patterns

d8lzz1gpw@mozmail.com (kimbenji) — Tue, 17 Feb 2026 00:00:00 +0000

Target Audience: Backend developers who understand Tactical Design building blocks Prerequisites: Understanding of Entity, Value Object, Repository, Domain Service concepts Estimated Time: About 25-30 minutes Key Question: “How do you structure domain logic that is difficult to express with core building blocks alone?”

Summary
Core building blocks (Entity, Value Object, Repository, Domain Service, Factory) are the skeleton of a domain model. The patterns covered in this document are tools for systematically expressing business rules on top of that skeleton: Specification (condition checking) + Policy (calculation/decision) + Module (code organization) + Builder (complex creation) + Null Object (null safety)

You can implement a domain model with just the core building blocks of tactical design. However, real businesses have more complex requirements. Condition checks like “can this order be confirmed?”, policy decisions like “what percentage discount applies to VIP customers?”, and code organization spanning multiple modules — let us explore the auxiliary patterns that cleanly solve these problems.

Testing Strategy

d8lzz1gpw@mozmail.com (kimbenji) — Tue, 13 Jan 2026 00:00:00 +0000

Target Audience: Developers establishing testing strategies for DDD-based projects Prerequisites: Tactical Design building blocks, basic JUnit/Mockito usage Time Required: About 25 minutes Key Question: “How should tests be organized in DDD architecture?”

Summary
Testing Strategy Core: Unit Tests(domain model focused, most numerous) → Integration Tests(Repository, external integrations) → E2E Tests(critical scenarios only)

Systems applying Domain-Driven Design require a different testing strategy than typical CRUD applications. Since business logic is concentrated in domain models, tests should also be designed around the domain layer. This document explores testing strategies suitable for DDD architecture and specific implementation methods.

Anti-Patterns and Pitfalls

d8lzz1gpw@mozmail.com (kimbenji) — Tue, 13 Jan 2026 00:00:00 +0000

Target Audience: Developers who are applying or considering adopting DDD Prerequisites: Basic concepts from Quick Start and Tactical Design Reading Time: About 20 minutes Key Question: “What are the common mistakes when applying DDD, and how can they be avoided?”

Warning
The anti-patterns introduced in this document frequently occur in real projects. Check if your codebase exhibits these symptoms.

DDD (Domain-Driven Design) is a powerful design methodology, but if not applied correctly, it can only increase complexity. This document examines common DDD anti-patterns encountered in practice and their solutions. Understanding the symptoms of each anti-pattern and catching them early to correct is crucial.