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.
Prepares you for software architect interviews, where you defend system designs and trade-offs end to end. Covers architecture foundations, APIs and messaging, data, security, and cloud operations.
10835 of 10835 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 10835 new. 0 cut, outside your plan.
An architect loop spends less of its time on code and more on judgement, and most of its rounds are conversations. Expect a screen about systems you have shaped, often a coding round kept from the engineering track, then one or two design rounds: a brief to design from, an existing architecture to critique, or a past project of yours presented to a panel that interrupts. A stakeholder or behavioral round usually closes the loop, and here it is no formality: it tests how you move teams you do not manage. The design rounds turn on specific decisions. An order and its payment live in two services: two-phase commit, a saga with compensating steps, or an outbox table relayed to a broker, and what does each leave inconsistent, for how long? The broker delivers at least once: which consumer absorbs the duplicate? A region fails and DNS is meant to steer traffic away: how long do resolvers keep returning the old answer? Access tokens are self-contained JWTs: how do you revoke one before it expires? A weaker answer draws the target architecture and defends it as drawn. A stronger one names the quality attribute behind each choice, the option it turned down, what the decision will cost to reverse and where it gets recorded, then explains how the running system reaches that target while it keeps serving traffic, one route at a time behind a facade rather than in a single cutover.
Before any architecture, the plan lays down the theory that design arguments lean on. The computer science module earns its place through concurrency, memory and [serialization](/topics/found-serialization), the section on changing a message format while services built against the old one are still deployed. Paradigms follow, since reactive programming resurfaces at system scale in event-driven designs, and then the [algorithms](/topics/found-dsa) for the coding round many architect loops keep. [Design and architecture](/topics/found-design-architecture) is the centre of the plan and comes early on purpose: from principles up through the distributed sections and [bounded contexts](/topics/found-ddd) to enterprise architecture, it supplies the vocabulary the later modules are read in. Process and UML follow as the way a decision is planned and drawn for others, and testing arrives as a strategy rather than a technique, with [non-functional testing](/topics/found-test-types) holding a system to the quality attributes its design promised. The plan then descends to the substrate those decisions rest on. Networking follows a connection through TCP from handshake to teardown before [TLS and HTTP](/topics/proto-web-transport) ride on it, and DNS ends on [steering and failover](/topics/proto-dns-traffic-steering), because many regional failovers begin with a changed DNS answer and caching decides how fast clients see it. With the wire in place, the plan turns to how services talk across it: [API styles](/topics/proto-api-styles) for the synchronous half, then messaging, which takes the delivery guarantees an application relies on as settled in the design stretch and turns to [running the broker](/topics/cloud-messaging-concepts) that has to keep them. Data architecture starts from the [relational model and its engine](/topics/db-relational-concepts) and takes the other store shapes in turn, each naming what its store gives up for what it gains, before [processing engines](/topics/data-processing-concepts) move data between them. Security comes after the data on purpose. Application security and [federated identity](/topics/proto-auth-identity) lead, directory protocols and secret management follow, and [GDPR](/topics/proto-gdpr) comes last, because in a design review it becomes a placement question: which stores may hold personal data, and across which borders it may be copied, can only be argued once every store is on the table. The cloud stretch puts the design into production and then watches it run, ending in [SRE practices](/topics/cloud-sre-practices), where an architecture is held to its service levels. Git and [GitHub](/topics/dev-github) come late because at this level they are governance: the workflows and review rules that let many teams change one estate. The plan closes on the people side: [the behavioral conversation](/topics/found-behavioral) and how the loop itself is run.
Architect roles are hired near the top of the level range, so trim level from below to where the posting starts; the junior questions mostly cover ground you already stand on. A senior engineer stepping into a first architect title has depth in one or two stretches and gaps in the rest. With a few weeks, by frequency suits that gap better than a tour of your own choosing: it surfaces the most-asked questions from every stretch, including the ones you have never had to own. An enterprise or solution architect from the governance side usually arrives the other way round: strong in design and enterprise architecture, thin on the wire and on operations, where a panel asks about retransmission timeouts or a consumer group falling behind. Given months, by topics is the better study order, since the security and cloud stretches assume the data stretch before them. Keep a decision record for one system you know as you go, adding an entry whenever a module raises a question it never answered. No module teaches a programming language; a coding round is answered in one you bring. Nor does the plan rehearse the design round itself, taking a named product from requirements and rough capacity numbers to a defended design in one sitting. The [System Design roadmap](/roadmaps/system-design) drills that round.
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.
An architect loop spends less of its time on code and more on judgement, and most of its rounds are conversations. Expect a screen about systems you have shaped, often a coding round kept from the engineering track, then one or two design rounds: a brief to design from, an existing architecture to critique, or a past project of yours presented to a panel that interrupts. A stakeholder or behavioral round usually closes the loop, and here it is no formality: it tests how you move teams you do not manage.
The design rounds turn on specific decisions. An order and its payment live in two services: two-phase commit, a saga with compensating steps, or an outbox table relayed to a broker, and what does each leave inconsistent, for how long? The broker delivers at least once: which consumer absorbs the duplicate? A region fails and DNS is meant to steer traffic away: how long do resolvers keep returning the old answer? Access tokens are self-contained JWTs: how do you revoke one before it expires?
A weaker answer draws the target architecture and defends it as drawn. A stronger one names the quality attribute behind each choice, the option it turned down, what the decision will cost to reverse and where it gets recorded, then explains how the running system reaches that target while it keeps serving traffic, one route at a time behind a facade rather than in a single cutover.
Before any architecture, the plan lays down the theory that design arguments lean on. The computer science module earns its place through concurrency, memory and serialization, the section on changing a message format while services built against the old one are still deployed. Paradigms follow, since reactive programming resurfaces at system scale in event-driven designs, and then the algorithms for the coding round many architect loops keep.
Design and architecture is the centre of the plan and comes early on purpose: from principles up through the distributed sections and bounded contexts to enterprise architecture, it supplies the vocabulary the later modules are read in. Process and UML follow as the way a decision is planned and drawn for others, and testing arrives as a strategy rather than a technique, with non-functional testing holding a system to the quality attributes its design promised.
The plan then descends to the substrate those decisions rest on. Networking follows a connection through TCP from handshake to teardown before TLS and HTTP ride on it, and DNS ends on steering and failover, because many regional failovers begin with a changed DNS answer and caching decides how fast clients see it. With the wire in place, the plan turns to how services talk across it: API styles for the synchronous half, then messaging, which takes the delivery guarantees an application relies on as settled in the design stretch and turns to running the broker that has to keep them.
Data architecture starts from the relational model and its engine and takes the other store shapes in turn, each naming what its store gives up for what it gains, before processing engines move data between them. Security comes after the data on purpose. Application security and federated identity lead, directory protocols and secret management follow, and GDPR comes last, because in a design review it becomes a placement question: which stores may hold personal data, and across which borders it may be copied, can only be argued once every store is on the table.
The cloud stretch puts the design into production and then watches it run, ending in SRE practices, where an architecture is held to its service levels. Git and GitHub come late because at this level they are governance: the workflows and review rules that let many teams change one estate. The plan closes on the people side: the behavioral conversation and how the loop itself is run.
Architect roles are hired near the top of the level range, so trim level from below to where the posting starts; the junior questions mostly cover ground you already stand on. A senior engineer stepping into a first architect title has depth in one or two stretches and gaps in the rest. With a few weeks, by frequency suits that gap better than a tour of your own choosing: it surfaces the most-asked questions from every stretch, including the ones you have never had to own.
An enterprise or solution architect from the governance side usually arrives the other way round: strong in design and enterprise architecture, thin on the wire and on operations, where a panel asks about retransmission timeouts or a consumer group falling behind. Given months, by topics is the better study order, since the security and cloud stretches assume the data stretch before them. Keep a decision record for one system you know as you go, adding an entry whenever a module raises a question it never answered.
No module teaches a programming language; a coding round is answered in one you bring. Nor does the plan rehearse the design round itself, taking a named product from requirements and rough capacity numbers to a defended design in one sitting. The System Design roadmap drills that round.