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 forward deployed engineer interviews: scoping and shipping software inside a customer's systems. Covers full-stack and data integration, cloud delivery, LLM apps, and discovery.
11526 of 11526 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 11526 new. 0 cut, outside your plan.
A customer scenario is the round to prepare for: an ambiguous brief, often with an interviewer playing the customer, where you are judged on the questions you ask before proposing anything, on what you cut from scope, and on what the first version will prove. The rest of the loop is more familiar: a practical coding round, more often a small working application than an algorithm puzzle, a system design conversation that middle and senior loops add, and a behavioral conversation about working alone inside someone else's organization. The technical rounds take their examples from the field. The customer's network blocks outbound traffic, so where does the model run? Their sign-on is SAML and your application speaks OpenID Connect; what sits between the two? A retrieval pipeline over their documents keeps answering from last year's policy. Interviewers want the mechanism each time: a model served inside their network, an identity broker in front of the application, a metadata filter on the retrieved chunks rather than a longer prompt. Two candidates who both built the demo are separated by what they built it to find out. One shows the feature working on sample data. The other names the decision the customer will make with it, what runs on the customer's hardware and what on yours, which parts are a prototype meant to be thrown away, and how the pilot will be measured before anyone agrees to extend it.
Two foundations lead, ahead of the algorithms: [concurrency](/topics/found-concurrency) and [serialization](/topics/found-serialization), because many of the integration failures an interviewer describes come down to one of them, two workers updating the same record or a payload whose schema changed under a consumer that was still running. Algorithms and software design follow for the coding round, then the shell and Git, since the code you ship usually runs on a host you do not own, behind someone else's proxy and change process. The application stretch stays at the level of concepts on purpose. The customer's estate picks the framework, so [UI framework concepts](/topics/fe-ui-frameworks-concepts) and [web framework concepts](/topics/be-web-frameworks-concepts) stand in for any single product, with HTML, CSS and the browser underneath and data access behind the server. Then the plan turns to the wire, where the customer's systems set the terms rather than you: HTTP, TLS and the proxies in between; API styles that run from REST and [GraphQL](/topics/proto-graphql) back to SOAP and OData for what an older estate still exposes; and [federated identity](/topics/proto-auth-identity) for the corporate sign-on your application has to accept. Data comes after the contracts that carry it. The stores run from [relational concepts](/topics/db-relational-concepts) and SQL through document, cache, search and analytical engines, and the integration module is about moving a customer's data without breaking it: [change data capture](/topics/data-cdc), reruns that are safe to repeat, and [governance](/topics/data-governance), where personal data is classified before any of it reaches a model. Testing and security close the build half, and security leans on secret management because the credentials you hold are the customer's. Delivery moves the pilot from your laptop into the customer's account: containers, cloud platform concepts with serverless beside them, [infrastructure as code](/topics/cloud-iac-concepts) so the environment can be rebuilt after you leave, a pipeline, and telemetry with service levels that decide when a failure is worth waking someone for. Applied AI comes late because by then a model is one more dependency with an API, a store and a deployment. [LLM methods](/topics/found-ai-llm-methods) supply the vocabulary, the choice between [calling a hosted model and running open weights](/topics/found-ai-engineering-model-sourcing-hosted-vs-open) included, model hubs follow, and the retrieval module connects a model to the customer's documents and systems through a [vector store](/topics/db-vector-concepts) and the customer's own tools served over MCP, applying the [RAG and agent patterns](/topics/found-rag) those methods teach. A pilot is rarely signed off on a demo nobody can score, so [evaluation](/topics/found-ai-engineering-evaluation) is taught with those methods too, and the testing module back in the build half has already treated an [AI-powered feature](/topics/found-testing-ai-systems) as something with test cases and a release call. [Inference hosting](/topics/ai-serving-concepts) answers the site where data may not leave the network, so the model has to come to it, and the model lifecycle module meets customers who already train their own: an experiment tracker and registry, data versioning, feature stores, drift monitoring and the explainers a risk team asks for. Working with a coding assistant ends the stretch. The last stretch is the senior one. Software architecture, event-driven design, [system design](/topics/found-system-design), distributed-systems theory and resilience patterns supply the design round, and [solution architecture](/topics/found-solution-architecture) turns it toward the customer: requirements, build against buy, what the pilot costs to run. Business alignment, capability mapping and the delivery methods follow, since on site you are often the one setting the cadence, and the [behavioral round](/topics/found-behavioral) closes the plan.
Which half of this job you already do decides where to begin. Full-stack engineers moving toward customer-facing AI work can take the application and storage stretches at speed and spend their hours on the contracts, the integration module and applied AI, the parts of a customer's estate they have not had to integrate with before. Data scientists and ML engineers moving the other way should clear the coding-round modules first and then work forward from the shell, since the AI stretch will feel familiar and the delivery questions will not. Either way, solution architecture earns a second pass: the customer scenario round is a scoping exercise with a person across the table. Two weeks out, the controls do the cutting: narrow level to the band the posting names and raise importance to must know; study order needs no change, since it opens at by frequency. A quarter out, study by topics instead, and put the extra weeks into a small pilot built against a dataset you did not prepare, because the scenario round rewards candidates who have already been surprised by real data. No module teaches a general-purpose programming language; SQL is the one query language the plan carries. The coding rounds will still be written in a general-purpose language, most often Python or TypeScript, and the [Python](/roadmaps/python) and [TypeScript](/roadmaps/typescript) roadmaps carry the depth this one leaves out.
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.
A customer scenario is the round to prepare for: an ambiguous brief, often with an interviewer playing the customer, where you are judged on the questions you ask before proposing anything, on what you cut from scope, and on what the first version will prove. The rest of the loop is more familiar: a practical coding round, more often a small working application than an algorithm puzzle, a system design conversation that middle and senior loops add, and a behavioral conversation about working alone inside someone else's organization.
The technical rounds take their examples from the field. The customer's network blocks outbound traffic, so where does the model run? Their sign-on is SAML and your application speaks OpenID Connect; what sits between the two? A retrieval pipeline over their documents keeps answering from last year's policy. Interviewers want the mechanism each time: a model served inside their network, an identity broker in front of the application, a metadata filter on the retrieved chunks rather than a longer prompt.
Two candidates who both built the demo are separated by what they built it to find out. One shows the feature working on sample data. The other names the decision the customer will make with it, what runs on the customer's hardware and what on yours, which parts are a prototype meant to be thrown away, and how the pilot will be measured before anyone agrees to extend it.
Two foundations lead, ahead of the algorithms: concurrency and serialization, because many of the integration failures an interviewer describes come down to one of them, two workers updating the same record or a payload whose schema changed under a consumer that was still running. Algorithms and software design follow for the coding round, then the shell and Git, since the code you ship usually runs on a host you do not own, behind someone else's proxy and change process.
The application stretch stays at the level of concepts on purpose. The customer's estate picks the framework, so UI framework concepts and web framework concepts stand in for any single product, with HTML, CSS and the browser underneath and data access behind the server. Then the plan turns to the wire, where the customer's systems set the terms rather than you: HTTP, TLS and the proxies in between; API styles that run from REST and GraphQL back to SOAP and OData for what an older estate still exposes; and federated identity for the corporate sign-on your application has to accept.
Data comes after the contracts that carry it. The stores run from relational concepts and SQL through document, cache, search and analytical engines, and the integration module is about moving a customer's data without breaking it: change data capture, reruns that are safe to repeat, and governance, where personal data is classified before any of it reaches a model. Testing and security close the build half, and security leans on secret management because the credentials you hold are the customer's.
Delivery moves the pilot from your laptop into the customer's account: containers, cloud platform concepts with serverless beside them, infrastructure as code so the environment can be rebuilt after you leave, a pipeline, and telemetry with service levels that decide when a failure is worth waking someone for.
Applied AI comes late because by then a model is one more dependency with an API, a store and a deployment. LLM methods supply the vocabulary, the choice between calling a hosted model and running open weights included, model hubs follow, and the retrieval module connects a model to the customer's documents and systems through a vector store and the customer's own tools served over MCP, applying the RAG and agent patterns those methods teach. A pilot is rarely signed off on a demo nobody can score, so evaluation is taught with those methods too, and the testing module back in the build half has already treated an AI-powered feature as something with test cases and a release call. Inference hosting answers the site where data may not leave the network, so the model has to come to it, and the model lifecycle module meets customers who already train their own: an experiment tracker and registry, data versioning, feature stores, drift monitoring and the explainers a risk team asks for. Working with a coding assistant ends the stretch.
The last stretch is the senior one. Software architecture, event-driven design, system design, distributed-systems theory and resilience patterns supply the design round, and solution architecture turns it toward the customer: requirements, build against buy, what the pilot costs to run. Business alignment, capability mapping and the delivery methods follow, since on site you are often the one setting the cadence, and the behavioral round closes the plan.
Which half of this job you already do decides where to begin. Full-stack engineers moving toward customer-facing AI work can take the application and storage stretches at speed and spend their hours on the contracts, the integration module and applied AI, the parts of a customer's estate they have not had to integrate with before. Data scientists and ML engineers moving the other way should clear the coding-round modules first and then work forward from the shell, since the AI stretch will feel familiar and the delivery questions will not. Either way, solution architecture earns a second pass: the customer scenario round is a scoping exercise with a person across the table.
Two weeks out, the controls do the cutting: narrow level to the band the posting names and raise importance to must know; study order needs no change, since it opens at by frequency. A quarter out, study by topics instead, and put the extra weeks into a small pilot built against a dataset you did not prepare, because the scenario round rewards candidates who have already been surprised by real data.
No module teaches a general-purpose programming language; SQL is the one query language the plan carries. The coding rounds will still be written in a general-purpose language, most often Python or TypeScript, and the Python and TypeScript roadmaps carry the depth this one leaves out.