Spring Modulith Training

Make module boundaries in your Spring Boot application explicit and verifiable before distributed architecture becomes the default answer. Use Spring Modulith to define modules, test dependencies, work with domain events, generate architecture documentation, and examine incremental modernisation paths.

Book a 30-min call Request by email

Two-day in-house course for up to 12 participants. Delivered in Zürich, at your office across Switzerland or Europe, or fully remote; examples and depth are aligned with your team's Spring Boot versions and architecture questions.

When This Training Is Worth Your Team's Time

For CTOs and engineering managers deciding how to improve boundaries in a Spring Boot system without assuming that every boundary needs a separate service.

  • The Monolith Is Hard to Change

    Dependencies cross business areas freely, ownership is unclear, or a change in one area regularly affects another.

  • Microservices Are Being Considered

    The team needs a practical basis for comparing verifiable in-process modules with the operational cost of distributed services.

  • Modernisation Must Be Incremental

    You want to introduce module tests, domain events, and architecture documentation inside an existing Spring Boot application.

Core and Tailored Modules

The core path covers module definition, verification, module tests, documentation, and domain events. We select operational features, jMolecules, migration patterns, and event externalisation according to your architecture questions.

  • Basics & Module Model

    Understand the motivation behind moduliths and how they compare to microservices. Set up projects, define modules with package structures, named interfaces, and custom module detection, including simple, advanced, nested, and open modules.

  • Architecture Verification

    Define dependency rules, then use architecture tests to detect violations in the build. Integrate ArchUnit to check your modular boundaries and customise verification options.

  • Module Testing

    Learn the fundamentals of module testing with Spring Modulith's application module testing support. Handle dependencies, configure bootstrap modes, and use change-aware test execution.

  • Documentation

    Generate living architecture documentation automatically: Modulith diagrams in C4 and UML formats, and application module canvases that visualise your modular structure.

  • Module Communication & Events

    Communicate between modules using synchronous and asynchronous domain events. Use the event publication registry with persistence, resubmission, and completion modes. Test event-driven interactions with the Scenario API and Passage of Time Events.

  • Operational Integration

    Integrate into CI/CD with fitness functions. Use the ApplicationModuleInitializer, Modulith actuator endpoints, observability with Micrometer and OpenTelemetry, module-specific Flyway migrations, and configurable Modulith properties.

  • DDD with jMolecules

    Make DDD concepts explicit with jMolecules: aggregates, entities, value objects, domain events, repositories, and module annotations. Integrate into Modulith documentation, canvas, and ArchUnit rules.

  • Migration & Hybrid Architectures

    Migrate legacy applications to a Modulith step by step. Design hybrid architectures combining moduliths and microservices. Externalise events via Kafka, AMQP, JMS, and Spring Messaging.

Who Is This Training For?

This training is designed for developers, architects, and teams who want to build or modernise Spring Boot applications with a clearly modular structure.

  • Spring Boot Developers

    Software developers who work with Spring Boot and want to structure their applications in a clearly modular way, with clear boundaries, testable modules, and automated architecture checks.

  • Software Architects

    Software architects who want to examine microservices critically or decide deliberately which boundaries belong in-process and which justify distributed services.

  • Teams Modernising Monoliths

    Teams that want to modernise existing monoliths and gradually convert them into modular systems, step by step, without a risky big-bang rewrite.

Training Details

All sessions are hands-on with real code exercises using an example application. We tailor content and pace to your team's experience level.

Format

In Zürich, on-site at your office, or fully remote. We adapt exercises and tooling to your environment.

Duration

2 days. For in-house delivery, we adapt the agenda and can split it into focused modules.

Language

Delivered in English or German. Italian available on request.

Prerequisites

Spring Boot experience. Familiarity with domain-driven design concepts is helpful but not required.

Frequently Asked Questions

Where does the training take place?

In Zürich, at your office anywhere in Switzerland or Europe, or fully remote.

Is the training available in German?

Yes. We deliver the training in English or German – Italian is available on request. Course materials are in English.

How long does the training take?

2 days. For in-house courses we adapt the content individually and can split it into focused modules.

Do we need domain-driven design experience?

No. Familiarity with DDD concepts is helpful but not required – we introduce the relevant ideas such as bounded contexts and domain events as part of the training.

How much does the training cost?

We deliver in-house, for up to 12 participants. The final price depends on group size, duration, and how much we tailor the content. Book a 30-minute call or email hello@42talents.com. We reply personally to emails within one business day.

Related Spring Courses

Explore the other courses in our Spring training curriculum.

Build the capability your roadmap needs

Tell us which capability your team needs to build. We'll shape the course around your stack, delivery goals, and current codebase.

In-house, up to 12 participants. Content tailored to your codebase and your stack.

Book a 30-min call Request by email