Grokking Spring Boot
Learn Spring Boot by building a booking service, and learn how each part of Spring works inside.

Course Overview
Spring Boot makes a Java backend service quick to build, yet much of what it does happens out of sight. Grokking Spring Boot teaches you to build a backend service with it and to explain each mechanism that makes the service work. The course follows one running example, a booking service for an event ticketing app, from a single endpoint to a secured, tested service ready for production. You will build small versions of the container, of a proxy, and of an auto-configuration rule in plain Java before you use the real ones, so the behavior of Spring stops being a mystery. Along the way, the course covers dependency injection and the bean lifecycle, REST APIs, data access with JPA, transactions and locking, security, testing, performance, messaging, and production monitoring. Runnable Java programs in the lessons show each mechanism, and the Spring code targets current Spring Boot and Java versions.
What you'll learn in Grokking Spring Boot
- Build a Spring Boot service from a single endpoint to a secured, tested booking service ready for production.
- Control bean scopes, the bean lifecycle, and post-processors, and know why constructor injection is the default.
- Set up configuration with property sources, profiles, typed properties, secrets, and structured logging.
- Access data with JdbcClient and JPA, fix the N+1 query problem, and manage the schema with Flyway migrations.
- Understand the proxies behind @Transactional, @Cacheable, @Async, and @Retryable, and avoid their pitfalls.
- Test at the right level with plain unit tests, slice tests, full application tests, and HTTP layer tests.
- Publish events after commit, send messages through Kafka, and make a service ready for production with Actuator.
- Explain how the Spring container creates and connects beans, after building a small container yourself in plain Java.
- Read how auto-configuration decides what to create, use the conditions report, and override a default safely.
- Design REST APIs with DTOs, validation, ProblemDetail errors, pagination, versioning, and OpenAPI documents.
- Use transactions correctly: propagation, isolation, rollback rules, the self-invocation trap, and locking.
- Secure an API with the security filter chain, password hashing, JWT tokens, OAuth2 sign-in, and method security.
- Keep a service fast and resilient with caching, virtual threads, sized connection pools, retries, and timeouts.
Course Content
Getting Started with Spring Boot
Final Exam
What people say about our courses






About the Author

Arslan Ahmad
Industry Expertise & Leadership
Arslan Ahmad is the lead author of Grokking Spring Boot. As the founder of Design Gurus and a former FAANG hiring manager, he has worked at industry giants like Facebook (now Meta) and Microsoft.
He has conducted hundreds of system design interviews, giving him unique insight into what top tech companies look for in candidates.
The course also incorporates expertise from senior engineers at Google, Meta, Amazon, Microsoft, and Uber, ensuring you learn system design best practices from professionals who have built and scaled real-world systems.
500+
Interviews Conducted
10k+
Students Taught
Related Courses
$148
$48
$72
FAQs
What is Grokking Spring Boot?
It is a written course that teaches Java developers to build a backend service with Spring Boot and to explain how each part of Spring makes that service work. One booking service for an event ticketing app grows from a single endpoint to a secured, tested service ready for production.
Who is this course for?
It is for Java developers who are starting with Spring Boot, and for developers who already use it but want to understand what it does for them. It suits a backend engineer joining a Spring team and a developer moving from another framework.
What do I need to know before I start?
You need basic Java: classes, interfaces, collections, and exceptions. No earlier Spring experience is needed. The course reviews the modern Java features that Spring code relies on, such as lambdas, streams, Optional, records, and annotations, before it uses them.
Which versions of Spring Boot and Java does it use?
It uses Spring Boot 4 on Spring Framework 7, with Java 21 for the Spring code. Every Spring listing, setting, log line, and error message in the lessons comes from a real run of that version, not from memory or an older guide.
How is this different from other Spring Boot courses?
Most courses teach which annotation to add. This course also explains the mechanism behind it, and several lessons build a small version of a mechanism in plain Java first: a container that reads constructors, a proxy that wraps a method in a transaction, and a condition evaluator like the one auto-configuration uses.
Can I run the code in the browser?
Yes, for the plain Java programs. They use only the Java standard library and run in the course player with the Run button. Spring code needs a build tool and a running server, so it is shown read-only together with the real output it produced.
Does it cover data access and transactions?
Yes. It covers connection pools, plain SQL with JdbcClient, JPA entities and Spring Data repositories, lazy and eager loading, the N+1 query problem, projections, and Flyway migrations, then transactions in depth: propagation, isolation levels, rollback rules, the self-invocation trap, and optimistic and pessimistic locking.
Does it cover Spring Security?
Yes. It explains the security filter chain, authentication and authorization, password hashing, stateless APIs with JWT tokens, sign-in with OAuth2, method security with @PreAuthorize, and CORS and CSRF, and then secures the booking API for customers and venue staff.
How does it teach testing?
It shows when to use plain unit tests without Spring, slice tests such as @WebMvcTest and @DataJpaTest, full application tests with @SpringBootTest, tests against a real database with Testcontainers, tests of security rules, and tests of the HTTP layer.
Does it prepare a service for production?
Yes. It covers caching, asynchronous methods, virtual threads, connection pool sizing, calls to other services, retries, and timeouts, then application events, Kafka, the transactional outbox, Actuator, health probes, metrics and tracing, container images, graceful shutdown, and a production checklist.
Is there any practice, or is it only reading?
Every lesson ends with practice questions and folded answers, and many lessons include Java programs you can run and change. Each chapter ends with an adaptive assessment that draws a fresh set of questions on every attempt, and the course closes with an adaptive final exam across all chapters.