Build production Spring Boot APIs on modern Java
A hands-on backend path — core Spring & dependency injection, REST APIs, Spring Data JPA, security, testing, microservices and observability — then into the territory that separates "I built a CRUD API" from "I can run this in production": distributed transactions, GraphQL, Spring Batch, JVM performance tuning, and progressive delivery. It ends with a two-week capstone service you architect, secure, test and deploy yourself.
Prerequisites & tooling
What you should already know
- Core Java — classes, interfaces, collections, OOP basics
- Comfortable with the command line and Git
- No prior Spring experience required
- JDK 21 (LTS) and an IDE like IntelliJ installed
Stack you'll work with
The same tools teams use to ship real Spring Boot services in production.
Your 26-week learning path
Twenty-two modules, from your first @RestController through microservices, GraphQL, batch processing and JVM tuning, to a two-week capstone service you deploy in a container.
Java Foundations & Environment Setup
Refresh modern Java and get your backend toolchain running.
- Records, sealed classes & pattern matching
- JDK 21, Maven/Gradle & project structure
- IDE setup & running your first Spring Boot app
Spring Core & Dependency Injection
Understand the container that powers every Spring application.
- IoC container, beans & the bean lifecycle
- Constructor injection & component scanning
- Auto-configuration & starters explained
Building REST APIs
Design and build clean, well-validated HTTP APIs.
- Spring MVC,
@RestController& DTOs - Bean Validation & request/response mapping
- Centralized error handling with
@ControllerAdvice
Data Persistence with Spring Data JPA
Model your domain and talk to a real relational database.
- Entities, repositories & JPQL queries
- Relationships, lazy loading & transactions
- Schema migrations with Flyway
Spring Security & Authentication
Lock down your API with modern, stateless authentication.
- The security filter chain & password encoding
- JWT-based authentication & OAuth2/OIDC login
- Method-level authorization
Testing Spring Boot Applications
Build a layered test suite you can trust before every deploy.
- Unit testing with JUnit 5 & Mockito
@SpringBootTest&MockMvcslice tests- Real-database integration tests with Testcontainers
Microservices & Messaging
Move from a single service to a small distributed system.
- Service-to-service calls with
RestClient/WebClient - Event-driven messaging with Kafka/RabbitMQ
- Resilience patterns with Resilience4j
Caching & Performance
Keep a growing service fast under real load.
- The Spring Cache abstraction & Redis
- Connection pooling & query performance
- Async processing with
@Async
Observability & Production Readiness
Understand what your service is doing once it's live.
- Spring Boot Actuator & health checks
- Metrics with Micrometer & structured logging
- Distributed tracing basics
Containerization & Deployment
Package and ship your service the way production teams do.
- Docker images with Cloud Native Buildpacks
- CI/CD pipelines for a Spring Boot service
- Deploying to Kubernetes — the basics
Reactive Programming with WebFlux
An introduction to Spring's non-blocking, reactive stack.
- Project Reactor:
Mono&Flux - Reactive data access & backpressure
- When to reach for WebFlux vs. Spring MVC
Advanced Spring Data — Specifications, Projections & Query Optimization
Move past findAll() into the query patterns real production repositories need.
- Dynamic queries with the JPA Criteria API & Specifications
- DTO projections, entity graphs & solving N+1 for real
- Batch inserts/updates & native queries when JPQL isn't enough
API Design at Scale — Versioning, Pagination & OpenAPI
Design an API surface that can evolve without breaking every client.
- API versioning strategies & deprecation without breaking clients
- Cursor-based pagination, filtering & sorting conventions
- OpenAPI/Swagger docs & per-client rate limiting
Spring Cloud Microservices — Config Server, Eureka & Gateway
Grow from a couple of services into a real distributed system with shared infrastructure.
- Centralized config with Spring Cloud Config Server
- Service discovery with Eureka
- Spring Cloud Gateway as a single entry point
Distributed Transactions & the Saga Pattern
Keep data consistent across services without a distributed database transaction.
- Why two-phase commit doesn't fit microservices
- Choreography vs. orchestration-based sagas
- The transactional outbox pattern for reliable event publishing
Advanced Security — OAuth2 Authorization Server & Multi-Tenancy
Go from consuming OAuth2 to running your own, and isolating tenants correctly.
- Running your own Spring Authorization Server
- API keys & service-to-service (client credentials) auth
- Multi-tenant data isolation strategies
Batch Processing with Spring Batch
Process large volumes of data reliably, with restart and skip logic built in.
- Jobs, steps & the chunk-oriented processing model
- Readers, processors & writers for a real CSV-to-database job
- Restartability, skip/retry policies & scheduling a job
GraphQL with Spring for GraphQL
Give clients a query language instead of a fixed set of REST shapes.
- Schema-first design with GraphQL SDL
@QueryMapping/@SchemaMappingresolvers- Solving GraphQL's own N+1 problem with
DataLoader
Contract Testing & Advanced Test Strategy
Test the boundary between services, not just the code inside one.
- Consumer-driven contract testing with Pact
- Mutation testing to check whether your tests actually test anything
- Testing resilience: timeouts, retries & circuit breakers under fault injection
JVM Performance Tuning & Virtual Threads
Understand what the JVM is actually doing when your service gets slow.
- Heap, GC algorithms & reading a GC log
- Thread dumps, heap dumps & profiling a live service
- Java 21 virtual threads & when they help (and don't)
CI/CD & Progressive Delivery for Spring Boot
Take deployment from "push and hope" to a pipeline with a real safety net.
- Multi-stage pipelines: build, test, scan, deploy
- Blue-green & canary deploys for a Spring Boot service
- Feature flags for decoupling deploy from release
Capstone: Ship a Production Spring Boot Service
Apply every module in one project — built, tested, secured and deployed by you.
- Fully tested, secured, containerized service
- A real CI/CD pipeline with a progressive rollout
- Portfolio-ready project you can show employers