Software Development
Building Microservices with Java and Spring Boot
A build-focused programme for teams delivering services with Spring Boot. Across five days participants develop REST APIs with validation, persistence, and externalized configuration, then add resilience, observability, and container packaging until the service is ready to run somewhere other than a laptop.
Overview
Practical learning for workplace transfer.
Spring Boot makes the first service easy and the fifth one dangerous. Teams accumulate services that quietly share a database, call each other synchronously in long chains, log in three different formats, and fail in ways no one can trace across a request. This programme builds a service properly from the first commit: configuration and profiles, request validation, transactional persistence, a consistent error contract, timeouts and retries, structured logging with correlation identifiers, health and metrics endpoints, and a container image sized for production. Service boundaries and data ownership are treated as design decisions taken up front, not as deployment details discovered later.
Prerequisites
Solid Java development experience and familiarity with HTTP and relational databases. Prior Spring exposure is helpful but not required.
Objectives
- Build a Spring Boot service with layered REST endpoints, validation, and consistent error responses.
- Externalize configuration with profiles and properties while keeping secrets out of the codebase.
- Implement persistence with Spring Data JPA, explicit transaction boundaries, and managed schema migrations.
- Apply timeouts, retries, and circuit breakers so one slow dependency cannot take the platform down.
- Instrument services with structured logs, metrics, health checks, and distributed tracing.
- Define service boundaries and inter-service contracts that permit independent deployment.
Target audience
- Java backend developers building or maintaining Spring Boot services
- Software architects defining service boundaries and integration contracts
- Platform and DevOps engineers packaging and operating Java workloads
- API developers accountable for public and internal REST contracts
- Teams decomposing a monolithic Java application into deployable services
- Technical leads setting service standards across several delivery squads
Program outline
A clear structure for the learning journey.
Program outline
Outline points are grouped in one designed block instead of being treated as separate module cards.
Module 1: Spring Boot Foundations and Configuration
Dependency injection, component scanning, and auto-configuration explained
Application properties, profiles, and environment-specific configuration
Externalized secrets and configuration that varies safely between environments
Project structure, starters, and keeping the dependency surface small
Module 2: REST APIs, Validation, and Error Contracts
Resource design, HTTP semantics, and versioning that clients can follow
Request and response models governed by Bean Validation constraints
Centralized exception handling and one predictable error payload
API documentation generated from the code and kept honest over time
Module 3: Persistence, Transactions, and Data Ownership
Spring Data JPA repositories, query methods, and the N+1 select problem
Transaction boundaries, propagation, and isolation inside service code
Schema migrations with Flyway or Liquibase inside the deployment pipeline
One database per service: what changes when tables can no longer be joined
Module 4: Service Boundaries and Communication
Splitting by business capability rather than by technical layer
Synchronous REST calls, the coupling they create, and failure propagation
Asynchronous messaging, event ordering, and eventual consistency trade-offs
Contract testing between producer and consumer services
Module 5: Resilience and Production Behaviour
Timeouts, connection pools, and bounded thread usage on every call path
Retries, backoff, idempotency, and avoiding retry storms
Circuit breakers, bulkheads, and deliberate graceful degradation
Virtual threads and their effect on blocking service workloads
Module 6: Observability, Packaging, and Deployment
Structured logging carrying correlation and trace identifiers
Application metrics with Micrometer and health checks with Actuator
Distributed tracing across service hops and asynchronous boundaries
Container images, layered builds, resource limits, and startup tuning
Materials provided
- Course workbook, annotated code samples, and reference notes
- Hands-on lab environment and starter repositories
- Exercises, checklists, and reusable code templates
- 4D Certificate of Completion
- Post-course technical guidance
Training Options
Programs can be delivered in-house, online, or in a blended format depending on your team's schedule, location, and learning objectives. When an external certificate or exam is included, certification rules and fees remain under the relevant awarding body's policies, while 4D provides the training and preparation support.
Why choose 4D
4D delivers this programme as a build rather than a lecture series: by day five participants have a running, instrumented Spring Boot service packaged in a container. Trainers bring the operational view into the room, so timeouts, tracing, and image sizing are decided the way your platform team expects Java workloads to behave in production.
Related courses
Python Programming Fundamentals
A hands-on introduction to Python for engineers and analysts who need working code rather than tutorial fragments. Participants build fluency with data types, collections, functions, files, and error handling, then assemble a small program that reads real data and produces a usable report.
View courseIntermediate Python and Clean Code Practices
Designed for developers whose Python works but is difficult to change. The course covers dataclasses, generators, decorators, context managers, and type hints, then applies the refactoring moves that turn a nine-hundred-line module into small tested units guarded by black, ruff, and mypy.
View coursePython Automation and Scripting for Work Tasks
Aimed at teams losing hours every week to repetitive file, spreadsheet, and reporting work. Participants automate those tasks with Python: batch file handling, Excel and CSV processing, REST API calls, email alerts, and scheduled jobs that run unattended and report clearly when something fails.
View course