roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Show interviewers you understand Spring Boot beneath the annotations, from the IoC container to production services. Covers web and data access, security, testing, microservices and batch.
2638 of 2638 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 2638 new. 0 cut, outside your plan.
Spring Boot is tested inside Java and Kotlin backend loops rather than in an interview of its own: in the technical conversation, in a take-home that arrives as a Boot project, and in live coding of a small validated endpoint. The conversation usually picks an annotation and asks what stands behind it. Why does a @Transactional method called from another method of the same class run with no transaction? Where did the DataSource come from when nobody declared one, and how would you swap it for your own? Why does a request that Spring Security rejects never reach the @ControllerAdvice that formats every other error? Why does the test suite slow down each time one class mocks a different bean?
Early-career candidates are expected to wire a service correctly and name the defaults Boot picked for them. Senior candidates are handed decisions with a price instead: MVC or WebFlux once a blocking driver sits in the request path, where a transaction should end when a remote call sits inside it, whether faster startup is worth a native image and the reflection metadata it demands, and how to read a degraded instance from its health checks and metrics before anyone restarts it.
Boot is a layer that configures a container, which is why the container comes first. The IoC container explains what a bean definition is and when a dependency is injected; proxy mechanics explain how an annotation turns into behavior at a method call, which transactions, caching, async methods and method security all rely on. With both in hand, auto-configuration reads as what it is, bean definitions registered under conditions, and externalized configuration as the input those conditions read.
The two web stacks come next, servlet first: the request-processing lifecycle of Spring MVC is the baseline that Spring WebFlux departs from, and its event-loop threading reads most clearly against one thread per request. Persistence opens on transaction management, the proxies of the first module at their most common job, then goes downward: Spring Data repositories first, then Hibernate's persistence context under the JPA ones, where the SQL a repository call really sends is decided.
Security follows the web and data layers because it guards both. Its filter chain runs before the dispatcher sees a request, and method security reuses the proxies once more. Test slices and Actuator then turn from building a service to proving and watching it.
From there the plan leaves the single service: Spring Cloud for services that call each other, messaging for the ones that talk through a broker, and Spring Batch for bulk jobs that run to completion rather than per request. AOT and native image comes late because it withdraws runtime freedoms the earlier modules took for granted: the bean graph is fixed at build time, and reflection needs declared hints. The wider portfolio closes the plan, with GraphQL, Modulith and Spring AI for the postings that name them.
For a backend loop two weeks away, the web, persistence and security modules carry most of the Spring conversation. Pare importance to must know, drill in the order the page already serves, by frequency, and open the integration, batch and portfolio modules only for a posting that names Kafka, a batch platform or one of those projects. With months to go, switch to by topics in study order, which puts the container questions ahead of the ones that lean on them, and check answers against a running application rather than memory: start it once with `--debug` to read which auto-configurations matched and why the rest backed off, and turn on SQL logging before answering a fetching question. Engineers who have shipped Boot for years usually know the annotations better than the startup sequence behind them, so they gain most from the first two modules and from the transaction and proxy pitfalls, and can drop junior from the level range. Developers arriving from ASP.NET Core or NestJS already know dependency injection as an idea; [Spring's version of it](/topics/be-spring-core-dependency-injection), with candidates chosen by type, qualifiers and primary beans, is the place to start. Every module here assumes you write Java or Kotlin already. The [Java Backend Developer roadmap](/roadmaps/java-developer) takes the rest of the same loop: the language itself, the JVM underneath it, the algorithms round and the system design round.
For a backend loop two weeks away, the web, persistence and security modules carry most of the Spring conversation. Pare importance to must know, drill in the order the page already serves, by frequency, and open the integration, batch and portfolio modules only for a posting that names Kafka, a batch platform or one of those projects. With months to go, switch to by topics in study order, which puts the container questions ahead of the ones that lean on them, and check answers against a running application rather than memory: start it once with --debug to read which auto-configurations matched and why the rest backed off, and turn on SQL logging before answering a fetching question.
Engineers who have shipped Boot for years usually know the annotations better than the startup sequence behind them, so they gain most from the first two modules and from the transaction and proxy pitfalls, and can drop junior from the level range. Developers arriving from ASP.NET Core or NestJS already know dependency injection as an idea; Spring's version of it, with candidates chosen by type, qualifiers and primary beans, is the place to start.
Every module here assumes you write Java or Kotlin already. The Java Backend Developer roadmap takes the rest of the same loop: the language itself, the JVM underneath it, the algorithms round and the system design round.