Modular vs Monolithic Chains
Every blockchain does four jobs. A monolithic chain does them all itself; a modular stack splits them across specialized layers — and that’s the deep design choice.
We’ve met rollups (lessons 31–32), data availability (33), and bridges (34) as separate gadgets — but they’re actually pieces of one big idea that reorganizes how blockchains are built. Step back and a pattern appears: a blockchain isn’t one job, it’s four jobs bundled together, and the whole scaling debate is really about whether one chain should do all four, or split them up. This is the lens that makes the entire module click. Hold the question: what are the distinct jobs a blockchain performs — and why would splitting them across different layers help (or hurt)?
The four jobs every blockchain does
Under the hood, a blockchain performs four distinct functions. Execution: actually running the transactions and smart contracts (lesson 8) to compute new balances. Settlement: providing the final “this is official and won’t be reversed” anchor, and resolving disputes. Consensus: agreeing on the ordering of transactions (lessons 6–7). Data availability: publishing the data so anyone can verify (lesson 33). Early chains do all four themselves on every node — that’s a monolithic chain (one integrated system). It’s simple and tightly secure, but it means every node must do everything, which is the root of the congestion and the scaling trilemma from lesson 16.
Modular: split the jobs across specialized layers
A modular blockchain takes those four jobs and splits them across specialized layers, each doing one thing well — the classic “separation of concerns.” You’ve already seen this without the name: a rollup (lessons 31–32) is a layer that specializes in execution, doing the heavy transaction-running off to the side, while it leans on the L1 for settlement (anchoring, dispute resolution) and posts to a data-availability layer (lesson 33). Consensus might live on yet another layer. Instead of one chain straining to do all four, you get a stack: many execution layers (rollups) can share one secure settlement + DA base. That’s how a modular design escapes the trilemma’s squeeze — specialization lets each layer scale its own job.
The same transaction, two architectures: • Monolithic: one chain runs your swap, orders it, publishes the data, and finalizes it — all on every node. • Modular: a rollup executes your swap and orders it locally, posts the data to a DA layer, and settles by anchoring to the L1 (which can catch fraud or verify a proof). Four jobs, spread across three specialized systems working together.
The tradeoff: neither is simply “better”
So which wins? Honestly, it’s a genuine tradeoff, not a solved question. Monolithic chains are simpler and have tight, unified security (one system, one trust model, no seams) and low latency within the chain — but they hit a hard capacity ceiling and every user competes for the same block space. Modular stacks scale far better (add more execution layers without touching the base) and let you mix and match — but they’re more complex, introduce seams between layers where things can break (a shaky DA layer, a risky bridge from lesson 34, a centralized rollup sequencer), and spread trust across multiple systems you must each evaluate. The mature takeaway: when you look at any chain or L2, ask which of the four jobs it actually does and which it outsources — that single question tells you its real security model, cuts through the marketing, and ties together everything in this module.
Think of building cars. A monolithic carmaker does everything in one factory — forging metal, making engines, assembling, painting — all under one roof. Simple to coordinate and tightly controlled, but that one factory can only build so many cars, and every model waits in the same line. A modular approach is a supply chain: specialist firms make engines, another does bodies, another paints, assembled at the end. It scales enormously — swap in a better engine supplier, add assembly plants — but now you depend on every link, and a weak supplier or a bad handoff between them can stall or compromise the whole car. Same finished vehicle; a real tradeoff between integrated simplicity and specialized scale.
Reading a chain’s architecture: 1. A classic monolithic L1: does execution, settlement, consensus, and DA itself → simple, unified security, but capacity-capped. 2. A rollup: specializes in execution; outsources settlement + (usually) DA to an L1 → scales, but you must trust the DA layer and the bridge/sequencer. 3. A validium (lesson 33): execution on the rollup, proofs on L1, but DA off-chain → cheapest, but a real trust assumption on availability. 4. For each, the diagnostic is identical: which of the four jobs does it do, and which does it hand off — and therefore who do you trust?
This is the reading. The interactive version — active-recall quiz, a hands-on experiment you run in your own AI, and an earned mastery check — is free in the app.
Start this lesson free →