What Spring Boot Adds
Separate Spring Framework from Boot, then trace starters, SpringApplication, component scanning, conditional auto-configuration, and back-off behavior.
5 lessons115 minFramework vs Boot · Starters
Your Course Track
Start Your Spring Boot Journey
Begin with Stage 1: Core Spring & Mental Models to understand object construction, the IoC container, and bean lifecycles.
0% complete0 / 84 core lessons
Core curriculum
One dependency-aware path
Each stage owns its concepts once. Later lessons link back to the runtime model instead of explaining the same annotation again.
Open stage
Why Spring Exists
Begin with ordinary Java object construction, then see why IoC, dependency injection, XML bean definitions, Java configuration, and component scanning exist.
14 lessons345 minIoC vs DI · XML bean metadata
Configuration Before Features
Externalize settings, bind validated properties, select profiles, and keep secrets outside the artifact before infrastructure depends on them.
4 lessons75 minProperty precedence ·
Build a Maintainable API
Place controllers, application services, repositories, DTOs, validation, and error translation at explicit boundaries.
14 lessons380 minDispatcherServlet · DTO mapping
Persistence and Transactions
Connect database behavior to JPA, Hibernate, Spring Data repositories, the persistence context, fetching, transactions, locking, and query performance.
19 lessons495 minPackage by feature · Persistence context
Logging and Observability
Write structured, correlated logs and expose safe health, metrics, and tracing signals before tuning or distributing the system.
5 lessons175 minStructured logging · Correlation identifiers
Testing Spring Applications
Choose the smallest useful test boundary: plain unit tests, collaboration tests, MVC/JPA slices, full application tests, or real infrastructure.
4 lessons165 minJUnit and Mockito · Test slices
Spring Security
Trace authentication and authorization through the SecurityFilterChain before comparing sessions, JWT, CSRF, CORS, and OAuth 2.0/OIDC.
5 lessons245 minSecurityFilterChain · Authentication vs authorization
Production Behavior
Call external services safely and add caching only after defining timeouts, retries, idempotency, consistency, and failure evidence.
7 lessons280 minRestClient · Timeouts and retries
Architecture and Production Capstone
Package, observe, test, and deploy one modular application before considering distributed-system complexity.
7 lessons340 minModular architecture · Proxy-backed annotations
Course curriculum
Choose one module. Finish it. Move forward.
Opening a module takes you to its own workspace—other modules stay out of the way.
00Prepare
Foundation7 chapters350 min
Before You Learn Spring Boot
Confirm the main Java, backend, and tooling basics before starting Spring Boot.
1The Spring Boot Journey 20m2Core Java & Backend Prerequisites 55m3Professional Environment Setup 40m+ 4 more chapters
Know the core Java, HTTP, SQL, and build-tool concepts needed to follow the Spring Boot modules.
Prerequisite: None
01Understand
Foundation5 chapters115 min
What Spring Boot Adds
Separate the Spring portfolio, Spring Framework, and Spring Boot, then trace how Boot assembles a conventional application.
1Spring Ecosystem vs Framework vs Boot 30m2Create Your First Spring Boot Application 15m3Spring Boot Project Anatomy & Package Design 35m+ 2 more chapters
Explain which capabilities come from Java, Spring Framework, Spring Boot, and other Spring projects—and organize a project so Boot can discover it predictably.
Prerequisite: Module 0 readiness checkpoint
02Understand
Foundation14 chapters345 min
Spring from First Principles
Start with ordinary Java object construction, follow Spring configuration from XML to annotations, and inspect how the container turns bean definitions into managed objects.
1Why Spring Exists: From new to a Container 22m2From XML Beans to Modern Spring Configuration 28m3The IoC Container 15m+ 11 more chapters
Explain why Spring exists, how configuration metadata becomes BeanDefinition objects, and how the container creates, wires, initializes, and sometimes proxies a bean.
Prerequisite: Spring Boot fundamentals
03Configure
Foundation4 chapters75 min
Configuration
Externalize every environment difference—properties, YAML, profiles, typed configuration binding, and secrets that never touch version control.
1Properties vs YAML 15m2Type-Safe Configuration with @ConfigurationProperties 25m3Environment Profiles 15m+ 1 more chapters
Ship one artifact into dev, test, and production with only the environment changing, and keep credentials out of the repository.
Prerequisite: Spring Boot fundamentals
04Build
Foundation11 chapters275 min
Building REST APIs
Build a task API end to end: controllers, request binding, DTO boundaries, status codes, validation, pagination, and the MVC internals underneath.
1Your First REST Controller 15m2The DispatcherServlet 20m3@RestController vs @Controller 15m+ 8 more chapters
Ship endpoints with validated input, consistent error payloads, and tests that prove the HTTP contract.
Prerequisite: Spring Core and configuration
05Harden
Intermediate3 chapters105 min
Validation & Error Handling
Turn malformed input and domain failures into predictable, machine-readable API contracts.
1Build a Stable Validation & Error Contract 40m2Write Custom Constraints Without Hiding Business Logic 30m3Centralize Failures with ProblemDetail 35m
Design validation boundaries and one safe error vocabulary for every endpoint.
Prerequisite: Spring MVC
06Build
Foundation2 chapters45 min
Application Architecture
Stop putting everything in controllers: split responsibilities across controller, service, repository, and DTO layers and organize packages so structure follows intent.
Refactor an endpoint-heavy prototype into a layered service where each class has one reason to change.
Prerequisite: Spring MVC and validation
07Build
Foundation17 chapters450 min
Database & Spring Data JPA
Model entities honestly, choose fetch strategies deliberately, and keep every write inside a transaction scoped to one business operation.
Persist and query data without N+1 surprises, leaked entities, or accidental multi-statement commits.
Prerequisite: Application architecture and SQL fundamentals
08Prove
Intermediate4 chapters165 min
Testing
Build a fast confidence system with pure unit tests, focused Spring slices, and realistic container-backed integration tests.
1Prove Domain Rules with JUnit 5 35m2Use Mockito for Collaborations, Not State 35m3Use MVC, JSON & JPA Test Slices 45m+ 1 more chapters
Choose the narrowest test that can prove each risk and keep the suite deterministic.
Prerequisite: Spring MVC and Spring Data JPA
09Secure
Intermediate5 chapters245 min
Spring Security
Trace authentication and authorization through the servlet filter chain, then build session, bearer-token, and OIDC security deliberately.
1Trace a Request Through the Security Filter Chain 50m2Choose Sessions, JWTs, and Refresh Tokens by Threat Model 50m3Enforce Permissions, CORS, and CSRF Correctly 45m+ 2 more chapters
Secure an API with least-privilege rules and explain every trust boundary.
Prerequisite: Spring MVC, validation, and testing basics
10Observe
Foundation2 chapters45 min
Logging
Log deliberately with SLF4J and Logback: right levels, structured messages, zero sensitive data, and exceptions with full context.
Diagnose failures from logs alone because messages carry context, levels carry meaning, and nothing sensitive leaks.
Prerequisite: Spring Boot fundamentals
11Observe
Intermediate3 chapters130 min
Observability & Monitoring
Expose safe operational signals and connect logs, metrics, and traces into one production investigation workflow.
1Design Health, Readiness & Management Access 40m2Correlate Logs, Metrics & Traces 50m3Build a Useful Prometheus & Grafana Pipeline 40m
Operate a service from symptoms to root cause without exposing sensitive management data.
Prerequisite: Configuration and logging
12Accelerate
Intermediate4 chapters165 min
Caching & Redis
Use Spring Cache and Redis without turning stale data, stampedes, and unsafe keys into correctness bugs.
1Understand What Spring Cache Does—and Does Not Do 35m2Design Redis Caching for Consistency 45m3Prevent Key Leaks, Stampedes & Hotspots 40m+ 1 more chapters
Select cacheable reads, design keys and TTLs, and make invalidation observable.
Prerequisite: Spring Data JPA and observability
13Decouple
Intermediate4 chapters190 min
Async Processing & Kafka
Move work off the request path while keeping delivery, ordering, retries, and business state observable.
1Use @Async and Application Events Deliberately 40m2Publish Reliably with Kafka & the Outbox Pattern 55m3Design Retries, Ordering & Dead Letters 45m+ 1 more chapters
Choose local async work, in-process events, or a broker and state the failure contract of each.
Prerequisite: Application architecture and transactions
14Harden
Intermediate3 chapters115 min
API Integration & Resilience
Call other systems deliberately: modern HTTP clients with explicit timeouts, bounded retries and circuit breakers, and verified inbound webhooks.
1Calling External APIs with RestClient 30m2Receiving Webhooks Safely 30m3Budget Timeouts, Retries, Circuit Breakers & Bulkheads 55m
Integrate a third-party API whose failures do not cascade into your own outage.
Prerequisite: Spring MVC and failure-handling basics
15Build
Intermediate2 chapters65 min
File Handling
Accept uploads without risking memory or security, validate what users send, and store files durably behind controlled access.
Ship an upload feature that bounds memory, blocks malicious files, and keeps private files private.
Prerequisite: Spring MVC, validation, and security
16Optimize
Advanced2 chapters90 min
Performance & Scalability
Measure real bottlenecks, tune the hottest paths, and scale Spring Boot services horizontally with evidence instead of folklore.
Turn performance work into measurement-driven scaling decisions backed by load-test evidence.
Prerequisite: Data access, caching, and observability
17Ship
Advanced4 chapters190 min
Docker & Deployment
Package one immutable artifact, inject environment configuration safely, and deploy it with health-aware automation.
1Package & Run an Immutable Spring Boot Service 50m2Build a Safe CI/CD & Secrets Path 45m3Engineer Probes, Shutdown & Rolling Deploys 45m+ 1 more chapters
Create a repeatable container delivery path with safe startup, rollout, shutdown, and rollback behavior.
Prerequisite: Configuration, testing, and Actuator
18Architect
Advanced3 chapters150 min
Advanced Spring Boot
Organize boundaries, recognize framework-powered patterns, master proxies and post-processors, and assemble a production-grade capstone.
1Choose Layered, Hexagonal or Clean Boundaries 50m2Recognize the Patterns Behind Spring Annotations 40m3Design a Production-Grade Capstone 60m
Defend an architecture through dependency direction, failure behavior, performance evidence, and evolutionary cost.
Prerequisite: Core Spring, transactions, and testing
19Distribute
Advanced4 chapters170 min
Microservices & Cloud-Native Patterns
Split services only around owned capabilities, then design discovery, routing, resilience, communication, and tracing for partial failure.
1Find Service Boundaries Before Adding Spring Cloud 50m2API Gateways & Service Discovery 40m3Propagate Context Across Service Boundaries 40m+ 1 more chapters
Design a service boundary and explain how it behaves when dependencies are slow, unavailable, or duplicated.
Prerequisite: API integration, messaging, observability, and deployment
Read with less friction
A 70–75 character reading column, descriptive headings, calmer typography, lesson drawers, and an optional focus mode.
Trace the runtime
Annotated code, bean and request lifecycles, deliberate failures, and evidence-led debugging replace annotation lists.
Prepare for interviews
Retrieval checkpoints, concise model answers, follow-up questions, pitfalls, and module assessments appear throughout the path.
Optional specializations
Add complexity when the problem requires it
These topics remain available without making every learner treat distributed systems and specialist infrastructure as prerequisites.
Async Processing & KafkaMove work off the request path while keeping delivery, ordering, retries, and business state observable.File HandlingAccept uploads without risking memory or security, validate what users send, and store files durably behind controlled access.Performance & ScalabilityMeasure real bottlenecks, tune the hottest paths, and scale Spring Boot services horizontally with evidence instead of folklore.Microservices & Cloud-Native PatternsSplit services only around owned capabilities, then design discovery, routing, resilience, communication, and tracing for partial failure.
Interview preparation
Explain the mechanism, then prove it.
Use module assessments after the retrieval questions, debugging exercises, and project checkpoints inside each stage.
Reference
Keep primary sources close
Lessons explain the model; official documentation remains the versioned source of truth.