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.
Step into blockchain developer interviews knowing smart contracts, consensus, and dApps. Covers Solidity and Rust, chain security and auditing, DeFi, on-chain infrastructure, and system design.
8458 of 8458 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 8458 new. 0 cut, outside your plan.
Nearly every question in a blockchain loop has an adversary in it, because the code under discussion holds other people's money and runs where anyone can call it. The usual loop is a coding round, a contract exercise with its tests, one or two technical conversations and a behavioral round, with a design round added at middle level and above, around a protocol, a bridge or an indexer. Application teams usually add a review round, where you are handed a contract and asked what is wrong with it; protocol teams add a conversation on consensus and the node client instead. The review round does most of the sorting. The contract usually hides an external call before the state update it depends on, an initializer anyone can call, a price read from a pool's reserves in the same transaction, or an owner check written against `tx.origin`. Finding it is the entry ticket; the follow-up asks what your fix removes. The technical conversations go to mechanism: where a `mapping` entry lives in storage and why an upgrade that reorders state variables corrupts a proxy, what a pending transaction in the public mempool reveals to a searcher, and why a swap therefore carries a deadline and a minimum output. Seniority shows in what you do with uncertainty: how an exchange decides a deposit is final under probabilistic confirmation and under checkpoint finality, why a withdrawal from an optimistic rollup waits about a week while a validity proof settles as soon as it verifies, and what a user can still do when the sequencer stops.
The opening stretch has no chain in it on purpose. Computer science fundamentals and the [algorithms](/topics/found-dsa) that score the coding round come first, then [application security](/topics/found-appsec), whose cryptography section, hashing, signatures and randomness, is the material a chain is built from. The supporting languages follow, [JavaScript](/topics/lang-javascript) and TypeScript because tests, deployment scripts and dApp code are written in them, and [Python](/topics/lang-python), which Vyper resembles and Brownie is written in. The chain languages come after: [Solidity](/topics/lang-solidity), Vyper beside it, [Rust](/topics/lang-rust) for Solana programs and Substrate chains, and [Go](/topics/lang-go), which Geth, an execution client the plan reaches later, is written in. Then the plan turns from code to the machine it runs on. General [distributed-systems theory](/topics/found-distributed-systems-core-theory) comes before the [chain consensus protocols](/topics/proto-blockchain-consensus), because proof of work and proof of stake are particular answers to a problem replication and Byzantine fault tolerance already state. The [networks](/topics/bc-networks) put names and trade-offs on those answers, and the [scaling mechanics](/topics/bc-scaling-l2) explain the layer above them. With a language and a chain in hand, the plan takes practice and risk together: the [frameworks](/topics/bc-dev-tooling) you test and fuzz with, then [contract security](/topics/bc-contract-security), from reentrancy to the audit process. [Tokens and DeFi](/topics/bc-tokens-defi) follow the security module rather than precede it, since a flash loan, an AMM curve or a governance vote is also an attack surface the previous module named. A short chain-neutral stretch on version control, repository organization and [Linux](/topics/os-linux) sits in the middle; the Linux material is what running a node later requires. On-chain infrastructure is the plan's longest look beneath the application: [wallets, accounts and the transaction lifecycle](/topics/bc-wallets-accounts), then the client libraries that submit a transaction, the [node implementations](/topics/bc-nodes) that execute it, and the [oracles and RPC providers](/topics/bc-oracles-infra) a dApp depends on without owning. [UI framework concepts](/topics/fe-ui-frameworks-concepts) come after, because the frontend is where wallet connectivity becomes a screen. The plan closes on the senior rounds: [system design](/topics/found-system-design), working with AI coding assistants, and the [behavioral interview](/topics/found-behavioral), paired with the anatomy of the loop from screen to offer.
Where you enter depends on which half of the plan you already own. A web developer moving to contracts can skip the supporting languages and go from the security foundations straight into Solidity, the tooling and contract security, where the review round is won. A backend or distributed-systems engineer heading for protocol or client work should take the distributed theory, the chain consensus protocols, Rust or Go and the node implementations in that order, because a protocol interview begins where an application one ends. Someone new to both halves goes top to bottom with study order switched to by topics, and writes one small contract with its tests before reaching the DeFi module, so the attack names have something to attach to. When the date is fixed, let the posting set the controls: narrow level to the band it hires at, raise importance to must know, and leave study order on by frequency. What survives is mostly Solidity, security and the transaction lifecycle. Senior candidates gain most in scaling, security and system design, where the questions carry numbers: a challenge window, a block's gas limit, a confirmation depth. Indexers, APIs and the databases most dApps keep off-chain have no module here; that tier belongs to the [Backend Developer roadmap](/roadmaps/backend). For a Solana or Substrate team, where Rust is the working language rather than one hub beside Solidity, the [Rust roadmap](/roadmaps/rust) takes the language further than this plan does.
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.
Nearly every question in a blockchain loop has an adversary in it, because the code under discussion holds other people's money and runs where anyone can call it. The usual loop is a coding round, a contract exercise with its tests, one or two technical conversations and a behavioral round, with a design round added at middle level and above, around a protocol, a bridge or an indexer. Application teams usually add a review round, where you are handed a contract and asked what is wrong with it; protocol teams add a conversation on consensus and the node client instead.
The review round does most of the sorting. The contract usually hides an external call before the state update it depends on, an initializer anyone can call, a price read from a pool's reserves in the same transaction, or an owner check written against tx.origin. Finding it is the entry ticket; the follow-up asks what your fix removes. The technical conversations go to mechanism: where a mapping entry lives in storage and why an upgrade that reorders state variables corrupts a proxy, what a pending transaction in the public mempool reveals to a searcher, and why a swap therefore carries a deadline and a minimum output.
Seniority shows in what you do with uncertainty: how an exchange decides a deposit is final under probabilistic confirmation and under checkpoint finality, why a withdrawal from an optimistic rollup waits about a week while a validity proof settles as soon as it verifies, and what a user can still do when the sequencer stops.
The opening stretch has no chain in it on purpose. Computer science fundamentals and the algorithms that score the coding round come first, then application security, whose cryptography section, hashing, signatures and randomness, is the material a chain is built from. The supporting languages follow, JavaScript and TypeScript because tests, deployment scripts and dApp code are written in them, and Python, which Vyper resembles and Brownie is written in. The chain languages come after: Solidity, Vyper beside it, Rust for Solana programs and Substrate chains, and Go, which Geth, an execution client the plan reaches later, is written in.
Then the plan turns from code to the machine it runs on. General distributed-systems theory comes before the chain consensus protocols, because proof of work and proof of stake are particular answers to a problem replication and Byzantine fault tolerance already state. The networks put names and trade-offs on those answers, and the scaling mechanics explain the layer above them.
With a language and a chain in hand, the plan takes practice and risk together: the frameworks you test and fuzz with, then contract security, from reentrancy to the audit process. Tokens and DeFi follow the security module rather than precede it, since a flash loan, an AMM curve or a governance vote is also an attack surface the previous module named. A short chain-neutral stretch on version control, repository organization and Linux sits in the middle; the Linux material is what running a node later requires.
On-chain infrastructure is the plan's longest look beneath the application: wallets, accounts and the transaction lifecycle, then the client libraries that submit a transaction, the node implementations that execute it, and the oracles and RPC providers a dApp depends on without owning. UI framework concepts come after, because the frontend is where wallet connectivity becomes a screen. The plan closes on the senior rounds: system design, working with AI coding assistants, and the behavioral interview, paired with the anatomy of the loop from screen to offer.
Where you enter depends on which half of the plan you already own. A web developer moving to contracts can skip the supporting languages and go from the security foundations straight into Solidity, the tooling and contract security, where the review round is won. A backend or distributed-systems engineer heading for protocol or client work should take the distributed theory, the chain consensus protocols, Rust or Go and the node implementations in that order, because a protocol interview begins where an application one ends. Someone new to both halves goes top to bottom with study order switched to by topics, and writes one small contract with its tests before reaching the DeFi module, so the attack names have something to attach to.
When the date is fixed, let the posting set the controls: narrow level to the band it hires at, raise importance to must know, and leave study order on by frequency. What survives is mostly Solidity, security and the transaction lifecycle. Senior candidates gain most in scaling, security and system design, where the questions carry numbers: a challenge window, a block's gas limit, a confirmation depth.
Indexers, APIs and the databases most dApps keep off-chain have no module here; that tier belongs to the Backend Developer roadmap. For a Solana or Substrate team, where Rust is the working language rather than one hub beside Solidity, the Rust roadmap takes the language further than this plan does.