Designing systems
Software Architecture in Go
Code that compiles is easy; code that stays changeable for years is architecture. This track covers the ideas that keep a Go codebase coherent as it grows — Domain-Driven Design and bounded contexts, aggregates and repositories, hexagonal/clean architecture, an idiomatic project layout, and knowing when a modular monolith should become microservices.
Mark a topic “learned” on its page and watch the bars fill.
Skill map
Learned nodes light up — the glowing one is your next step. Click any node to jump in.
Principles & Modeling
How to shape a system — modeling the domain with DDD, aggregates and repositories, and keeping business logic clean with ports & adapters.
Modeling software around the business — the ubiquitous language, bounded contexts, entities vs value objects, and when DDD's complexity pays off (and when it doesn't).
✦ Complete · ⏱ 5 min 2 · Intermediate Aggregates & RepositoriesClustering entities behind an aggregate root that guards invariants, and the repository interface that loads/saves whole aggregates — with persistence ignorance, demonstrated in runnable Go.
✦ Complete · ⏱ 5 min 3 · Intermediate Hexagonal & Clean ArchitecturePorts & adapters and the dependency rule — keeping the domain free of I/O so the database, HTTP, and queues are swappable details. Demonstrated with Go interfaces.
✦ Complete · ⏱ 4 minStructure & Boundaries
Where the lines go — an idiomatic Go project layout, and the modular-monolith-vs-microservices decision and how to evolve between them.
The architecture lens on Go repo structure — organizing by feature/domain (not technical layer) so packages map to bounded contexts, and where the domain↔infrastructure seam goes on disk.
✦ Complete · ⏱ 4 min 5 · Intermediate Modular Monolith vs MicroservicesWhen to keep one deployable with clean internal module boundaries vs splitting into services — the real trade-offs, the distributed-monolith anti-pattern, and the strangler-fig path between them.
✦ Complete · ⏱ 5 min 6 · Intermediate Architecture Patterns (Styles)A field guide to the macro architecture styles — layered, event-driven, microkernel/plugin, microservices, and space-based — what each optimizes for, and how to choose by trade-offs instead of fashion.
✦ Complete · ⏱ 6 min🐹 Architecture is about change, not diagrams
The point of good architecture isn't a pretty diagram — it's that the next change is cheap and safe. Go's small interfaces, explicit dependencies, and lack of magic make clean boundaries natural: depend on interfaces, keep the domain free of I/O, and let the compiler enforce the lines. Start simple (a well-structured monolith) and add structure only when a real force — a team, a scaling need — demands it.