Introduction to Spring Boot Microservices 

Course & Training

Three intensive days on building scalable and robust enterprise applications with Spring Boot, Spring Modulith and selected Spring Cloud components. Step by step, we evolve a classic monolith into a modular monolith and – where it makes sense – into microservices. This gives you the foundation to consciously decide which architecture is the right fit for your context.

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:

We are happy to conduct tailored courses for your team - on-site, remotely or in our course rooms.

Request In-House Course

Public Course Schedule:

   

  Rolf Jufer  

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.


Disclaimer: The actual course content may vary from the above, depending on the trainer, implementation, duration and constellation of participants.

Whether we call it training, course, workshop or seminar, we want to pick up participants at their point and equip them with the necessary practical knowledge so that they can apply the technology directly after the training and deepen it independently.

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 (Is individually adapted for in-house courses.)


Form:

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 Audience:

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.


Requirements:

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 In-House Course:

In-House Kurs Anfragen

Waitinglist for public course:

Sign up for the waiting list for more public course dates. Once we have enough people on the waiting list, we will determine a date that suits everyone as much as possible and schedule a new session. If you want to participate directly with two colleagues, we can even plan a public course specifically for you.

Waiting List Request

(If you already have 3 or more participants, we will discuss your preferred date directly with you and announce the course.)

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.




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.