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 full stack interviews that move between browser and server. Covers language and framework concepts, APIs and auth, data stores, testing, delivery and system design.
13410 of 13410 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 13410 new. 0 cut, outside your plan.
Full stack loops usually run three to five rounds: a coding screen in JavaScript or TypeScript, a practical round that builds one small feature end to end, an endpoint and the form or list that calls it, a technical conversation that leans toward whichever half the team is short of, and a behavioral interview, with a design round added once the posting is middle or above. The practical round carries the most weight, because it shows whether you hold both halves in your head at once or switch between two separate skill sets. The questions sit on the boundary. A `fetch` from the page is blocked while the same request from `curl` succeeds: which party refused it, and what does the preflight ask the server to declare? A list page issues one query per row, once in an ORM and once in a GraphQL resolver, and the fix has a different name on each side. A retried `POST` creates two orders. A page renders on the server, then the browser warns that the markup it hydrated did not match. What separates candidates is knowing which side owns a symptom. Faced with a list that is stale after a save, a weaker answer adds a refresh on the client; a stronger one asks whether the client cache, a `Cache-Control` header, a CDN or a read replica is serving the old row, and fixes it where it lives. Senior loops push the same scenarios into production: a token stored where any script on the origin can read it, or a deploy in which the new frontend talks to the old API for a few minutes.
The plan opens in the browser's language and stays there for a long time. [JavaScript](/topics/lang-javascript) and [TypeScript](/topics/lang-typescript) come first because the coding rounds are written in them, and [the algorithms](/topics/found-dsa) follow for the same reason. Then the page itself: [HTML](/topics/fe-html) and [CSS](/topics/fe-css), the tools that scope and generate styles, and the [browser platform](/topics/fe-browser-platform), where rendering, storage, workers and the security model turn markup into a runtime. [Git](/topics/dev-git), package workspaces and [bundling](/topics/fe-build-tools-concepts) come before [UI framework concepts](/topics/fe-ui-frameworks-concepts), so that state, reconciliation and routing can be discussed without stopping to explain how a module graph is built. The wire sits in the middle of the frontend half rather than at the start of the backend one. [HTTP and TLS](/topics/proto-web-transport), then the API styles with [REST](/topics/proto-rest) at their head, precede [meta-frameworks](/topics/fe-meta-frameworks-concepts) because render modes and data loading are decisions about where a request runs, and precede performance because most of a slow page is on the network. Linting, testing, design and accessibility, then [federated identity](/topics/proto-auth-identity) with application security complete the browser half, and [system design](/topics/found-system-design), with a frontend counterpart beside it, is where that half is judged. Delivery pipelines and the module on handing code to an AI assistant, and checking what comes back, close it. The second half starts over from the ground: CS fundamentals, paradigms, [design principles](/topics/found-design-principles), clean code and patterns, so the server code has a vocabulary before any of it is written. [Web framework concepts](/topics/be-web-frameworks-concepts) are taught without a named framework, as request lifecycle, middleware, binding and error responses, and gRPC, [WebSockets](/topics/proto-websockets) and Server-Sent Events add the API shapes a browser-only engineer rarely meets. [ORM concepts](/topics/be-orm-concepts) sit ahead of the stores on purpose: the application reaches the database through loading strategies and a unit of work, and the [relational concepts](/topics/db-relational-concepts), SQL, document, in-memory and search modules that follow explain what that layer was hiding. Once the stores are in place, the plan leaves the single service behind: architectural styles and [microservices](/topics/found-microservices) first, then the distributed-systems theory that gives the senior design round its trade-offs. Server-side [authentication and authorization](/topics/be-authz) and secret management follow, as the counterpart to the identity protocols met earlier. The plan ends in operations: the Linux host, [Docker](/topics/cloud-docker), and the proxy, broker and service-level questions a full stack engineer meets on call rather than in code, and then the [behavioral round](/topics/found-behavioral) and the loop itself.
Study order opens on by frequency, which on this roadmap interleaves browser and server questions by how often they are asked; keep it there for a generalist posting, and switch to by topics if you would rather finish one half before starting the other. Narrow level to the step the posting names and the one above it: the half the team is short of tends to be examined harder. A frontend engineer moving to full stack should begin at the web framework concepts and work down through the ORM and database modules; the browser half will be revision. A backend engineer should do the reverse, starting from the browser platform and the UI framework concepts, and take HTML and CSS seriously, because a layout bug in the practical round is as visible as a slow query. For a junior, the JavaScript runtime, HTTP and REST come first, with importance raised to must know; the rest can wait until those hold under follow-up questions. Seniors are usually hired for the design round and the production scenarios, so the architecture, distributed systems and operations modules are where their hours go furthest. This plan names no server runtime and no UI framework; the framework modules on both sides are concept modules. For a stack that is JavaScript end to end, the [JS Full Stack Developer roadmap](/roadmaps/javascript-full-stack) commits both halves to the language and its tools. If the server is on the JVM, the [Java Backend Developer roadmap](/roadmaps/java-developer) carries the Spring and persistence questions this plan leaves to its framework-neutral modules.
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.
Full stack loops usually run three to five rounds: a coding screen in JavaScript or TypeScript, a practical round that builds one small feature end to end, an endpoint and the form or list that calls it, a technical conversation that leans toward whichever half the team is short of, and a behavioral interview, with a design round added once the posting is middle or above. The practical round carries the most weight, because it shows whether you hold both halves in your head at once or switch between two separate skill sets.
The questions sit on the boundary. A fetch from the page is blocked while the same request from curl succeeds: which party refused it, and what does the preflight ask the server to declare? A list page issues one query per row, once in an ORM and once in a GraphQL resolver, and the fix has a different name on each side. A retried POST creates two orders. A page renders on the server, then the browser warns that the markup it hydrated did not match.
What separates candidates is knowing which side owns a symptom. Faced with a list that is stale after a save, a weaker answer adds a refresh on the client; a stronger one asks whether the client cache, a Cache-Control header, a CDN or a read replica is serving the old row, and fixes it where it lives. Senior loops push the same scenarios into production: a token stored where any script on the origin can read it, or a deploy in which the new frontend talks to the old API for a few minutes.
The plan opens in the browser's language and stays there for a long time. JavaScript and TypeScript come first because the coding rounds are written in them, and the algorithms follow for the same reason. Then the page itself: HTML and CSS, the tools that scope and generate styles, and the browser platform, where rendering, storage, workers and the security model turn markup into a runtime. Git, package workspaces and bundling come before UI framework concepts, so that state, reconciliation and routing can be discussed without stopping to explain how a module graph is built.
The wire sits in the middle of the frontend half rather than at the start of the backend one. HTTP and TLS, then the API styles with REST at their head, precede meta-frameworks because render modes and data loading are decisions about where a request runs, and precede performance because most of a slow page is on the network. Linting, testing, design and accessibility, then federated identity with application security complete the browser half, and system design, with a frontend counterpart beside it, is where that half is judged. Delivery pipelines and the module on handing code to an AI assistant, and checking what comes back, close it.
The second half starts over from the ground: CS fundamentals, paradigms, design principles, clean code and patterns, so the server code has a vocabulary before any of it is written. Web framework concepts are taught without a named framework, as request lifecycle, middleware, binding and error responses, and gRPC, WebSockets and Server-Sent Events add the API shapes a browser-only engineer rarely meets. ORM concepts sit ahead of the stores on purpose: the application reaches the database through loading strategies and a unit of work, and the relational concepts, SQL, document, in-memory and search modules that follow explain what that layer was hiding.
Once the stores are in place, the plan leaves the single service behind: architectural styles and microservices first, then the distributed-systems theory that gives the senior design round its trade-offs. Server-side authentication and authorization and secret management follow, as the counterpart to the identity protocols met earlier. The plan ends in operations: the Linux host, Docker, and the proxy, broker and service-level questions a full stack engineer meets on call rather than in code, and then the behavioral round and the loop itself.
Study order opens on by frequency, which on this roadmap interleaves browser and server questions by how often they are asked; keep it there for a generalist posting, and switch to by topics if you would rather finish one half before starting the other. Narrow level to the step the posting names and the one above it: the half the team is short of tends to be examined harder.
A frontend engineer moving to full stack should begin at the web framework concepts and work down through the ORM and database modules; the browser half will be revision. A backend engineer should do the reverse, starting from the browser platform and the UI framework concepts, and take HTML and CSS seriously, because a layout bug in the practical round is as visible as a slow query. For a junior, the JavaScript runtime, HTTP and REST come first, with importance raised to must know; the rest can wait until those hold under follow-up questions. Seniors are usually hired for the design round and the production scenarios, so the architecture, distributed systems and operations modules are where their hours go furthest.
This plan names no server runtime and no UI framework; the framework modules on both sides are concept modules. For a stack that is JavaScript end to end, the JS Full Stack Developer roadmap commits both halves to the language and its tools. If the server is on the JVM, the Java Backend Developer roadmap carries the Spring and persistence questions this plan leaves to its framework-neutral modules.