How Rollups Work: Ethereum’s Ultimate Scaling Solution

Ethereum’s congestion problem hit a breaking point in 2021. When the NFT boom arrived, gas fees spiked so high that sending a simple transaction cost $50 or more. Users got priced out. Developers got stuck. The promise of decentralized applications became impractical for anyone without deep pockets. The Ethereum community needed a solution, and fast.

That solution turned out to be rollups — a class of Layer 2 technologies that execute transactions outside the main Ethereum chain (Layer 1) but post transaction data back to Layer 1 for verification and availability. The result is throughput increases of 10x to 100x while maintaining Ethereum’s security guarantees. By 2024, rollups had become the dominant scaling narrative, with total value locked exceeding $30 billion across various implementations.

But here’s what most articles don’t tell you: rollups aren’t a single technology. They’re a family of approaches with fundamentally different trust assumptions, security models, and trade-offs. Understanding these differences matters — because the rollup you choose (or build) affects everything from your user’s costs to your application’s architecture.

The Core Concept: Execution Outside, Settlement Inside

At its simplest, a rollup is a scaling technique that performs transaction execution off-chain while storing enough data on-chain to verify those transactions later. Think of it like a newspaper that publishes only the headlines and a cryptographic summary of each article, rather than the full text. You can verify that something happened, and reconstruct what happened if needed, without storing everything permanently on the expensive, slow main chain.

This is the key insight: Ethereum doesn’t need to execute every computation itself. It only needs to verify that the computation was done correctly. The math sounds abstract, but the practical impact is concrete. While Ethereum mainnet processes roughly 15-30 transactions per second, rollups can handle thousands.

Three components make this possible. First, there’s the sequencer — a node (or set of nodes) that collects transactions, orders them, and executes them to produce a new state root. Second, there’s the batch poster (or aggregator) that compresses many transactions into a single batch and submits that batch to Ethereum as a single transaction. Third, there’s the verification mechanism — the part that proves to Ethereum the batch was computed correctly.

The verification mechanism is where the major philosophical and technical divisions appear. Different approaches here lead to fundamentally different systems with different security properties, performance characteristics, and trust models.

Optimistic Rollups: The “Innocent Until Proven Guilty” Approach

Optimistic rollups take their name from how they handle disputes: they assume everything is legitimate by default and only step in when someone challenges a transaction batch. This is the “optimistic” part — the system is optimistic that validators will catch any fraud.

Here’s how it works in practice. When you submit a transaction to an optimistic rollup like Arbitrum or Optimism, the sequencer executes it and includes it in a batch submitted to Ethereum. The batch contains compressed transaction data and a new state root — essentially a cryptographic summary of all account balances after those transactions. Crucially, the batch does not include a mathematical proof that the computation was correct. It just includes the result.

For a period called the challenge window (typically seven days), anyone can act as a “challenger” and try to prove that a batch was incorrect. If someone identifies fraud, they can submit a fraud proof to Ethereum. This triggers a verification process — typically running the disputed computation on-chain (or in a simulation) to determine the truth. If fraud is proven, the sequencer that submitted the invalid batch loses a bond (usually a substantial amount of tokens), and the challenger receives a reward. The honest state is then restored.

This design has implications. The seven-day challenge period exists because fraud proofs need time to be submitted — there’s no mathematical certainty that a batch is correct, only the economic guarantee that someone would have profited by proving fraud if it existed. This is why withdrawing from an optimistic rollup to Ethereum takes seven days: you have to wait out the challenge window to ensure no one can successfully dispute the state you’re withdrawing from.

Optimism, launched in 2022, was the first major optimistic rollup. Its architecture inspired a wave of successors. Arbitrum, developed by Offchain Labs, became the dominant optimistic rollup by TVL partly due to its Nitro upgrade, which improved compatibility with the Ethereum Virtual Machine and dramatically reduced costs. Base, launched by Coinbase in 2023, built on Optimism’s OP Stack and quickly became one of the most-used rollups, leveraging Coinbase’s massive user base.

The honest assessment: optimistic rollups are simpler to implement than their cryptographic counterparts, but they introduce a trust assumption that some developers find uncomfortable. You’re trusting that at least one honest challenger will monitor the chain and submit fraud proofs if needed. For most applications, this is an acceptable trade-off. But it’s not zero.

ZK Rollups: Mathematical Certainty at a Cost

Zero-knowledge rollups (ZK rollups) take a different approach. Instead of assuming transactions are valid and waiting for someone to prove otherwise, ZK rollups prove mathematically that every batch is correct before it’s accepted. This “validity proof” is generated using zero-knowledge cryptography — specifically, zkSNARKs (Succinct Non-Interactive Arguments of Knowledge) or zkSTARKs.

The mathematics here is genuinely complex, but the intuition is straightforward: the sequencer doesn’t just tell Ethereum “here’s the new state.” It tells Ethereum “here’s the new state, AND here’s a mathematical proof that if you apply these transactions to the old state, you get this new state.” Ethereum verifies the proof cryptographically and accepts the batch immediately. No waiting period. No challenger needed.

This eliminates the trust assumption entirely. A ZK rollup batch is either mathematically correct or it isn’t — there’s no scenario where an invalid batch gets accepted because no one was watching. For developers who prioritize security minimalism, this is the clear advantage.

The trade-off is that generating these proofs is computationally intensive. The sequencer needs powerful hardware to create the proof, which means ZK rollups have historically been slower to finalize than optimistic rollups and harder to build. Generating a validity proof for a batch of thousands of transactions takes minutes in some implementations, though this is improving rapidly.

zkSync Era (from Matter Labs) and Starknet (from StarkWare) are the two most prominent ZK rollups. Both support general-purpose smart contracts, though Starknet uses a custom programming language (Cairo) while zkSync uses Solidity compatibility. Polygon zkEVM and zkRollup projects from ConsenSys represent efforts to bring ZK technology to Ethereum with full EVM equivalence — making it nearly invisible to developers whether they’re deploying to L1 or L2.

The caveat that many articles ignore: ZK rollups are still maturing. The “ZK” in ZK rollup refers to the cryptographic technique, not necessarily to full zero-knowledge privacy. Most current ZK rollups are “validity rollups” — they prove correctness but don’t hide transaction data by default. Privacy-preserving ZK rollups exist but add significant complexity and cost. Also, the proving infrastructure remains expensive; as of early 2025, batch times and costs mean ZK rollups aren’t always cheaper than optimistic rollups for high-throughput use cases.

The Security Model: What “Inheriting Ethereum’s Security” Actually Means

A claim you’ll see everywhere is that rollups “inherit Ethereum’s security.” This is technically true but practically misleading if you don’t understand what it means — and doesn’t mean.

Rollups inherit Ethereum’s data availability and finality guarantees. The transaction data that rollups post to Ethereum is stored on the most decentralized, censorship-resistant network in existence. As long as Ethereum exists, that data cannot be deleted or modified. This is the core security property: even if every rollup operator disappears, the data needed to reconstruct the correct state exists on Ethereum.

What rollups do NOT inherit is Ethereum’s consensus security in the traditional sense. The sequencer (or set of sequencers) that runs the rollup is typically a single entity or small set of entities. They can reorder transactions, front-run users, or (in theory) stop producing blocks. The fraud proof or validity proof mechanism is what constrains them — they can’t commit invalid state because someone will catch them. But they have significant power over transaction ordering and inclusion.

This is worth emphasizing: most rollups in 2025 are still relatively centralized. A single sequencer (or a small committee) controls transaction ordering. Projects like Espresso and Astria are building decentralized sequencer infrastructure, but widespread decentralization is years away. When you use a rollup, you’re trusting that the operator won’t abuse its position. The fraud proof mechanism makes abuse economically irrational in most cases, but it’s a different trust model than Ethereum’s naive proof-of-stake consensus.

There’s also the upgradeability risk. Many rollup contracts have admin keys that allow the operator to upgrade the contract logic, potentially changing the rules of the system. Projects are moving toward timelock-driven upgrades and governance mechanisms, but this is an ongoing concern. If a rollup’s admin key is compromised, users could lose funds regardless of the underlying cryptographic guarantees.

Data Availability: The Bottleneck You’ve Never Heard Of

If you understand one thing about rollup architecture, make it data availability. This is the most critical — and most overlooked — component of the entire system.

Rollups post transaction data to Ethereum so that anyone can verify the rollup’s state independently. This is called on-chain data availability, and it’s what makes rollups trust-minimized. Without it, the rollup operator could simply lie about the state and no one would be able to prove otherwise.

But here’s the problem: posting data to Ethereum is expensive. Ethereum charges for data storage (specifically, through gas fees for calldata or blob storage introduced in EIP-4844). As rollups scale to millions of users, the cost of posting all this data becomes significant. In fact, for many rollups, data availability is the dominant cost component — not the computation.

Ethereum addressed this with EIP-4844 (also called “Proto-Danksharding”), which introduced “blobs” — a cheaper way to store rollup data. Blobs are designed specifically for rollup data and are significantly cheaper than traditional calldata. The result was an immediate 10x reduction in L2 transaction costs in early 2024 when the upgrade activated. Further danksharding upgrades are planned to increase blob capacity over time.

The honest limitation: even with blobs, data availability becomes a bottleneck as rollup usage grows. This is why data availability layers (DALs) are emerging as a solution. Projects like EigenDA, Avail, and Celestia offer dedicated data availability networks that rollups can use instead of posting to Ethereum directly. This trades some data availability guarantees for dramatically lower costs — a trade-off that makes sense for certain applications but not for all.

Token Standards and Bridging: Getting Assets On and Off

Moving assets between Ethereum (Layer 1) and a rollup (Layer 2) requires a bridge. This is more complex than it sounds because of the fundamental architecture difference: Layer 2 doesn’t have the same security guarantees as Layer 1, so simply “minting” tokens on L2 and “burning” them on L1 requires trust.

The standard approach is a canonical bridge operated by the rollup itself. To move ETH or an ERC-20 token from L1 to L2, you deposit it into the L1 bridge contract. The sequencer detects this deposit and mints the corresponding tokens on L2. To move back (withdraw), you burn the tokens on L2, wait through the challenge period (for optimistic rollups), and claim your funds on L1.

This works, but the seven-day delay for optimistic rollups is a real UX friction point. Users withdrawing significant amounts either need to wait or use a third-party bridge that provides faster withdrawals by fronting the funds and settling on L1 after the challenge period (taking on the liquidity and fraud risk themselves). Services like Across and Stargate have built businesses around this.

The token standards themselves have evolved. Originally, rollups used “bridged tokens” — new token contracts on L2 that represented the L1 original. This created fragmented liquidity and required extra trust. The current standard is EIP-7685 and related work on superchain tokens and canonical token representation. The goal is for a token deployed on any rollup to be fundamentally the same asset, with unified liquidity across the ecosystem.

For developers: understanding bridge security is essential. Canonical bridges are typically the most secure but slowest. Third-party bridges may offer speed but introduce additional trust assumptions. The collapse of bridges like Wormhole (2022, $320M exploit) and Horizon Bridge ($100M exploit) demonstrates what’s at stake.

The Rollup Ecosystem: Who’s Building What

The rollup landscape in 2025 is fragmented but maturing. Here’s a snapshot of the major players:

Arbitrum dominates by TVL, with its Nitro upgrade providing EVM equivalence and low costs. Its governance token (ARB) launched in 2023, introducing on-chain governance to the ecosystem. The Arbitrum Orbit program allows projects to launch their own app-specific rollups using Arbitrum’s technology.

Optimism pioneered the optimistic rollup approach and continues iterating with the OP Stack — a modular, open-source stack for building rollups. Base is the highest-profile OP Stack deployment, but other chains like Mode and Zora have also adopted it. The Superchain vision aims to connect multiple OP Stack chains with shared infrastructure and messaging.

zkSync Era and Starknet lead the ZK rollup space. zkSync emphasizes EVM compatibility and developer experience; Starknet uses Cairo and focuses on performance. Both have native account abstraction (no EOAs required), enabling features like social recovery and gas sponsoring that aren’t easily available on optimistic rollups.

Polygon has taken a multi-path approach, with Polygon zkEVM (ZK rollup) and Polygon PoS (proof-of-stake sidechain, which some argue isn’t a true rollup). Their AggLayer vision aims to unify different scaling approaches.

The one that might surprise you: Bitcoin is exploring rollup technology. While less mature, projects like Merlin and Bitfinity are attempting to bring rollup-style scaling to Bitcoin, leveraging the same principles of off-chain execution with on-chain data availability.

Challenges and Honest Limitations

I’ve spent most of this article explaining how rollups work and why they’re powerful. But if you’re making actual decisions about where to build, you need to know what’s broken.

Exit latency remains a fundamental friction point. Even with ZK rollups, finality isn’t instant. ZK proofs take time to generate and verify. For many applications, the user experience of waiting minutes (or, for optimistic rollups, days) for finality is unacceptable. This is particularly painful for high-frequency trading, arbitrage, and certain DeFi strategies.

Interoperability between rollups is painful. Moving assets or data from Arbitrum to Starknet isn’t straightforward — it typically requires multiple hops, bridges, and trust assumptions. The dream of a seamless “rollup ecosystem” where applications span multiple L2s remains largely unrealized.

Centralization concerns are legitimate. Most rollups today have a single sequencer. This gives the operator enormous power over transaction ordering. MEV (Maximal Extractable Value) is a real problem — rollup sequencers can reorder, front-run, or exclude transactions for profit. The solutions exist (Proposer-Builder Separation, encrypted mempool) but are not yet widely deployed.

Regex — the concept of “read compatibility” — is an unsolved challenge. Cross-rollup transactions that feel like they happen atomically are theoretically possible but practically rare. True interoperability will require new primitives.

The uncomfortable truth: we’re still in the early innings. Rollups work, they’re being used, and they’re dramatically cheaper than L1. But the vision of a fully decentralized, seamless, multi-rollup ecosystem is something we’re years away from.

The Road Ahead: What’s Coming Next

The rollup roadmap is active and ambitious. Several developments are worth watching as you think about where the space is heading.

Decentralized sequencing is the most immediate priority. Projects like Espresso, Astria, and EigenLayer are building infrastructure to distribute sequencer duties across multiple validators. This reduces the centralization risk and makes rollup sequencing more analogous to L1 proof-of-stake.

ZK proving efficiency continues to improve at a remarkable pace. Hardware acceleration (GPUs, ASICs) is reducing proving times dramatically. If current trends continue, ZK rollups may match or exceed optimistic rollups in throughput and latency within the next two years.

Cross-rollup standards are maturing. The ERC-7683 standard for cross-chain intent resolution, combined with progress on shared messaging layers, may finally make multi-rollup applications practical.

App-chains and rollups-as-a-service are proliferating. Using Arbitrum Orbit, OP Stack, or ZK Stack, teams can deploy their own dedicated rollups with customized economics and governance. This is particularly attractive for high-throughput applications like gaming or exchanges that need guaranteed block space.

Ethereum’s rollup-centric roadmap seems to be vindicated. The network is no longer trying to scale itself directly — it’s becoming a settlement layer for a rich ecosystem of rollups, each optimized for different use cases. Whether that vision fully realizes its promise depends on solving the challenges above. But the momentum is real, and the engineering is advancing fast.

If you’re building something that needs high throughput, low costs, and Ethereum security, rollups are no longer an experiment — they’re the standard answer. Just go in with eyes open about what you’re actually trusting.