Course · Training · Workshop

Introduction to Spring Boot Microservices

Build scalable, robust enterprise applications with Spring Boot, Spring Modulith and Spring Cloud – evolving a classic monolith into a modular monolith and, where sensible, microservices.

Modern software architecture is not an either-or decision, but a continuum: from well-structured monoliths through modular monoliths to microservices. In this course, you will experience this journey hands-on with a shared sample application. The Spring ecosystem with Spring Boot, Spring Data, Spring MVC and Spring Modulith has established itself as the dominant Java framework for building scalable enterprise applications. With Spring Modulith, you define and verify module boundaries at compile time. With selected Spring Cloud components (e.g. Service Discovery, Config Server, Circuit Breaker, resilience features), you make distributed systems production-ready. The goal is not “microservices at all costs”, but understanding when a monolith, modular monolith or microservices architecture is appropriate – and how to evolve your system step by step towards it.

In-house course

Tailored for your team.

Request

No suitable date?

Request a new public date.

Request a date

Trainers

Rolf Jufer

Instructor

Adam Furmańczuk

Instructor

What participants say

The course was a good introduction to Microservices with Spring Boot. We can now start discussing how we want to build up our microservice structure and whether it is necessary to destructure existing monoliths

David
Full Stack Developer

These customers booked courses in the same topic cluster.More customers →

Content

Together, we incrementally build an enterprise application – starting from a classic monolith, evolving it into a modular monolith and, where appropriate, into selected microservices. Along the way, we cover (among others) the following areas:

Architecture & Design:

Monoliths, modular monoliths and microservices – comparison, typical use cases and decision criteria
Domain-Driven Design and module boundaries
When does which architecture fit? Evolution instead of big-bang rewrite
Twelve-Factor App methodology

Spring Fundamentals:

Overview of the Spring ecosystem and core concepts (Inversion of Control, Dependency Injection)
Spring 6/7 and Spring Boot 3.5/4 – relevant features and innovations for enterprise applications
Setting up and configuring Spring Boot applications with Spring Initializr, Maven, profiles
Faster development with Spring Boot DevTools

Modular Monoliths with Spring Modulith:

Spring Modulith – structure and definition of module boundaries
Modular-first design and verification at compile time
Intra-process communication with events
Module testing and automatic module documentation

REST Services & Data Persistence:

REST services with Spring MVC
RESTful API design best practices
Data persistence with Spring Data JPA
Validation and error handling

OpenAPI & API Generation:

OpenAPI / Swagger specification
Spring Boot starter for OpenAPI integration (springdoc-openapi)
API-first development approach
Code generation from OpenAPI specs
Documentation and client generation

From Monolith to Microservices:

Service decomposition strategies
Inter-service communication (REST, asynchronous)
API gateways with Spring Cloud Gateway
Saga pattern for distributed transactions

Spring Cloud & Resilience:

Service discovery with Spring Cloud Eureka
Centralized configuration with Spring Cloud Config
Resilience patterns (circuit breaker, retry, timeout)
Resilience4j via Spring Cloud CircuitBreaker
Spring Cloud LoadBalancer

Observability & Monitoring:

Monitoring, logging and health checks
Spring Boot Actuator
Metrics with Micrometer
Distributed tracing (e.g. with Micrometer Tracing / OpenTelemetry)

Security:

Spring Security fundamentals
OAuth 2.0 and JWT in microservice landscapes
Service-to-service authentication

Deployment & Containerization:

Docker for Spring Boot
Containerization of Spring Boot applications
Graceful shutdown and health probes
Typical deployment patterns

Testing:

Testing with unit and integration tests
Spring Boot TestContext framework
Contract tests with Spring Cloud Contract
End-to-end tests with Testcontainers

We focus on a carefully selected subset of these topics and dive deep into them using the shared course application – always with a practical focus on production-ready applications.

The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.

Goal

Build practical expertise and create a comprehensive understanding of how to use the Spring ecosystem efficiently, with a focus on Spring Boot 3.5/4, Spring 6/7, Spring Modulith and selected Spring Cloud components. Participants understand the differences between monoliths, modular monoliths and microservices, know typical use cases and can consciously choose the right architecture for their projects. By the end of the course, they will be able to implement production-ready enterprise applications and understand how to evolve existing systems from monoliths to modular monoliths or microservices.

Duration

2 Days

Format

A proven mix of concept explanations, live coding and the collaborative, incremental development of a comprehensive course application. The application evolves from a classic monolith through a modular monolith to selected microservices and finally to a production-ready, containerized solution – always geared towards the practical use of Spring Boot in real-world projects and production environments.

Target group

Software developers who want to build modern Spring Boot applications and make informed decisions about whether a monolith, modular monolith or microservices architecture fits their project. Development teams transitioning from existing monoliths to modular or distributed systems. Architects and tech leads who need to evaluate and decide on architectural styles.

Prerequisites

Basic experience in software development with Java (at least 1–2 years) and a basic understanding of databases and SQL. Familiarity with Maven or Gradle is advantageous. An interest in software architecture and modern development practices is expected.

Preparation

After registration, each participant receives a short questionnaire and detailed installation instructions. These cover the setup of Java 17+, Maven, an IDE (IntelliJ IDEA or VS Code), Docker and other tools. Based on the answers and the preparation status, we provide individual feedback and, if needed, additional preparatory materials.

Request this course in-house

Request a public date

No suitable public date? Register without obligation — once there is enough interest we schedule a new public date and let you know first.

More about Spring Boot and Microservices

Here's why you should take this course: - You will gain a clear understanding of when to choose a monolith, a modular monolith or microservices. - You will build a complete, production-ready course application, progressing from a basic Spring Boot app to a containerised, observable solution. - You will familiarise yourself with Spring Modular in practice, making your existing and new applications modular and maintainable. - You will work with a modern Spring stack (Spring 6/7, Spring Boot 3.5/4, Spring Cloud and OpenAPI), equipping you with the skills to apply this knowledge directly to your projects. - You will combine architectural concepts with real code, thereby strengthening your profile as a software engineer, tech lead or architect.

Further resources:

History

The Spring Framework was created in 2002 by Rod Johnson as an alternative to complex Enterprise Java frameworks. Spring Boot emerged in 2014 under the leadership of Phil Webb and the Pivotal team to radically simplify Spring application development – with auto-configuration, starter dependencies, and embedded servers.

Spring Cloud evolved from 2015 onwards as a response to the growing microservices movement, integrating patterns such as service discovery, config management, and circuit breakers. Spring Modulith was introduced in 2022 by Oliver Drotbohm to bridge the gap between monoliths and microservices – focusing on modular structures that are verified at compile time.

Today, the Spring ecosystem represents the evolution of modern software architecture: from classic monoliths through modular monoliths to microservices. With Spring Boot 3.x/4.x, Spring 6.x/7.x, and Spring Modulith, developers can consciously choose the right architecture and evolve systems incrementally – without big-bang rewrites. The ecosystem is used by millions of developers worldwide and significantly shapes the development of cloud-native enterprise applications.