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.
Defend design decisions at interview depth, from a single class to a whole system. Covers paradigms and OOP, clean code, principles and patterns, architectural styles, domain modeling and distributed design.
2371 of 2371 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 2371 new. 0 cut, outside your plan.
Design questions surface in several rounds of a loop, under different names. An object-oriented design round, common early in a career, hands you a small domain such as a library's loans and watches where state and behavior land. A refactoring exercise shows you a class that switches on a type code and asks what you would change first. From middle level up, the system design round reaches the large end of this subject: where service boundaries go, what travels as an event, what happens when a dependency stalls. Architect loops add a walkthrough of a system you built, where each decision you mention invites the question of what it cost. Principles are tested through their counterexamples. Why does a `Square` that extends a mutable `Rectangle` break code written against the parent? Why does a service that writes to its database and then publishes to a broker lose events when it crashes between the two, and how does an outbox table close that gap? What stops a retried payment from charging twice? Level shows in the direction of the answer. Lower in the range, naming the principle a design follows is enough. Higher up, candidates name the force that made it matter, the option they rejected and the change that would reverse the decision; at principal level the question is often whether a structure should exist at all, such as a split into services the organization cannot operate.
The plan opens beneath objects, with [imperative](/topics/found-programming-paradigms-imperative) and declarative styles and structured programming, because the earliest design choices are about how much control flow and mutable state a reader must hold in their head. [Object-oriented programming](/topics/found-oop) follows, and its load-bearing pages are [coupling and cohesion](/topics/found-paradigms-oop-coupling-cohesion): the later modules, up to service boundaries, keep measuring in those two units. The functional stretch that closes it is no detour: [pure functions](/topics/found-paradigms-fp-pure-functions) return as the reason architectures keep I/O at the edge of the domain, and immutability as the reason a recorded event can be shared and replayed safely. Code-Level Design starts from symptoms. [Smells and refactoring](/topics/found-clean-code-smells-refactoring) come before [design principles](/topics/found-design-principles), so each principle arrives explaining a problem you have already seen, and [design patterns](/topics/found-design-patterns) follow as named answers to the same forces. SOLID meets you twice, first as object-oriented technique, then beside GRASP and the rules for packages and components. [Codebase organization](/topics/found-codebase-organization) ends the module, the first step above the class. Architecture Practice comes before any style, because choosing between structures needs a vocabulary for choosing. [Software architecture](/topics/found-software-architecture) is about decisions costly to undo: the qualities they serve, how they are written down, how a design is judged and changed; [enterprise and solution architecture](/topics/found-enterprise-architecture) carries that discipline above a single system. Styles & Patterns then applies it to the [catalog of styles](/topics/found-architectural-styles). Two styles get topics of their own beside it, because so many design conversations end up there: [microservices](/topics/found-microservices), where the subject is what a split costs, and [event-driven architecture](/topics/found-eda), from delivery guarantees through CQRS to event sourcing. Domain modeling comes after both, and answers the question they leave open: where the boundaries go. [Strategic design](/topics/found-ddd-strategic-design) draws the bounded contexts that usually become a service's edge; tactical design shapes aggregates and the domain events a broker will carry; patterns such as the repository and the unit of work tie the model to its storage. Scale & Resilience closes the plan where the system no longer fits on one machine: [distributed theory](/topics/found-distributed-systems-core-theory) first, since consistency models and scalable design both rest on it, then the [cloud design patterns](/topics/found-cloud-design-patterns), led by the timeouts, retries and circuit breakers that guard the calls a split into services made remote.
Which half of the plan matters depends on the round. An object-oriented design round lives mostly in the first two modules; model one small domain on paper and test each choice against the principles as they arrive. If you still cannot say why that `Square` should not extend `Rectangle`, the distributed modules will not hold either. With study order switched to by topics, the queue walks the plan from the top, and a saga question waits until the substitution ones are behind you. A senior engineer two weeks from a system design round needs the opposite: a level range that starts at senior trims the opening modules to the questions that ask why, and leaves the hours for boundaries and failure. Engineers stepping toward an architect title usually find their gap in Architecture Practice, not the styles: they have built event-driven systems but never written down the option they turned away. Write a decision record for a system you know, alternatives and reversal condition included. This is one skill, not a whole loop: the plan has no algorithms and no behavioral interview. The [Software Architect roadmap](/roadmaps/software-architect) sets this material inside the full architect loop, and a backend candidate whose design round follows a coding screen will find that screen in [Data Structures & Algorithms](/roadmaps/datastructures-and-algorithms).
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.
Design questions surface in several rounds of a loop, under different names. An object-oriented design round, common early in a career, hands you a small domain such as a library's loans and watches where state and behavior land. A refactoring exercise shows you a class that switches on a type code and asks what you would change first. From middle level up, the system design round reaches the large end of this subject: where service boundaries go, what travels as an event, what happens when a dependency stalls. Architect loops add a walkthrough of a system you built, where each decision you mention invites the question of what it cost.
Principles are tested through their counterexamples. Why does a Square that extends a mutable Rectangle break code written against the parent? Why does a service that writes to its database and then publishes to a broker lose events when it crashes between the two, and how does an outbox table close that gap? What stops a retried payment from charging twice?
Level shows in the direction of the answer. Lower in the range, naming the principle a design follows is enough. Higher up, candidates name the force that made it matter, the option they rejected and the change that would reverse the decision; at principal level the question is often whether a structure should exist at all, such as a split into services the organization cannot operate.
The plan opens beneath objects, with imperative and declarative styles and structured programming, because the earliest design choices are about how much control flow and mutable state a reader must hold in their head. Object-oriented programming follows, and its load-bearing pages are coupling and cohesion: the later modules, up to service boundaries, keep measuring in those two units. The functional stretch that closes it is no detour: pure functions return as the reason architectures keep I/O at the edge of the domain, and immutability as the reason a recorded event can be shared and replayed safely.
Code-Level Design starts from symptoms. Smells and refactoring come before design principles, so each principle arrives explaining a problem you have already seen, and design patterns follow as named answers to the same forces. SOLID meets you twice, first as object-oriented technique, then beside GRASP and the rules for packages and components. Codebase organization ends the module, the first step above the class.
Architecture Practice comes before any style, because choosing between structures needs a vocabulary for choosing. Software architecture is about decisions costly to undo: the qualities they serve, how they are written down, how a design is judged and changed; enterprise and solution architecture carries that discipline above a single system. Styles & Patterns then applies it to the catalog of styles. Two styles get topics of their own beside it, because so many design conversations end up there: microservices, where the subject is what a split costs, and event-driven architecture, from delivery guarantees through CQRS to event sourcing.
Domain modeling comes after both, and answers the question they leave open: where the boundaries go. Strategic design draws the bounded contexts that usually become a service's edge; tactical design shapes aggregates and the domain events a broker will carry; patterns such as the repository and the unit of work tie the model to its storage. Scale & Resilience closes the plan where the system no longer fits on one machine: distributed theory first, since consistency models and scalable design both rest on it, then the cloud design patterns, led by the timeouts, retries and circuit breakers that guard the calls a split into services made remote.
Which half of the plan matters depends on the round. An object-oriented design round lives mostly in the first two modules; model one small domain on paper and test each choice against the principles as they arrive. If you still cannot say why that Square should not extend Rectangle, the distributed modules will not hold either. With study order switched to by topics, the queue walks the plan from the top, and a saga question waits until the substitution ones are behind you.
A senior engineer two weeks from a system design round needs the opposite: a level range that starts at senior trims the opening modules to the questions that ask why, and leaves the hours for boundaries and failure.
Engineers stepping toward an architect title usually find their gap in Architecture Practice, not the styles: they have built event-driven systems but never written down the option they turned away. Write a decision record for a system you know, alternatives and reversal condition included.
This is one skill, not a whole loop: the plan has no algorithms and no behavioral interview. The Software Architect roadmap sets this material inside the full architect loop, and a backend candidate whose design round follows a coding screen will find that screen in Data Structures & Algorithms.