Scaling is a trilemma. Optimizing for throughput, decentralization, and security simultaneously is impossible. Layer 2 solutions like Arbitrum and Optimism choose a security-first approach, inheriting Ethereum's consensus, which inherently limits their speed ceiling compared to alternative L1s like Solana.
the-ethereum-roadmap-merge-surge-verge
Blog
Why Ethereum Scaling Takes Multiple Years
Ethereum's scaling journey is a deliberate, multi-phase engineering marathon. This post deconstructs the Merge, Surge, and Verge roadmap to explain why building a secure, decentralized, and scalable global computer takes time, contrasting it with the 'move fast and break things' approach of competitors like Solana.
introduction
THE REALITY
The Scaling Mirage
Ethereum scaling is a multi-year coordination problem, not a technical sprint.
The ecosystem must standardize. Fragmented liquidity and developer tooling across dozens of L2s and app-chains create friction. Universal standards like ERC-4337 for account abstraction and shared bridging protocols like Across and LayerZero are prerequisites for mass adoption, requiring years of industry-wide coordination.
Evidence: The Rollup Roadmap. Ethereum's own protocol roadmap, including danksharding and data availability sampling, is a multi-year plan. Major L2s like zkSync and StarkNet have taken 3+ years to launch production-grade, provably secure zkEVMs, validating the timeline.
key-trends
WHY SCALING IS A MARATHON
The Three-Pillar Reality
Ethereum scaling isn't a single upgrade; it's a multi-year coordination problem across three interdependent pillars.
01
The Data Availability Bottleneck
Rollups need cheap, secure data to prove state. Ethereum's ~80KB/s blob capacity is a hard limit. Solutions like EigenDA and Celestia compete, but fragmenting security.
- Cost: Blobs are ~100x cheaper than calldata, but still a cost center.
- Throughput: Current cap of ~6 blobs/block limits all rollups simultaneously.
- Fragmentation Risk: External DA layers trade security for scalability, creating new trust assumptions.
~6/block
Blob Capacity
100x
Cost Reduction
02
The Proving Wall
Zero-knowledge proofs (ZKPs) are the endgame for trustless scaling, but hardware and algorithm limits create a long tail. zkEVMs like zkSync, Scroll, and Starknet prove EVM equivalence is expensive.
- Latency: Proving times range from minutes to hours, blocking instant finality.
- Cost: Prover hardware is a centralizing force, requiring specialized ASICs/GPUs.
- Complexity: Each new opcode or precompile requires months of circuit development and auditing.
Minutes-Hours
Prove Time
ASIC/GPU
Hardware Need
03
The Cross-Rollup Liquidity Fracture
Scaling creates dozens of sovereign execution layers. Moving assets between Optimism, Arbitrum, Base, and zkRollups relies on slow bridges or centralized custodians, breaking composability.
- TVL Lockup: $10B+ is stranded across layers, inefficiently deployed.
- Latency: Withdrawals take 7 days for optimistic rollups or require trust in a bridge.
- Solution Space: Protocols like Across, LayerZero, and intents via UniswapX attempt to abstract the problem, but add complexity.
$10B+
Fragmented TVL
7 Days
Slow Withdrawals
deep-dive
THE TIMELINE
Deconstructing the Marathon: Merge, Surge, Verge
Ethereum's scaling roadmap is a sequential dependency chain, not a parallel sprint.
Sequential Dependencies: The Merge enabled the Surge. The Surge enables the Verge. Each phase's output is the next phase's prerequisite. You cannot build a stateless client (Verge) before you have data shards (Surge) to reduce state growth.
State is the Bottleneck: The core scaling constraint is state bloat. Rollups like Arbitrum and Optimism currently post all data to Ethereum L1. Without data sharding (Danksharding), this model hits a hard data availability ceiling, capping all L2 throughput.
Counter-Intuitive Insight: The Surge's goal is not higher L1 TPS. Its goal is cheaper L2 TPS. By providing ~16 MB/s of dedicated data availability, Danksharding reduces Arbitrum's costs by ~100x, making L2s the primary user experience layer.
Evidence: Post-Merge, Ethereum's focus shifted to blob transactions (EIP-4844), a proto-danksharding interim. This reduced L2 transaction fees by over 90% for protocols like Base, demonstrating the Surge's direct impact on end-user scaling.
WHY ROADMAPS ARE MISLEADING
The Scaling Timeline: A Reality Check
Comparing the multi-year complexity of scaling approaches against the simplistic 'mainnet launch' milestone.
| Critical Milestone | Layer 2 Rollup (e.g., Arbitrum, Optimism) | Data Availability Layer (e.g., Celestia, EigenDA) | Monolithic L1 (e.g., Solana, Sui) |
|---|---|---|---|
Time to Functional Mainnet | 6-12 months | 12-18 months | 3-6 months |
Time to Full Decentralization (Sequencer/Prover) | 2-4 years post-launch | 1-2 years post-launch | N/A (native) |
Time to Economic Security (Slashing Live) | 1-3 years post-launch | 6-18 months post-launch | N/A |
Cross-Chain Interop Maturity (e.g., LayerZero, Axelar) | Requires 1-2 years of stable L1<>L2 bridges | Requires DA bridge security (1+ year) | Requires light client maturity (2+ years) |
Client Diversity (2+ implementations) | 2-3 years post-launch | 1-2 years post-launch | Often single-client for 1+ years |
Ecosystem Tooling (RPC, Indexers, Oracles) | 12-24 months to match L1 depth | 18-36 months (depends on rollup adoption) | 12-24 months |
Protocol Revenue Sustainability | 3-5 years (requires significant L2 activity) | 3+ years (requires DA market share) | 2-4 years (requires dApp dominance) |
counter-argument
THE CONSENSUS
The 'Move Fast' Fallacy
Ethereum's scaling timeline is dictated by the physics of decentralized coordination, not engineering speed.
Coordination is the bottleneck. Scaling requires consensus from thousands of validators and alignment of core developers. This process is slower than a single team shipping a monolithic L1 like Solana.
Upgrades are multi-year events. The path from EIP-4844 (Proto-Danksharding) to full Danksharding spans years. Each phase requires client diversity and rigorous testing to avoid catastrophic forks.
Layer 2s create new dependencies. Optimistic rollups like Arbitrum and Optimism must harden their fraud proofs, while ZK-rollups like zkSync and Starknet await EVM equivalence. Their progress is gated by Ethereum's base layer upgrades.
Evidence: The Merge was proposed in 2015 and shipped in 2022. The current rollup-centric roadmap commits to a similar multi-year cadence for scaling data availability.
takeaways
WHY SCALING IS A MARATHON
TL;DR for Builders and Investors
Ethereum scaling is a multi-year, multi-layer puzzle because each solution introduces new trade-offs between security, decentralization, and performance.
01
The L2 Trilemma: You Can't Have It All (Yet)
Every scaling solution forces a compromise. Optimistic Rollups (Arbitrum, Optimism) inherit security but have ~7-day withdrawal delays. ZK-Rollups (zkSync, Starknet) offer fast finality but require complex, computationally heavy proof generation. Validiums (Immutable X) sacrifice some data availability for higher throughput. The market is still discovering the optimal balance.
~7 Days
ORU Delay
~10 mins
ZK Proof Time
02
Data Availability is the Real Bottleneck
Scaling isn't just about execution; it's about making transaction data cheaply available for verification. Ethereum as a DA layer is expensive (~$1k/MB). This is why modular chains (Celestia, EigenDA, Avail) and EIP-4844 (Proto-Danksharding) are critical. They decouple data availability from execution, aiming to reduce L2 costs by 10-100x but require new trust and security assumptions to be battle-tested.
~$1k/MB
Ethereum Calldata Cost
10-100x
Potential Cost Reduction
03
Cross-L2 UX is Still Broken
A multi-rollup future is a fragmented future. Moving assets between Arbitrum, Optimism, and Base requires slow, expensive bridges with fragmented liquidity. Solving this requires standardized messaging (LayerZero, CCIP), shared sequencing (Espresso, Astria), and unified liquidity layers (Across, Chainlink CCIP). This interoperability stack adds another year+ of integration and security audits.
2-20 mins
Bridge Latency
$5-$50
Bridge Cost (Peak)
04
Decentralization is the Final Mile
Many L2s launch with a single sequencer (a centralized transaction processor) for speed. True scaling means decentralizing this critical component without sacrificing performance. Projects like Espresso Systems (shared sequencer) and EigenLayer (restaking for validation) are tackling this, but implementing and securing a decentralized sequencer set is a multi-year engineering challenge.
1
Default Sequencers
Years
Decentralization Timeline
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall