Domain-Driven Design Basics
DDD is a set of modeling tools for the hardest part of software: deciding what the domain is and where boundaries between concepts live. This video distills the essential ideas — the ubiquitous language shared with domain experts, bounded contexts as hard boundaries, and aggregates as consistency units — and shows how they translate into code structure.
Topics covered:
- The ubiquitous language: one vocabulary for code, meetings, and docs
- Bounded contexts: why "Order" means different things in sales and shipping
- Context mapping: integrating contexts through translation layers
- Entities vs. value objects: identity matters or it doesn't
- Aggregates: the consistency boundary and the aggregate root as its gatekeeper
- Domain events: facts the domain emits that other contexts consume
- Repositories and application services: where persistence and use cases live
- How much DDD you need: tactical patterns for one team, strategic for many
Related articles
Hexagonal Architecture: Ports, Adapters, and Where the Boundary Really Goes
Hexagonal architecture isolates your domain behind ports and adapters — here is where the boundary actually belongs, what it buys you in tests, and when it is pure ceremony.
The Law of Demeter in Practice
Message chains, the law of diminishing knowledge, and why 'don't talk to strangers' prevents the most brittle code you'll ever write.
Dependency Injection and Composition Roots: Why Containers Exist
Dependency injection moves construction out of classes and into a composition root — how constructor injection, lifetimes, and DI containers actually work, and why service locator is a trap.
More in Software Architecture
The Strangler Fig Pattern
How to replace a legacy system without a rewrite — routing by path, strangling features incrementally, and keeping both systems honest.
DetailsService Mesh Explained
What a service mesh actually does — sidecars, mTLS, traffic routing, and observability — and the network plumbing it takes off your plate.
DetailsFeature Flags in Practice
How feature flags work end to end — evaluation at runtime, kill switches, and canary rollouts — plus the operational discipline they demand.
DetailsThe Saga Pattern Explained
How distributed transactions work without distributed locks — saga steps, compensating actions, and the orchestration vs. choreography split.
DetailsCQRS Explained
Command query responsibility segregation — separate read and write models, why they diverge, and what you actually gain from the split.
DetailsAPI Gateway Patterns
What an API gateway actually does — routing, auth, rate limiting, and aggregation — and which patterns matter for your traffic.
DetailsHexagonal Architecture, Visualized
Ports and adapters in one diagram — how hexagonal architecture keeps business logic independent of databases, HTTP, and everything external.
DetailsEvent-Driven Architecture Explained
How event-driven systems work — events, topics, and consumers — and what the broker actually guarantees in a distributed system.
DetailsMicroservices vs. Monolith
The honest engineering comparison — deployment boundaries, data ownership, failure domains, and the real costs of splitting a system.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.