Software Design & Architecture
Design patterns are shorthand for 'this problem has been solved before, and here is what the solution ended up looking like'. They are not a checklist to apply, and they are not a substitute for thinking — but knowing them lets you communicate a design in three words that would otherwise take three paragraphs. This track covers the classical Gang-of-Four patterns in Java, plus the architectural patterns (hexagonal, DDD, event-driven) that show up in real production systems above the class-level.
What this track covers
The Gang-of-Four classics that actually earn their keep (Strategy, Factory, Builder, Observer, Decorator, Adapter), plus the architecture-level patterns that shape whole services — hexagonal / ports-and-adapters, DDD tactical patterns (aggregate, repository, domain event), modular monolith, CQRS and event sourcing.
Who this is for
Mid-level engineers who are being asked to make design decisions, not just implement them, and senior engineers who need a shared vocabulary for architecture reviews.
Prerequisites
- Solid grasp of OOP fundamentals — classes, interfaces, polymorphism
- Comfortable with the SOLID principles (from the Software Engineering Fundamentals track)
- Have worked on at least one codebase where a wrong design decision cost you a rewrite
Recommended learning order
// beginner
Read the Java design patterns guide as a single sitting. Then look for one pattern per week in your own codebase — you will find Strategy and Factory almost immediately.
// intermediate
Move up to architectural patterns: hexagonal architecture, DDD tactical patterns, modular monolith. These change how you organise packages, not just how you write a class.
// advanced
CQRS, event sourcing, saga orchestration, and the harder question of when NOT to use them. The advanced material on this site treats these as tools that solve specific problems, not defaults.
Common mistakes to avoid
- Applying a pattern because it has a name, not because it solves the problem in front of you
- Building an entire hexagonal / DDD scaffolding for a CRUD service that will never grow beyond three tables
- Confusing CQRS with 'two databases' and missing the eventual-consistency and read-model rebuild story
- Using event sourcing because it is fashionable and inheriting an unfixable schema evolution problem
- Refusing to use inheritance anywhere because 'composition over inheritance' — the principle is a preference, not a ban
Career relevance
Architectural pattern fluency is what distinguishes a strong mid-level engineer from a staff-level candidate. It also becomes essential in any hiring loop that includes an architecture round.
Featured tutorials in this track
The Outbox Pattern — Reliable Event Publishing in Microservices
Solve the dual-write problem with the transactional Outbox pattern. Production guide using Spring Boot, JPA, PostgreSQL, Kafka and Debezium with idempotent consumers and operational best practices.
CQRS Pattern in Spring Boot — Separating Reads and Writes for Scale
A complete production guide to the CQRS pattern in Spring Boot — write models, query models, event projections, Kafka integration, consistency trade-offs and real-world scaling patterns.
Domain-Driven Design (DDD) with Spring Boot — Practical Guide for Real Systems
A no-nonsense guide to Domain-Driven Design with Spring Boot — bounded contexts, aggregates, value objects, domain events and how to apply DDD without ceremony.
Hexagonal Architecture with Spring Boot — Build Clean, Maintainable Applications
A practical guide to Ports and Adapters (Hexagonal Architecture) in Spring Boot — isolate your domain, make your code testable, and keep infrastructure swappable.
Modular Monolith Architecture in Spring Boot — The Right Way to Scale a Monolith
Why modern teams are returning to modular monoliths — module boundaries, package-by-feature, internal events and a clean migration path to microservices in Spring Boot.
Essential Software Design Principles Every Developer Should Know
A practical overview of the design principles that separate junior and senior engineers — DRY, KISS, YAGNI, SOLID, separation of concerns and more.
Java Design Patterns — A Field Guide for Working Backend Engineers
Which Gang-of-Four pattern to reach for, when, and when to skip patterns entirely. A practical reference for Java backend services.