What are blockchain rollups and how do they scale Ethereum

Ethereum can process roughly 15 transactions per second. That is less than a single Starbucks checkout line. Rollups are the technology that lets Ethereum handle thousands of transactions per second without sacrificing the security that makes it valuable in the first place. They work by executing transactions off chain and posting compressed proofs back to Ethereum, turning the base layer into a settlement court rather than a transaction processor.

The standard narrative says that rollups make Ethereum faster. This is technically true but misleading. Ethereum itself does not get faster. It still produces a block every 12 seconds. It still processes roughly 15 transactions per second on the base layer. Nothing about Ethereum’s consensus or execution changes when a rollup deploys.

What changes is where the work happens. Rollups move transaction execution off the Ethereum mainnet and onto a separate chain that can process transactions much faster because it does not need thousands of validators to agree on every state change. The rollup then compresses the results and posts them back to Ethereum, where they are verified and made permanent.

The analogy that most explanations use is a court system: the rollup handles the day to day transactions (the cases), and Ethereum serves as the court of final appeal (the judge). This analogy is useful but incomplete. The more precise framing is that rollups convert Ethereum from a transaction processor into a data availability and verification layer. The base chain stops doing the work and starts checking the work.

Understanding why this matters requires understanding what makes Ethereum slow in the first place, and why the obvious solutions do not work.

Why Ethereum cannot simply increase its throughput

Ethereum processes approximately 15 transactions per second. The intuitive fix is to increase the block size or reduce the block time, allowing more transactions per block or more blocks per unit of time. Every first generation blockchain project that tried this approach discovered the same problem: larger blocks require more powerful hardware to validate, which prices out smaller node operators, which concentrates validation among fewer entities, which undermines decentralization.

This is the blockchain trilemma. You can optimize for any two of three properties (security, decentralization, throughput) but improving the third requires sacrificing one of the others. Increasing Ethereum’s block size would improve throughput at the cost of decentralization. Reducing the validator count would improve throughput at the cost of security.

Rollups sidestep the trilemma by separating execution from verification. The rollup chain handles execution with a small number of operators, achieving high throughput. Ethereum handles verification and data availability with its full validator set, maintaining security and decentralization. Neither chain compromises, because each is optimized for a different function.

This is not a theoretical argument. Solana, which chose to optimize for throughput over accessibility, requires validators to run hardware costing thousands of dollars and processes blocks that are hundreds of megabytes. Ethereum validators can run on a consumer laptop. The rollup architecture lets Ethereum achieve Solana’s throughput without Solana’s hardware requirements by moving execution to a separate layer.

How optimistic rollups work

Optimistic rollups are named for their core assumption: transactions are assumed to be valid unless proven otherwise.

The process starts with a sequencer, a node operated by the rollup team that collects user transactions, orders them, and executes them in batches. The sequencer produces a new rollup state after each batch, just as Ethereum produces a new state after each block.

Instead of requiring every validator to re-execute every transaction, the optimistic rollup posts the batch data to Ethereum and publishes a state root (a cryptographic hash of the rollup’s state after executing the batch). This state root is accepted as correct unless someone challenges it.

The challenge mechanism is the fraud proof system. During a challenge window, typically seven days, anyone can examine the batch data posted to Ethereum, re-execute the transactions locally, and compare their result to the published state root. If the results differ, the challenger submits a fraud proof to a smart contract on Ethereum, which re-executes the disputed transaction on chain and determines who is correct.

If the fraud proof shows that the sequencer published an incorrect state root, the sequencer’s staked collateral is slashed, the incorrect state root is reverted, and the challenger receives a reward. If no one challenges the state root within the challenge window, it is finalized on Ethereum and becomes the canonical state of the rollup.

This design is elegant because it moves the expensive work (re-execution and verification) off the critical path. In the normal case, where the sequencer is honest, no on chain re-execution happens at all. The cost of operating the rollup reduces to posting compressed batch data to Ethereum, which is dramatically cheaper than executing every transaction on the base layer.

Arbitrum and Optimism are the two largest optimistic rollups. Arbitrum uses an interactive dispute resolution protocol that narrows the disputed computation down to a single instruction before re-executing it on chain, minimizing the on chain gas cost of fraud proofs. Optimism uses a non-interactive fraud proof system where the entire disputed transaction is re-executed in a single on chain step.

Base, built by Coinbase using the OP Stack (Optimism’s open source framework), has become the fastest growing rollup by transaction volume, driven by consumer applications and the integration with Coinbase’s user base.

How ZK rollups work

ZK rollups take the opposite approach: they prove correctness up front rather than assuming it.

After the sequencer executes a batch of transactions, a prover generates a cryptographic validity proof (typically a zk-SNARK or zk-STARK) that mathematically demonstrates the batch was executed correctly. This proof, along with the batch data, is posted to a verifier contract on Ethereum. The verifier checks the proof, which is computationally cheap and takes constant time regardless of how many transactions the batch contains.

The advantage is finality. There is no seven day challenge window. As soon as the proof is verified on Ethereum, the batch is finalized. Users can withdraw assets from a ZK rollup to Ethereum in minutes rather than waiting a week.

The disadvantage is cost. Generating a validity proof for a complex batch of transactions requires significant computational resources. ZK proof generation is a mathematically intensive process that can take minutes for large batches and requires specialized hardware. This cost is amortized across all transactions in the batch, but it adds a per-batch overhead that optimistic rollups avoid.

ZK rollups are also more difficult to build. Optimistic rollups can support the same virtual machine as Ethereum (the EVM) with relatively minor modifications, which means existing Solidity smart contracts work with little or no changes. ZK rollups historically required developers to write contracts in specialized languages like Cairo (used by StarkNet) because the EVM’s instruction set was not designed for efficient zero-knowledge proof generation.

This gap is closing. zkSync Era and Polygon zkEVM have implemented EVM-compatible ZK rollups that can execute standard Solidity contracts, though with varying degrees of compatibility. Scroll, another ZK rollup, aims for full EVM equivalence, meaning contracts deployed on Ethereum can be deployed on Scroll without any modification.

Blobs and the Dencun upgrade: the economics shift

Before March 2024, rollups posted their batch data as calldata in Ethereum transactions. Calldata is stored permanently by every Ethereum node, which makes it expensive. A typical rollup batch cost $500 to $2,000 in calldata fees during periods of high Ethereum congestion.

The Dencun upgrade introduced EIP-4844, which created a new data type called blobs. Blobs are large chunks of data (approximately 128 KB each) that are attached to Ethereum transactions but are only stored temporarily, for approximately 18 days, rather than permanently. This makes them dramatically cheaper than calldata.

The impact was immediate and measurable. Transaction fees on Arbitrum dropped from an average of $0.25 to under $0.01. Fees on Base dropped to fractions of a cent. The cost of posting a rollup batch to Ethereum fell by more than 90%.

This matters because it changes the economic equation for rollup adoption. When layer 2 transactions cost $0.25, only users with transactions above a certain value threshold would choose the rollup over a competing chain with lower base fees. When layer 2 transactions cost $0.001, the cost advantage of competing chains largely disappears, and the security advantage of Ethereum settlement becomes the deciding factor.

Blobs are the first step toward full danksharding, a future upgrade that will increase the number of blobs per block from the current target of three to 64 or more. Each step in this progression further reduces rollup costs and increases the data throughput available for layer 2 settlement on Ethereum.

The sequencer centralization problem

Almost every major rollup today runs a single sequencer operated by the rollup team. Arbitrum’s sequencer is run by Offchain Labs. Optimism’s sequencer is run by OP Labs. Base’s sequencer is run by Coinbase.

This centralization creates several risks. If the sequencer goes down, the rollup halts. If the sequencer censors certain transactions, users cannot interact with the rollup normally. If the sequencer reorders transactions to extract MEV, users pay a hidden tax.

Rollup teams defend this centralization as a temporary measure. Decentralizing the sequencer, by introducing a rotating set of sequencers or using a shared sequencing layer, is on every major rollup’s roadmap. But roadmaps are not deployments.

The mitigation is forced inclusion. Most rollups include a mechanism that allows users to submit transactions directly to the Ethereum base layer, bypassing the sequencer entirely. If the sequencer censors your transaction, you can force it through the rollup’s on chain contract. This process is slower and more expensive than going through the sequencer, but it prevents permanent censorship.

The degree to which forced inclusion actually works in practice, under the time constraints and gas costs of real world usage, is a meaningful differentiator between rollups. L2BEAT, the primary independent tracker of rollup security properties, rates each rollup on the maturity of its forced inclusion mechanism along with several other security criteria.

The fragmentation problem

Ethereum’s rollup strategy has succeeded in creating scalable execution environments. It has also created a fragmentation problem that did not exist before rollups.

A user with assets on Arbitrum cannot directly use them on Base. A DeFi protocol on Optimism has separate liquidity from the same protocol on zkSync. An NFT minted on StarkNet cannot be sold on a marketplace running on Scroll.

Each rollup is its own chain with its own state, its own bridge to Ethereum, and its own ecosystem of applications. Moving assets between rollups requires bridging, which introduces delay (seven days for optimistic rollup withdrawals to Ethereum), cost (gas fees on both the source and destination chains), and risk (bridge smart contract vulnerabilities).

This is not merely an inconvenience. It is a structural problem that undermines the network effects that make Ethereum valuable. If liquidity is split across 30 rollups, no single rollup has the depth of liquidity that Ethereum mainnet had when it was the primary execution environment.

Solutions are being developed. Shared sequencing layers like Espresso aim to coordinate transaction ordering across multiple rollups, enabling atomic cross-rollup transactions. Interoperability protocols like Chainlink CCIP and LayerZero provide messaging layers that let rollups communicate. ERC-7683, a cross-chain intent standard, aims to standardize how users express cross-rollup transfers.

None of these solutions are mature enough to eliminate fragmentation today. Whether the rollup ecosystem converges on a small number of dominant chains or remains fragmented across dozens is an open question with significant implications for where users, developers, and liquidity settle.

The security model differs in more subtle ways as well. In an optimistic rollup, security depends on at least one honest verifier watching the chain and submitting fraud proofs when needed. If every verifier is offline or colluding, invalid state transitions could be finalized after the challenge window closes. In practice, multiple independent verifiers monitor every major optimistic rollup, and the economic incentive to catch fraud (the challenger receives slashed collateral) makes this attack expensive to sustain. But the theoretical requirement is weaker than a ZK rollup, where the mathematical proof itself guarantees correctness regardless of who is watching.

The user experience implications of rollup choice extend beyond fees and finality. Wallet support, token availability, and application deployment all vary across rollups. A user who bridges assets to a rollup with limited DeFi protocol deployment may find their capital stranded in an ecosystem with few productive uses. The interoperability problem compounds this: moving assets back to Ethereum or to a different rollup incurs additional bridging fees and time delays that can negate the cost savings that attracted the user to the rollup in the first place.

What this does not cover

This article does not cover the internal architecture of specific rollup virtual machines. The differences between Arbitrum Nitro, the OP Stack, and StarkNet’s Cairo VM are significant and affect developer experience, performance, and security properties. Each deserves dedicated analysis.

This article does not cover validiums and volitions, which are rollup variants that post data to a separate data availability layer rather than to Ethereum. These systems trade some of Ethereum’s security guarantee for lower costs, and the tradeoffs are nuanced.

This article does not address the token economics of rollup governance. ARB, OP, STRK, and ZK tokens each have different governance, staking, and incentive structures. Whether rollup tokens accrue value to holders or function primarily as governance instruments is an active debate with implications for investment decisions.

Practical checks before choosing a rollup

Check the rollup’s security stage on L2BEAT. L2BEAT classifies rollups into three stages based on the maturity of their proof systems, upgrade mechanisms, and governance. Stage 0 rollups rely heavily on trust in the rollup team. Stage 1 rollups have functional proof systems but retain upgrade keys. Stage 2 rollups have fully trustless proof systems with minimal centralized control. Most major rollups are still at Stage 0 or Stage 1 as of mid 2026.

Understand the withdrawal time. Optimistic rollup withdrawals to Ethereum take approximately seven days due to the fraud proof challenge window. Fast bridge services can accelerate this by fronting the funds, but they charge a fee and introduce counterparty risk. ZK rollup withdrawals can complete in minutes once the validity proof is verified. This difference matters if you need rapid access to your assets on Ethereum mainnet.

Verify the forced inclusion mechanism. If the sequencer goes down or censors your transaction, can you force your transaction through the on chain contract? Check whether the rollup has a functioning forced inclusion mechanism and how long the delay is. A rollup without forced inclusion is a centralized chain with Ethereum branding.

Compare actual transaction costs. Rollup fees vary based on the rollup’s compression efficiency, batch frequency, and the current price of Ethereum blob space. Use a rollup fee tracker to compare the actual cost of common operations (token transfer, swap, contract deployment) across rollups at the time you plan to use them, rather than relying on historical averages.

Check the ecosystem. The cheapest rollup is not useful if the application you need is on a different rollup. Verify that the DeFi protocols, NFT marketplaces, or wallet infrastructure you plan to use are deployed and liquid on the rollup you choose.

Disclaimer: This article is for informational and educational purposes only. It does not constitute financial, investment, or legal advice. Cryptocurrency markets are volatile and carry significant risk. Always conduct your own research before making investment decisions.