Summary
Hexagonal Architecture - or more precisely: Ports & Adapters - is widely adopted across teams. Yet, its practical implementation often reveals limitations: unclear module structures, mixed models, and framework dependencies that undermine the original intent.
This Masterclass addresses exactly these challenges. Over two intensive days, the focus is on implementing hexagonal architecture in Java. The emphasis is on decisions that matter in real systems - beyond diagrams and introductory material.
For who?
This workshop is for Java developers and architects with an interest in DDD and structured architectural styles.
What you'll learn
We will work on questions such as:
- Which package and module structures hold up in practice?
- What does separating domain and persistence models actually mean - and when is it worth it?
- How far should framework independence go - and what trade-offs does it introduce?
- What distinguishes Hexagonal Architecture from Onion and Clean Architecture in everyday work?
- What internal structure makes sense within the application, even though the pattern itself does not prescribe one?
Learning Outcomes
The workshop is built around a continuous implementation example. Starting from a traditional layered architecture, we gradually evolve the system towards a hexagonal structure. Different implementation variants are deliberately compared, common misconceptions are made visible, and architectural decisions are evaluated against concrete change scenarios. Participants work continuously on code and implement the concepts using Java and common frameworks. The focus is not on the pattern itself, but on applying it in a way that holds up in real systems.
Prerequisites
Participants should have a solid Java knowledge, and a basic understanding of layered architectures.