Layer-2 Rollups at a Glance

You now know how Ethereum works under the hood: one shared EVM, every node re-executing every transaction, all of it secured by proof-of-stake. That redundancy is the source of Ethereum’s security — and also its bottleneck. Because everyone redoes everything, Ethereum Layer 1 can only process roughly 15 transactions per second. When the network gets busy, block space runs short, a fee auction breaks out, and a simple token swap can cost more than the swap is worth.

The mainstream fix is not “make Ethereum bigger.” It’s Layer-2 rollups: separate, faster chains that do the heavy lifting elsewhere and then check their homework back on Ethereum. This lesson is how that trick works — and why it’s cheaper without being less safe.

The Scaling Problem

Let’s name the thing. Throughput is how many transactions a chain can settle per unit of time, usually measured in transactions per second (TPS). Ethereum L1 sits around 15 TPS. Visa, for comparison, handles thousands. The gap isn’t because Ethereum’s engineers forgot how to type fast — it’s a deliberate consequence of the design you already learned: thousands of nodes each re-execute every transaction so that nobody has to be trusted. Block space is therefore scarce, and scarce things get auctioned, which is why gas fees spike exactly when you most want to transact.

This tension has a name: the scalability trilemma. A blockchain wants three things at once — security (hard to attack), decentralization (anyone can run a node on modest hardware), and scalability (high throughput) — but it’s brutally hard to maximize all three together. Crank scalability by demanding beefy, expensive nodes, and you quietly sacrifice decentralization. Ethereum L1 deliberately picks security and decentralization, and accepts low base throughput. Rollups are the clever way to buy back scalability without paying with the other two.

What a Rollup Does

Time for the two layers. Layer 1 (L1) is the base chain — Ethereum itself, with its full security and decentralization. A Layer 2 (L2) is a separate system built on top of L1 that handles transactions for it, then leans on L1 for the guarantees it can’t provide on its own.

A rollup is the dominant kind of L2. The recipe has two halves:

1. Off-chain execution. The rollup runs transactions on its own faster chain — a chain that does not need thousands of independent nodes re-executing everything, so it can be cheap and quick.
2. On-chain data + settlement. It periodically posts the compressed transaction data (and/or a proof) back to Ethereum L1. A batch is that bundle: many L2 transactions rolled into a single L1 submission (hence the name “rollup”). Because the data lands on L1, anyone can reconstruct the L2’s state from Ethereum alone — that property is called data availability — and L1 remains the final court of settlement and security.

The analogy: picture a packed restaurant. If every diner walked into the kitchen and read out their order individually, the kitchen would melt down — that’s L1 trying to do everything. Instead, each table’s server takes the orders out front (fast, off to the side), then carries one consolidated ticket back to the kitchen. The kitchen (L1) still cooks the canonical meal and is the single source of truth about what was ordered — but it only had to read one ticket instead of a hundred shouted orders. The serving happens off-chain; the authoritative record lands on-chain.

The genius is that you keep Ethereum’s trust model. You don’t have to trust the rollup operator’s word for your balance, because the underlying data is published to L1, where it can be checked.

Why It’s Cheaper: Amortizing the L1 Cost

Here’s the money question, literally. Posting a batch to Ethereum costs gas — a fixed cost that exists no matter how many transactions are inside the batch. The trick is that this one cost is shared across everyone in the batch. Stuff more transactions into a single batch and the cost-per-user falls, because the same L1 bill is split more ways. This sharing-out of a fixed cost is called amortizing it.

Drag the batch size up below and watch the cost-per-user collapse while the total L1 cost barely moves. Flip the optimistic/ZK toggle to see the finality readout change — we’ll explain that difference in the next section.

A worked example in plain numbers. Suppose posting a batch to L1 costs about 0.02 ETH in gas, and 200 transactions ride in that batch. Each user’s share of the L1 cost is 0.02 / 200 = 0.0001 ETH — a hundredth of a percent of an ETH. Compare that to sending a full standalone L1 transaction, which pays the whole base fee by itself. The more riders share the batch’s fixed bill, the cheaper each seat. Double the batch to 400 transactions and the per-user share halves again to 0.00005 ETH. (These are illustrative round numbers, not a live quote.)

One more lever made this dramatically cheaper: EIP-4844, the “blobs” upgrade. A blob is a chunk of cheap, temporary data space on L1, purpose-built for rollups — it’s much cheaper than regular permanent transaction storage (calldata) and is automatically deleted after a few weeks, which is fine because rollups only need the data available long enough for anyone to verify the batch. Blobs slashed the data-posting bill, which is the dominant cost for a rollup, so per-user fees dropped by an order of magnitude.

A quick definition you just met: the sequencer is the component that receives incoming L2 transactions, decides their order, and packages them into batches. Today it’s usually a single operator — convenient and fast, but a centralization point we’ll revisit in the risks section.

Two Flavors: Optimistic vs ZK

All rollups post data to L1. They differ in how L1 becomes convinced the batch is actually correct — and that single choice drives everything else.

Optimistic rollups

An optimistic rollup does what the name says: it assumes every batch is valid and posts it without proof. Verification is “innocent until proven guilty.” After a batch is posted, there’s a challenge window — typically about 7 days — during which anyone watching can submit a fraud proof: a compact on-chain demonstration that a specific batch contained an invalid state transition. If a valid fraud proof lands, the bad batch is reverted and the cheater loses their bond. If nobody successfully challenges within the window, the batch is final.

• Upside: dirt cheap to operate — no expensive cryptography per batch, just publish and wait.
• Downside: slow withdrawal finality. Moving funds back to L1 means waiting out the full challenge window (the ~7 days), because until then a fraud proof could still overturn things.

ZK rollups

A ZK rollup (zero-knowledge rollup) flips the assumption to “guilty until proven innocent.” With every batch it attaches a validity proof (a ZK proof): a succinct piece of cryptography that mathematically proves the batch’s state transition was computed correctly, without re-running all the transactions. L1 verifies that little proof on the spot. If it checks out, the batch is correct — there’s nothing to dispute and no waiting window.

• Upside: fast finality. Once the validity proof is verified on L1, the batch is settled immediately, so withdrawals don’t need a multi-day wait.
• Downside: heavier to produce. Generating those cryptographic proofs is computationally expensive and, historically, harder to engineer for a fully general EVM.

Flip the toggle in the island above to watch the finality readout switch between the optimistic challenge-window wait and ZK’s near-instant settlement.

Trade-offs and Risks

Rollups are a genuine win, but “inherits L1 security” deserves an asterisk. A rollup inherits Ethereum’s guarantees for data availability and settlement — the data is on L1, and L1 is the final court. But rollups add their own surface area of risk on top:

• Centralized sequencers. Most rollups today run a single sequencer. It can’t steal your funds (the data and proofs keep it honest), but it can censor or delay your transactions, or go offline. Decentralizing sequencers is active, unfinished work.
• Upgrade keys. Many rollups are governed by admin/multisig keys that can upgrade the contracts. A malicious or compromised key is a real risk, mitigated by timelocks and multisigs but not zero.
• Withdrawal delay (optimistic). That ~7-day challenge window means your funds aren’t instantly portable back to L1 — annoying, and a reason “fast bridges” (which front you the money for a fee) exist.
• Bridge risk. Moving assets between L1 and L2 goes through bridge contracts, which have historically been juicy hacking targets. The bridge is only as safe as its code.

And one important cousin to distinguish: a sidechain is not a rollup. A sidechain runs its own independent consensus and provides its own security — it does not post its data to Ethereum, so it does not inherit L1’s guarantees. If a sidechain’s validators collude, Ethereum can’t save you. A rollup’s safety is anchored to L1; a sidechain’s is anchored only to itself.

The Big Picture

Key Takeaways

That’s the whole arc. You’ve gone from “what is Ethereum?” through the EVM, accounts, gas, contracts, and proof-of-stake, and now up the scaling ladder to Layer-2 rollups — the design the ecosystem is actually building on. You understand Ethereum end to end. There’s one thing left: prove it. Head to the final exam for this topic and put it all together.