The Modular Blockchain Thesis: Why Splitting One Chain Into Layers Changes Everything

This article explains the modular blockchain thesis — the idea that blockchains work better when their core jobs are split across specialised layers instead of handled by a single chain. This matters because it's the design philosophy driving almost every major scaling effort in crypto right now, from Ethereum's rollup roadmap to entirely new networks like Celestia. If you don't understand modular design, the current landscape of Layer 2s, data availability layers, and rollups will look like random noise.

Every blockchain, no matter how it's branded, performs four distinct functions. Understanding these is the foundation for everything else.

• Execution — processing transactions and running smart contract logic. When you swap tokens on a DEX, execution is the computation that updates balances.
• Settlement — finalising transactions and resolving disputes. This is where the chain decides that a transaction is irreversibly valid.
• Consensus — getting nodes to agree on the order of transactions. Without this, two people could spend the same funds and no one would know which came first.
• Data availability — making sure the transaction data is published and accessible so anyone can independently verify what happened. This is the least intuitive of the four, and also the most important to the modular thesis.

What this means practically: When someone says a blockchain "scales," they're really saying it found a way to do one or more of these four jobs faster or cheaper — usually by not doing all four itself.

A monolithic blockchain handles all four jobs on a single chain. Bitcoin and Ethereum's base layer (Layer 1) both work this way. Every node processes every transaction, participates in consensus, stores the data, and validates settlement. This is where most explanations go wrong — they frame this as a design flaw. It's not. It's a design trade-off.

• Monolithic chains are simple to reason about: one set of validators, one security model, one fee market.
• The cost is that throughput is bottlenecked by the weakest of the four functions. Ethereum's base layer can handle roughly 15–30 transactions per second — not because execution is slow, but because every node must also store and propagate all the data.
• Raising hardware requirements to increase throughput reduces the number of people who can run a node, which centralises the network. This is the core tension.
• The so-called blockchain trilemma — the observation that it's hard to maximise decentralisation, security, and scalability simultaneously — is really a description of this monolithic constraint.

What this means practically: Monolithic chains don't fail at scaling because of bad engineering. They hit a ceiling imposed by asking every participant to do every job.

The modular blockchain thesis says: stop asking one chain to do all four jobs. Instead, build specialised layers that each handle one or two functions, then compose them into a stack. Each layer can be optimised independently, and the whole system scales further than any monolithic design.

• A rollup is the clearest example. It handles execution off the main chain, bundles hundreds or thousands of transactions into a compressed batch, and posts the result back to a base layer for settlement and data availability.
• The base layer (like Ethereum) stops trying to execute everything itself. Instead, it becomes a settlement and data availability layer — verifying proofs and storing the data rollups need.
• A dedicated data availability layer like Celestia takes this further: it does nothing but make data available and reachable, leaving execution and settlement to other layers entirely.
• This isn't one architecture. It's a design philosophy. Different projects choose different splits depending on what they optimise for.

What this means practically: When you use an Ethereum Layer 2 like Arbitrum or Optimism, you're already using a modular stack — execution happens on the L2, and Ethereum provides settlement, consensus, and data availability underneath.

A modular stack assembles like components, and the order of operations matters because each layer depends on guarantees from the layers below it.

1. User submits a transaction to the execution layer (a rollup or app-specific chain). This is where the computation happens — your token swap, your NFT mint, your contract call. Execution layers can be optimised for speed because they don't need thousands of validators to secure them independently.

2. The execution layer batches transactions and posts data to the data availability layer. This step is critical. If the data isn't published, no one can verify whether the execution was honest. The DA layer's job is to guarantee that this data exists and is retrievable.

3. The execution layer submits a proof or claim to the settlement layer. For optimistic rollups, this is a state root that can be challenged within a dispute window (typically seven days). For ZK rollups, this is a cryptographic validity proof that's verified on-chain.

4. The settlement layer finalises the result. Once the proof is accepted or the dispute window passes, the transaction is considered irreversibly settled with the full security of the base layer.

What this means practically: You get the speed and low fees of the execution layer, backed by the security of whichever chain handles settlement — without that base chain needing to process your transaction directly.

Most scaling conversations focus on execution speed. The modular thesis argues that data availability is the actual bottleneck — and the one worth solving separately.

• Posting transaction data to Ethereum costs gas. Before Ethereum's Dencun upgrade (March 2024), rollups spent roughly 80–90% of their fees on data posting, not execution.
• Dencun introduced "blobs" — a new, cheaper data format specifically for rollups. This cut L2 fees by roughly 90% overnight, which demonstrated exactly how much DA costs dominated.
• Celestia's entire value proposition is being a DA layer that's even cheaper and more scalable than Ethereum's blobs, using a technique called data availability sampling — where nodes verify data is available by checking small random pieces instead of downloading everything.
• The trade-off: using an external DA layer instead of Ethereum means your rollup inherits that external layer's security assumptions, not Ethereum's. This is a real and active debate in the ecosystem.

What this means practically: Where a rollup posts its data is one of the most consequential architectural choices in modular design. It determines cost, throughput ceiling, and the security model users are trusting.

The modular thesis isn't a solved problem. It's a direction with genuine advantages and open questions.

• Advantage: independent scaling. Execution layers can increase throughput without forcing the DA layer to change, and vice versa. Each layer improves on its own timeline.
• Advantage: shared security. Multiple rollups can post to the same settlement layer, all inheriting its security without each needing their own validator set.
• Unresolved: composability. On a monolithic chain, one transaction can interact with any contract atomically. Across modular layers, moving assets or calling contracts between rollups requires bridges, which add latency, cost, and risk.
• Unresolved: complexity. Users now need to understand which rollup they're on, which DA layer it uses, and how to bridge between layers. The user experience today is significantly worse than a single-chain world.
• Unresolved: fragmented liquidity. Assets spread across many rollups mean thinner markets and more friction. Solutions like shared sequencers and cross-rollup protocols are in development, but none are mature.

What this means practically: Modular design makes blockchains more scalable and more flexible, but the ecosystem is still building the connective tissue that makes it feel like one system to end users.

• Every blockchain performs four functions: execution, settlement, consensus, and data availability. Monolithic chains do all four in one place, which creates hard scaling limits.
• The modular thesis splits these functions across specialised layers. Rollups handle execution, base layers handle settlement, and dedicated DA layers handle data publishing — each optimised independently.
• Data availability, not execution, has been the dominant cost and bottleneck for rollups. Solving DA cheaply is what makes modular scaling work.
• Modular design is already live (every Ethereum L2 is a modular stack), but major challenges around composability, user experience, and liquidity fragmentation remain unsolved.