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.
Get ready for backend developer interviews, from CS foundations and the coding round to APIs, data access, and system design. Covers databases, security, containers, messaging, and observability.
10580 of 10580 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 10580 new. 0 cut, outside your plan.
With no language to drill, the technical conversation in a backend loop lives in the layers every stack shares: the HTTP exchange, the database, and what happens when two requests arrive at once. The loop around it is the usual one: a screen, a coding round, one or two of those conversations, a behavioral close, and from middle level a design round as well. The questions arrive as situations. A `POST` the client retried, and an order that now exists twice. Two requests that each read a balance, subtracted and wrote it back, and the money that vanished between them. A consumer that crashed after writing its row and before acknowledging the message. Each has a one-line answer, and the conversation after it sets the level. Junior rounds stay near the definitions: what idempotent means, which isolation level stops the lost update. "An idempotency key" fixes the duplicate order for one endpoint; asking who retried, the client or a proxy, and whether the key is checked inside the transaction that inserts the order, fixes it as a class. From senior level up, interviewers also want the signal that would have shown it first: pool wait time, replication lag, a p99 that moved before the error rate did.
Without a language module, the opening stretch is what every language shares: the half of computer-science fundamentals a backend round actually reaches, [concurrency](/topics/found-concurrency) above all; the software-design modules, [design principles](/topics/found-design-principles) first, for defending a shape; and the [structures and algorithms](/topics/found-dsa) a coding round is built from. Then the plan picks up a request where working engineers meet it, inside a [web framework](/topics/be-web-frameworks-concepts), where a route, a middleware chain, bound arguments and injected dependencies turn bytes into a handler call; the [protocol module](/topics/proto-web-transport) after it explains what the framework handled on your behalf, from the status code to the TLS handshake and the browser's cross-origin rules. API styles then fix the contract, [REST](/topics/proto-rest) and its two deliberate departures, and real-time delivery takes the case request-response does not fit. From the request the plan goes to its data through the layer the code touches first: [ORM concepts](/topics/be-orm-concepts) treat a loading strategy, a flush or an N+1 query as the application's decision, and the stores that follow put a price on each. [Relational concepts](/topics/db-relational-concepts) and [SQL](/topics/lang-sql) open that module; document, [in-memory](/topics/db-in-memory-concepts) and search stores follow as the places where a relational answer stops being the right one. The architecture modules move the question from one service to the system around it: how a decision that is expensive to reverse gets recorded, where [microservices](/topics/found-microservices) and event-driven messaging put a boundary, and the method [domain-driven design](/topics/found-ddd) offers for finding one. Distributed systems takes the same material to theory, [replication, consensus and clocks](/topics/found-distributed-systems-core-theory) before [system design](/topics/found-system-design) as the applied round, then consistency models and the resilience patterns that round speaks in. A practice stretch follows: testing, Git with GitHub, and security from the [identity protocols](/topics/proto-auth-identity) a provider speaks to what the application does with the result, standing on [secure coding](/topics/found-appsec) and secret handling. Operations follows a build to production in travel order: Linux as host, [Docker](/topics/cloud-docker) as the unit shipped, the pipeline, the [proxy tier](/topics/cloud-networking-concepts) in front, then what is left to operate live, [brokers](/topics/cloud-messaging-concepts) and telemetry with service levels. Coding with an AI assistant closes the technical stretch; the [behavioral round](/topics/found-behavioral) and the mechanics of the hiring process end the plan.
The plan is language-neutral, which changes who should start where. Someone switching stacks, a Django engineer interviewing for a Go team say, already holds the request path and the data modules in another vocabulary and can spend the hours on the architecture and distributed stretch. A first backend interview is the opposite case: the architecture modules will not hold until the HTTP and database ones do, so take the plan in page order, study order set to by topics, and leave everything from System Structure on for a second pass. Close to the date, two controls do the trimming: level, narrowed to the range the job advertises, and importance, raised to must know. Senior candidates are rarely failed on the opening modules; they are failed in the design round, on a guarantee they named and could not defend, so the distributed-systems theory earns a re-read, and the broker and telemetry modules supply the detail, lag, retention, a burn-rate alert, that separates an answer from a diagram. No module here is a programming language or a named web framework; SQL is the one language the plan teaches, and the coding round will be in another. The [Java Backend Developer roadmap](/roadmaps/java-developer) puts the JVM and Spring on top of this plan; for a runtime rather than a role, a tool roadmap such as [Node.js](/roadmaps/nodejs) supplies the missing half. Operations keeps to concepts beyond Docker and Linux; Kubernetes, with its own objects and controllers, is the [Kubernetes roadmap](/roadmaps/kubernetes).
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.
With no language to drill, the technical conversation in a backend loop lives in the layers every stack shares: the HTTP exchange, the database, and what happens when two requests arrive at once. The loop around it is the usual one: a screen, a coding round, one or two of those conversations, a behavioral close, and from middle level a design round as well.
The questions arrive as situations. A POST the client retried, and an order that now exists twice. Two requests that each read a balance, subtracted and wrote it back, and the money that vanished between them. A consumer that crashed after writing its row and before acknowledging the message.
Each has a one-line answer, and the conversation after it sets the level. Junior rounds stay near the definitions: what idempotent means, which isolation level stops the lost update. "An idempotency key" fixes the duplicate order for one endpoint; asking who retried, the client or a proxy, and whether the key is checked inside the transaction that inserts the order, fixes it as a class. From senior level up, interviewers also want the signal that would have shown it first: pool wait time, replication lag, a p99 that moved before the error rate did.
Without a language module, the opening stretch is what every language shares: the half of computer-science fundamentals a backend round actually reaches, concurrency above all; the software-design modules, design principles first, for defending a shape; and the structures and algorithms a coding round is built from.
Then the plan picks up a request where working engineers meet it, inside a web framework, where a route, a middleware chain, bound arguments and injected dependencies turn bytes into a handler call; the protocol module after it explains what the framework handled on your behalf, from the status code to the TLS handshake and the browser's cross-origin rules. API styles then fix the contract, REST and its two deliberate departures, and real-time delivery takes the case request-response does not fit.
From the request the plan goes to its data through the layer the code touches first: ORM concepts treat a loading strategy, a flush or an N+1 query as the application's decision, and the stores that follow put a price on each. Relational concepts and SQL open that module; document, in-memory and search stores follow as the places where a relational answer stops being the right one.
The architecture modules move the question from one service to the system around it: how a decision that is expensive to reverse gets recorded, where microservices and event-driven messaging put a boundary, and the method domain-driven design offers for finding one. Distributed systems takes the same material to theory, replication, consensus and clocks before system design as the applied round, then consistency models and the resilience patterns that round speaks in.
A practice stretch follows: testing, Git with GitHub, and security from the identity protocols a provider speaks to what the application does with the result, standing on secure coding and secret handling. Operations follows a build to production in travel order: Linux as host, Docker as the unit shipped, the pipeline, the proxy tier in front, then what is left to operate live, brokers and telemetry with service levels. Coding with an AI assistant closes the technical stretch; the behavioral round and the mechanics of the hiring process end the plan.
The plan is language-neutral, which changes who should start where. Someone switching stacks, a Django engineer interviewing for a Go team say, already holds the request path and the data modules in another vocabulary and can spend the hours on the architecture and distributed stretch. A first backend interview is the opposite case: the architecture modules will not hold until the HTTP and database ones do, so take the plan in page order, study order set to by topics, and leave everything from System Structure on for a second pass. Close to the date, two controls do the trimming: level, narrowed to the range the job advertises, and importance, raised to must know.
Senior candidates are rarely failed on the opening modules; they are failed in the design round, on a guarantee they named and could not defend, so the distributed-systems theory earns a re-read, and the broker and telemetry modules supply the detail, lag, retention, a burn-rate alert, that separates an answer from a diagram.
No module here is a programming language or a named web framework; SQL is the one language the plan teaches, and the coding round will be in another. The Java Backend Developer roadmap puts the JVM and Spring on top of this plan; for a runtime rather than a role, a tool roadmap such as Node.js supplies the missing half. Operations keeps to concepts beyond Docker and Linux; Kubernetes, with its own objects and controllers, is the Kubernetes roadmap.