Ethereum can only process about 15-30 transactions per second. Visa does ~65,000. Rollups are the main solution to this problem.
Why Ethereum is Slow
Imagine your friend group’s shared expense spreadsheet got really popular. Now 10,000 people want to use it. But the rule is: only 15 entries can be added per minute, and everyone has to bid for a spot.
What happens? The price skyrockets. Simple transactions that should cost ₹5 now cost ₹500-2000 because everyone’s competing for those limited spots. This is literally what happens on Ethereum during high traffic — gas fees explode.
“Why not just increase the limit to 1000 entries per minute?”
Because then you’d need a supercomputer to process them all. Only rich organizations could afford to run nodes (computers on the network). The network becomes centralized — which defeats the whole point.
flowchart TD A["More users 📈"] --> B["Only 15-30 tx/sec on Ethereum"] B --> C["Everyone bids for space"] C --> D["Gas fees skyrocket 💸"] D --> E{"Solutions?"} E -->|"Make blocks bigger"| F["❌ Only rich can run nodes<br/>= centralization"] E -->|"Process off-chain"| G["✅ Rollups!"]
What are Rollups?
The idea: instead of doing every calculation on Ethereum (Layer 1), do the heavy lifting somewhere cheaper and faster (Layer 2), then just post a summary back to Ethereum.
It’s like your friend group hiring an accountant. Instead of 10,000 people each adding entries to the shared spreadsheet, the accountant collects everyone’s transactions, bundles them up, and posts one summary: “Here are today’s 500 transactions, all verified.” The spreadsheet stays small and manageable.
flowchart LR subgraph L2["Layer 2 (Rollup)"] T1["Tx 1"] & T2["Tx 2"] & T3["Tx 3"] & T4["..."] & T5["Tx 500"] end L2 -->|"Compressed batch"| ETH["Ethereum L1"]
The gas cost is split across all 500 transactions. So instead of each person paying ₹500, everyone pays ₹1. Same security as Ethereum (since data is posted there), but way cheaper.
There are two flavors:
Optimistic Rollups
The optimist approach: assume all transactions are valid unless someone proves otherwise.
Think of it like a group project at college. Your team submits the assignment and the teacher says “I’ll assume it’s correct. But if anyone objects within 7 days, I’ll review it.” If a classmate catches an error (called a fraud proof), the incorrect part gets rejected and the cheater is penalized.
sequenceDiagram participant Users participant Rollup as Optimistic Rollup participant ETH as Ethereum Users->>Rollup: Submit 500 transactions Rollup->>ETH: Post batch (assumed valid) Note over ETH: 7-day challenge window ⏳ alt No one objects ETH->>ETH: Batch finalized ✅ else Someone finds fraud ETH->>ETH: Re-execute disputed tx ETH->>Rollup: Reject fraudulent tx ❌ end
Pro: Cheap and fast for everyday use Con: Withdrawals back to Ethereum take ~7 days (you have to wait for the challenge period to pass)
Examples: Optimism, Arbitrum — these are the two biggest right now
ZK Rollups (Zero Knowledge)
The skeptic approach: mathematically prove every transaction is valid upfront.
Instead of “trust me and check later”, ZK rollups submit a cryptographic proof (called a ZK-SNARK or ZK-STARK) alongside every batch. This proof mathematically guarantees all transactions are valid. Ethereum verifies the proof (which is fast) instead of re-executing every transaction.
Think of it like a sealed exam. Instead of the teacher grading every answer, the exam comes with a mathematical certificate that says “every answer here is correct, and here’s the proof.” The teacher just verifies the certificate — done in seconds.
sequenceDiagram participant Users participant Rollup as ZK Rollup participant ETH as Ethereum Users->>Rollup: Submit 500 transactions Rollup->>Rollup: Generate ZK proof 🔐 Rollup->>ETH: Post batch + proof ETH->>ETH: Verify proof (instant) ✅ Note over ETH: No waiting period needed!
Pro: Instant finality — no 7-day wait for withdrawals Con: Generating ZK proofs is computationally heavy (for the rollup operator, not the user)
Examples: zkSync, StarkNet, Polygon zkEVM
Rollups vs Sidechains
People confuse these. The difference is critical:
Rollups post their transaction data TO Ethereum. If the rollup goes down, you can still recover your funds from Ethereum’s data. Your money is as safe as Ethereum itself.
Sidechains are independent blockchains with their own security. If a sidechain gets compromised, your funds could be lost — Ethereum can’t help you.
graph TD subgraph safe["Rollups ✅"] R["Rollup"] -->|"Data posted to"| E1["Ethereum"] E1 -->|"Can always recover funds"| R end subgraph risk["Sidechains ⚠️"] S["Sidechain"] -.->|"Independent security"| E2["Ethereum"] end
TL;DR: Rollups inherit Ethereum’s security. Sidechains don’t. That’s why rollups are considered the “right” scaling solution by most of the Ethereum community.
For a specific Layer 2 example, check out polygon.