Ports and Adapters in Scala

Categories: Scala Domain Driven Design Coaching Hexagonal Architecture Software Architecture Ports and Adapters Architecture Advanced Scala

Course Length: 3 Days

Build clarity and confidence in your architecture with “Ports and Adapters with Scala” coaching. Each coaching session starts with a presentation on what Ports and Adapters are and how they are constructed. Then we will build an application from scratch to solidify the fundamentals and demonstrate how everything fits together.

This coaching program helps Scala teams strengthen their architecture by applying Hexagonal (Ports and Adapters) principles in a practical, code-focused way.

Each session begins with a brief presentation to establish a shared understanding, covering domain-driven design concepts, application services, and adapter structures. From there, we work directly with your codebase (or through focused labs) to identify coupling issues, clarify responsibilities, and introduce modern Scala techniques that reinforce clean design, Algebraic Data Types, Higher Kinded Types, pattern matching, and more.

By the end, your team will have:

A clearer understanding of the architectural boundaries between domain, application, and infrastructure.
Refactoring strategies that improve testability and maintainability.
Practical experience applying modern Scala language features to support a robust architecture.

This is not just a lecture—it’s hands-on architectural coaching built around your real-world challenges.

Day Topics and Activities

Day	Topics and Activities
Day 1 – Foundations and Design	Module Layouts for a Full Scala Application – Establish project structure with clear module boundaries and testing harnesses, including end-to-end tests using Testcontainers. First Application in Ports and Adapters – Build a small web feature to experience adapter wiring in action. DDD Strategic Design – Explore Ubiquitous Language and Bounded Contexts. Behavior-Driven Development (BDD) – Translate stakeholder requirements into executable tests that guide your application. DDD Tactical Design – Apply Value Objects, Aggregates, Application Services, Domain Events, and Domain Services.
Day 2 – Integration and Architecture	Acceptance Tests in Action – Implement behavior through Ports and Adapters using DDD tactical patterns. Input Adapters – Connect your domain to the web layer with a clean controller design using Input Ports, Scala `sealed` types, and Command/Result strategies. Output Adapters – Integrate with databases, applying Testcontainers for authentic integration testing. Rapid Development Practices – Establish consistent, repeatable patterns that accelerate team development. Architectural Patterns in Context – Discuss CQRS, the Outbox Pattern, and their role in resilient systems. Monoliths, Modular Monoliths, and Microservices – Learn how to divide, deliver, and maintain your application as it evolves.
Day 3 – Refactoring and Coaching	Refactoring Techniques – Use modern tooling to safely restructure complex code and improve architecture. Live Coaching Session – Scratch Refactoring – Work from a dedicated branch of your own project and perform guided refactoring using Scratch Refactoring techniques (from Michael Feathers’ Working Effectively with Legacy Code). You’ll commit your changes for review and discussion—but won’t merge them—creating a safe space for experimentation, feedback, and deep learning.

Day 1 – Foundations and Design

Module Layouts for a Full Scala Application – Establish project structure with clear module boundaries and testing harnesses, including end-to-end tests using Testcontainers.
First Application in Ports and Adapters – Build a small web feature to experience adapter wiring in action.
DDD Strategic Design – Explore Ubiquitous Language and Bounded Contexts.
Behavior-Driven Development (BDD) – Translate stakeholder requirements into executable tests that guide your application.
DDD Tactical Design – Apply Value Objects, Aggregates, Application Services, Domain Events, and Domain Services.

Day 2 – Integration and Architecture

Acceptance Tests in Action – Implement behavior through Ports and Adapters using DDD tactical patterns.
Input Adapters – Connect your domain to the web layer with a clean controller design using Input Ports, Scala sealed types, and Command/Result strategies.
Output Adapters – Integrate with databases, applying Testcontainers for authentic integration testing.
Rapid Development Practices – Establish consistent, repeatable patterns that accelerate team development.
Architectural Patterns in Context – Discuss CQRS, the Outbox Pattern, and their role in resilient systems.
Monoliths, Modular Monoliths, and Microservices – Learn how to divide, deliver, and maintain your application as it evolves.

Day 3 – Refactoring and Coaching

Refactoring Techniques – Use modern tooling to safely restructure complex code and improve architecture.
Live Coaching Session – Scratch Refactoring – Work from a dedicated branch of your own project and perform guided refactoring using Scratch Refactoring techniques (from Michael Feathers’ Working Effectively with Legacy Code). You’ll commit your changes for review and discussion—but won’t merge them—creating a safe space for experimentation, feedback, and deep learning.