Are you interested in AI? 🔎 Discover our AI training courses.

Legacy Modernization with DDD and Spring Boot

3 Days

Dates and Booking

In this training, you’ll learn how to systematically implement DDD concepts in Spring Boot applications. You’ll discover how to use Event Storming to identify bounded contexts, structure them as modules with Spring Monolith, and validate their architecture with ArchUnit and jMolecules. Throughout the course, we’ll work on a realistic legacy hotel codebase that exhibits typical problems of mature monoliths—so you can apply what you’ve learned directly to your own projects.

Why Domain-Driven Design with Spring Boot?

Many Spring Boot applications start out well-structured—but as complexity grows, the boundaries between business domains blur. What began as a clear-cut monolith turns into a “Big Ball of Mud”: services call each other, entities proliferate across module boundaries, and no one dares to make major changes anymore. Domain-Driven Design (DDD) offers proven strategies to counteract this erosion. It helps identify domain boundaries, establish a common language with the business, and consistently align the software architecture with the domain.

As the “DORA State of AI-based Software Development” Report shows, the use of coding agents amplifies both the good and the bad aspects of existing codebases. In other words, AI can add high-quality code to well-structured, clean code, but when applied to a poor-quality codebase, the quality will decline further. Therefore, domain-driven design and clean code will remain highly relevant skills in the future.

Agenda

DDD Fundamentals

  • Strategic Design
    • Collaborative Modeling: Event Storming
    • Bounded Contexts
    • Context Mapping
    • Ubiquitous Language
  • Tactical Design
    • Entities, Value Objects, Aggregates
    • Repositories & Domain Services
    • Domain Events

Modern Spring Architecture

  • Modular Monoliths
    • Application Modules with Spring Modulith
    • Module Testing & Documentation
  • Rich Domain Model
    • Tactical Design in Code with jMolecules
    • Testing the Tactical Structure
    • Clean Code
  • Architectural Styles
    • Layered/Hexagonal/Onion Architecture
    • Using Predefined ArchUnit Architecture Rules

Migration & Evolution

  • Introducing DDD into existing systems
    • Identifying Bounded Contexts in legacy code
    • Strangler Fig Pattern & incremental modernization
  • Outlook: From Monolith to Microservice

Optional

  • Clean Architecture
  • Event-based communication
  • CQRS & Event Sourcing

Your Benefits

You’ll understand strategic and tactical design and be able to use Event Storming to identify business boundaries—a toolkit you can put to use in your project right away.

You’ll learn how Spring Modulith, ArchUnit, and jMolecules technically support DDD concepts and make them actionable—executable architecture instead of theory.

You’ll learn how to incrementally introduce DDD into existing systems—without a big-bang rewrite, using proven strategies like Strangler Fig.

By working on a realistic legacy codebase, you’ll practice exactly the situations you encounter in your day-to-day work.

Audience

  • Experienced Spring Boot developers who want to structure their applications more effectively and ensure they remain maintainable over the long term.
  • Software architects who understand DDD concepts and want to implement them within their teams.
  • Tech leads and senior developers who face the challenge of modernizing legacy monoliths without rewriting everything from scratch.

Requirements

  • Solid knowledge of Java and Spring Boot (controllers, services, repositories, dependency injection)
  • Basic understanding of software architecture
  • Personal laptop with an IDE and Java 17+

Training Objectives

Conduct event storming and translate the results into bounded contexts.

Implement tactical patterns (entities, value objects, aggregates) and understand how they differ from typical Spring patterns.

Use Spring Modulith to define and test modules and enable them to communicate via events.

Validate architectural rules with ArchUnit and jMolecules.

Introduce DDD into existing systems—incrementally and without a big-bang rewrite.

Your Trainers

socreatory trainer Martin Günther

Martin Günther

Domain-driven design, collaborative modeling, modern software architecture

  • Legacy Modernization with DDD and Spring Boot

Martin Günther is a freelance software architect and technical coach specializing in Domain-Driven Design (DDD), collaborative modeling, and modern software architecture. He helps companies understand complex domains, develop robust architectures, and effectively bring interdisciplinary teams together. With deep technical expertise and active development experience, he keeps both the big picture and the implementation details in view. Passionate about structured collaboration, he facilitates workshops and uses methods such as Event Storming or Liberating Structures to guide teams toward creative ideas and practical solutions. Martin Günther regularly shares his knowledge at national and international conferences through presentations and interactive sessions.

socreatory trainer Nicole Rauch

Nicole Rauch

Domain-Driven Design, React/Redux, Clean Code, Functional Programming

  • Legacy Modernization with DDD and Spring Boot

Nicole Rauch is a freelance software developer and software development coach with extensive experience in compiler design and formal verification methods. In addition to Specification by Example, Domain-Driven Design, React/Redux, and Clean Code/Software Craftsmanship, functional programming is also part of her repertoire. Furthermore, she serves on the advisory board and co-organizes several conferences and a trade journal, and is a co-founder of Softwerkskammer, a German-language user community focused on software craftsmanship.

In-House Training

You can also book this training as an in-house training course exclusively for your team. Please use the enquiry form for more details.

Enquire now

Relevant Other Training Courses