CAP theorem
~11 minTwo data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Gets you ready for Java backend interviews end to end, from the language and the JVM to Spring services in production. Covers persistence, APIs, testing, security, and system design.
16896 of 16896 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 16896 new. 0 cut, outside your plan.
Most Java backend loops open with a screen and a live coding problem, move to one or two technical conversations on the language and Spring, add a system design round from middle level up, and close with a behavioral interview. The technical conversations decide most outcomes, and they are built from small scenarios rather than definitions: a `HashMap` key whose fields change after it was inserted, a counter two threads increment without synchronization, a prototype-scoped bean injected into a singleton, a lazy collection touched after its session has closed. A junior answer says what the code does. A middle answer says why, in terms of the mechanism: the `equals` and `hashCode` contract, the read-modify-write hidden in an increment, the single moment a singleton's dependencies are injected, the open session a lazy proxy needs. A senior answer starts from a production symptom, such as a connection pool drained by long transactions or a full GC every few minutes, and walks back to the cause, the measurement that confirmed it and the fix worth its trade-offs.
The first stretch is the ground every later module stands on: [the language](/topics/lang-java) and [the JVM](/topics/lang-jvm) beneath it, then computer-science foundations, software design, and the [algorithms](/topics/found-dsa) the coding round is graded on. Spring comes next, and its internal order matters. The [container](/topics/be-spring-core) and Boot explain how beans come to exist and MVC puts them behind HTTP. [AOP](/topics/be-spring-aop) comes before [transactions](/topics/be-spring-tx) and [Spring Security](/topics/be-spring-security) because transactional methods and method-level security are both applied through the same proxies, and most surprises in those annotations are proxy surprises. The plan then follows the request outward and down. Outward is the wire: HTTP and TLS, the API styles from [REST](/topics/proto-rest) to gRPC, and push channels for real-time delivery. Down is storage: [ORM concepts](/topics/be-orm-concepts) such as the unit of work and N+1 selects come before [Hibernate](/topics/be-hibernate) and Spring Data, so the framework has names to hang on, and the relational and non-relational stores sit beneath them. Architecture is where the plan changes scale. [Microservices](/topics/found-microservices), [distributed-systems theory](/topics/found-distributed-systems-core-theory), consistency models and resilience patterns together supply the system design round. A long, mostly language-neutral stretch follows on the practice around the code: how it is tested, versioned and secured, and how it runs, from Linux and containers through delivery pipelines and proxies to [broker operations](/topics/cloud-messaging-concepts) and service levels, then working alongside an AI coding assistant. Only then does the plan return to the JVM, for the tools that put those ideas to work, from the build tools and [Testcontainers](/topics/dev-testcontainers) to Micrometer and [Spring Cloud](/topics/be-spring-cloud). It ends with the [behavioral round](/topics/found-behavioral) and how the loop itself runs.
With a week or two, narrow level to the range you are interviewing for, raise importance to must know and keep study order at by frequency; the Spring and persistence modules repay that time best. With a few months, study by topics from the top: the Spring modules lean on the language ones, and the architecture modules lean on both. Senior candidates get more from the architecture and distributed-systems stretch than from re-reading Spring basics. The exception is AOP and transactions, where everyday use hides the self-invocation and propagation rules interviewers like to probe. The plan stops at the server's edge: it has no module on building a user interface, in JavaScript or any UI framework. If the job also owns the frontend, the [Full Stack Developer roadmap](/roadmaps/full-stack) adds that half. For a JVM team that writes Kotlin, the [Kotlin Backend Developer roadmap](/roadmaps/kotlin-developer) is largely this plan around a different language.
Two data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Most Java backend loops open with a screen and a live coding problem, move to one or two technical conversations on the language and Spring, add a system design round from middle level up, and close with a behavioral interview. The technical conversations decide most outcomes, and they are built from small scenarios rather than definitions: a HashMap key whose fields change after it was inserted, a counter two threads increment without synchronization, a prototype-scoped bean injected into a singleton, a lazy collection touched after its session has closed.
A junior answer says what the code does. A middle answer says why, in terms of the mechanism: the equals and hashCode contract, the read-modify-write hidden in an increment, the single moment a singleton's dependencies are injected, the open session a lazy proxy needs. A senior answer starts from a production symptom, such as a connection pool drained by long transactions or a full GC every few minutes, and walks back to the cause, the measurement that confirmed it and the fix worth its trade-offs.
The first stretch is the ground every later module stands on: the language and the JVM beneath it, then computer-science foundations, software design, and the algorithms the coding round is graded on. Spring comes next, and its internal order matters. The container and Boot explain how beans come to exist and MVC puts them behind HTTP. AOP comes before transactions and Spring Security because transactional methods and method-level security are both applied through the same proxies, and most surprises in those annotations are proxy surprises.
The plan then follows the request outward and down. Outward is the wire: HTTP and TLS, the API styles from REST to gRPC, and push channels for real-time delivery. Down is storage: ORM concepts such as the unit of work and N+1 selects come before Hibernate and Spring Data, so the framework has names to hang on, and the relational and non-relational stores sit beneath them.
Architecture is where the plan changes scale. Microservices, distributed-systems theory, consistency models and resilience patterns together supply the system design round. A long, mostly language-neutral stretch follows on the practice around the code: how it is tested, versioned and secured, and how it runs, from Linux and containers through delivery pipelines and proxies to broker operations and service levels, then working alongside an AI coding assistant. Only then does the plan return to the JVM, for the tools that put those ideas to work, from the build tools and Testcontainers to Micrometer and Spring Cloud. It ends with the behavioral round and how the loop itself runs.
With a week or two, narrow level to the range you are interviewing for, raise importance to must know and keep study order at by frequency; the Spring and persistence modules repay that time best. With a few months, study by topics from the top: the Spring modules lean on the language ones, and the architecture modules lean on both. Senior candidates get more from the architecture and distributed-systems stretch than from re-reading Spring basics. The exception is AOP and transactions, where everyday use hides the self-invocation and propagation rules interviewers like to probe.
The plan stops at the server's edge: it has no module on building a user interface, in JavaScript or any UI framework. If the job also owns the frontend, the Full Stack Developer roadmap adds that half. For a JVM team that writes Kotlin, the Kotlin Backend Developer roadmap is largely this plan around a different language.