Ethereum is a single-threaded computer. Every validator must re-execute every transaction to achieve consensus, a design that prevents the parallel processing that powers Web2 platforms like AWS or Google Cloud. This is the scalability trilemma in action.
the-ethereum-roadmap-merge-surge-verge
Blog
Why Ethereum Cannot Scale Like Web2
A first-principles breakdown of the fundamental trade-offs—decentralization, security, and composability—that make Ethereum's scaling path fundamentally different from centralized Web2 architectures.
introduction
THE FUNDAMENTAL CONSTRAINT
Introduction: The Scaling Mirage
Ethereum's security model creates a hard trade-off between decentralization and throughput that Web2 architectures do not face.
Layer 2 solutions like Arbitrum and Optimism are workarounds, not fixes. They batch transactions off-chain but must still post compressed data and proofs back to Ethereum's Layer 1 for finality. This creates a data availability bottleneck that caps their theoretical throughput.
The cost is security. Web2 scales by trusting centralized coordinators; Ethereum scales by making cryptographic guarantees. A network promising 1,000,000 TPS today sacrifices the decentralized consensus that gives the base chain its value.
Evidence: Even with advanced L2s, Ethereum's shared data layer processes ~0.2 MB/s. Solana, which prioritizes speed, achieves higher throughput by relaxing decentralization requirements, a trade-off that caused a 19-hour network stall in 2022.
key-trends
WHY WEB2 SCALING IS IMPOSSIBLE
Executive Summary: The Three Unbreakable Constraints
Ethereum's security and decentralization create fundamental trade-offs that no single-layer optimization can overcome.
01
The Decentralization Tax
Every node must redundantly execute and store every transaction, creating a ~1-2k TPS hard cap. This is the cost of a global, permissionless state machine.
- State Bloat: The chain grows at ~100+ GB/year, forcing expensive hardware.
- No Free Lunch: Scaling throughput linearly increases hardware costs, centralizing nodes.
~1-2k TPS
Hard Cap
100+ GB/yr
State Growth
02
The Latency of Finality
Consensus requires probabilistic agreement across thousands of globally distributed nodes. ~12-15 second block times are a feature, not a bug, for Byzantine Fault Tolerance.
- Settlement Assurance: Fast finality (e.g., Tendermint) trades off decentralization for speed.
- Unbreakable Law: You cannot have global consensus, instant finality, and decentralization simultaneously.
12-15s
Block Time
~64s
Full Finality
03
The Data Availability Bottleneck
Before a block is valid, its data must be available for verification. This creates the data availability problem, limiting block size and throughput.
- Blob Space Scarcity: Even with EIP-4844, blob capacity is a shared, auctioned resource.
- Scalability Ceiling: Rollups like Arbitrum and Optimism are ultimately constrained by L1's data bandwidth.
~0.1 MB/s
DA Throughput
Shared
Global Resource
thesis-statement
THE BOTTLENECK
The Core Thesis: Scaling State, Not Just Transactions
Ethereum's fundamental scaling limit is global state growth, not transaction throughput.
Ethereum's bottleneck is state. Scaling requires every node to store and compute the entire global state, creating a hard physical limit on growth that transaction batching alone cannot solve.
Web2 scales via sharding. Systems like Google or AWS partition data and computation across isolated servers; Ethereum's security model demands every validator verify every transaction, preventing this horizontal scaling.
Rollups like Arbitrum and Optimism are a partial fix. They batch transactions but still post compressed state diffs to L1, inheriting Ethereum's state growth constraints and creating a new data availability crisis.
The evidence is in node requirements. Running an Ethereum archive node requires over 12TB of SSD storage, growing at ~140GB/month. This exponential state growth makes decentralization economically unsustainable.
RAW PERFORMANCE METRICS
The Scaling Gap: Ethereum L1 vs. Web2 Benchmarks
A first-principles comparison of base-layer transaction throughput, cost, and finality against established Web2 payment networks, highlighting the fundamental architectural trade-offs.
| Core Metric | Ethereum L1 | Visa Network | Solana L1 |
|---|---|---|---|
Peak Transactions Per Second (TPS) | 15-45 TPS | 65,000 TPS | ~3,000 TPS |
Average Transaction Cost | $1-50 | $0.10-0.30 | < $0.001 |
Time to Finality (Settlement) | ~12 minutes (64 blocks) | < 3 seconds | ~400 milliseconds |
Base Layer Data Throughput | ~80 KB/s (1.5 MB block / 12s) | Not Publicly Disclosed | ~50 MB/s |
Global State Synchronization | All 10,000+ nodes | Centralized Ledger | ~2,000 Validators |
Client Hardware Requirements | 2+ TB SSD, 16+ GB RAM | Enterprise Data Centers | 128 GB RAM, High-CPU |
Throughput per Watt (Efficiency) | ~0.05 TPS/kW | ~650 TPS/kW (Est.) | ~30 TPS/kW (Est.) |
deep-dive
THE FUNDAMENTAL MISMATCH
Deep Dive: The Roadmap's Real Goal (Surge, Verge, Scourge)
Ethereum's scaling roadmap is a multi-year admission that monolithic L1 scaling is a dead end for global adoption.
Ethereum's roadmap concedes that a single chain cannot scale. The Surge (rollups), Verge (statelessness), and Scourge (PBS) are all optimizations for a rollup-centric world, not a monolithic L1. This is a fundamental architectural divergence from Web2's centralized scaling model.
Web2 scales via centralization, adding servers and databases under one entity's control. Ethereum scales via fragmentation and coordination, distributing execution across Optimism, Arbitrum, and zkSync while relying on a shared settlement layer. This introduces the interoperability tax that Web2 does not pay.
The Verge's stateless clients are the key unlock. They allow nodes to verify the chain without storing its full state, enabling light client scaling. This is not about L1 TPS; it's about making the base layer a viable trust anchor for thousands of rollups, a problem Web2 never faced.
Evidence: The data proves fragmentation. Base and Arbitrum now process more daily transactions than Ethereum L1. The roadmap's goal is not to make L1 fast, but to make coordinating this fragmented system secure and efficient, a challenge solved by protocols like EigenLayer and AltLayer for restaking and shared sequencing.
protocol-spotlight
WHY ETHEREUM CANNOT SCALE LIKE WEB2
Architectural Divergence: How Scaling Actually Works
Web2 scales by trusting centralized coordinators; Web3 scales by distributing trust, which imposes fundamental constraints.
01
The Problem: Global Synchronous Consensus
Every Ethereum node must agree on every transaction's order and outcome. This creates a single, sequential bottleneck for the entire network.\n- Throughput Limit: Capped at ~15-45 TPS on L1.\n- Latency Floor: Finality requires ~12-15 minutes (PoW) or ~12 seconds (PoS).\n- Cost: Every node pays the full cost of verifying every operation.
~15 TPS
Base Throughput
12+ min
Finality (PoW)
02
The Solution: Rollups (L2s) - Off-Chain Execution
Move computation off-chain and post compressed proofs (Optimism, Arbitrum) or validity proofs (zkSync, StarkNet) to L1. This preserves security while scaling.\n- Throughput Gain: 100-2000x capacity increase vs. L1.\n- Cost Reduction: 10-100x cheaper gas fees for users.\n- Security Model: Inherits Ethereum's $80B+ security budget via data/validity proofs.
100-2000x
Capacity Gain
$80B+
Security Budget
03
The Problem: Data Availability
Even with rollups, publishing transaction data to L1 is expensive. The ~80 KB/s data bandwidth of Ethereum is the new scaling bottleneck, limiting how many rollups can operate.\n- Blob Cost: ~$0.01-$0.10 per transaction (post-EIP-4844).\n- Throughput Ceiling: ~3-5 rollups saturate mainnet's data layer.
~80 KB/s
Data Bandwidth
3-5x
Rollup Saturation
04
The Solution: Modular Chains & Data Availability Layers
Decouple execution, settlement, consensus, and data availability. Dedicated DA layers like Celestia, EigenDA, and Avail provide ~10-100 MB/s of cheap data bandwidth.\n- Cost Reduction: 10-100x cheaper data than Ethereum L1.\n- Scalability: Enables hundreds of parallel rollups and sovereign chains.
10-100 MB/s
DA Bandwidth
10-100x
Cheaper Data
05
The Problem: Cross-Domain Liquidity Fragmentation
Scaling creates isolated liquidity pools across L2s and L1. Moving assets between them is slow (7-day challenge periods) or trust-dependent (multisig bridges).\n- Capital Inefficiency: Billions locked in bridge contracts.\n- Security Risk: $2B+ stolen from bridge hacks (Wormhole, Ronin).
$2B+
Bridge Hacks
7 Days
Withdrawal Delay
06
The Solution: Intents & Shared Sequencing
Shift from atomic transactions to declarative intents filled by a competitive network of solvers (see UniswapX, CowSwap). Shared sequencers like Espresso or Astria provide cross-rollup atomic composability.\n- User Experience: Gasless, MEV-protected swaps.\n- Composability: Enables atomic transactions across multiple L2s.
Gasless
User Experience
Atomic
Cross-Rollup TX
counter-argument
THE MONOLITHIC TRAP
Counter-Argument: What About Solana or Monolithic L1s?
Monolithic L1s like Solana achieve scale by centralizing hardware and state, which is the antithesis of Ethereum's decentralized scaling thesis.
Monolithic scaling centralizes hardware. Solana's 50k TPS target requires validators with 128-core CPUs and 512GB RAM. This creates a hardware oligopoly that excludes global participation, directly contradicting Ethereum's goal of a globally accessible, permissionless base layer.
State growth is a terminal problem. A single global state for all applications, as in Solana, grows exponentially. This forces validators to archive petabytes of data, a centralizing force that Ethereum's rollup-centric roadmap explicitly avoids by sharding data availability via EigenDA and Celestia.
Ethereum's scaling is social. The L2 ecosystem (Arbitrum, Optimism, zkSync) scales through parallel execution and independent innovation. This parallel sovereignty model creates competitive markets for blockspace and security, a dynamic impossible in a single-threaded monolithic chain.
Evidence: Solana validators require $65k+ in annual hardware costs. Ethereum validators require a $1k consumer laptop. This cost disparity defines the decentralization trade-off. The monolithic path optimizes for throughput; Ethereum's modular path optimizes for credible neutrality and global access.
FREQUENTLY ASKED QUESTIONS
FAQ: Clearing the Fog
Common questions about why Ethereum's scaling challenges differ fundamentally from Web2 platforms.
Ethereum is slow because every node in its decentralized network must redundantly compute and validate every transaction for security. This is the cost of global consensus without a central authority. Web2 systems like Visa use a single, trusted database, allowing for massive throughput but requiring you to trust their security and honesty.
future-outlook
THE SCALING CEILING
Future Outlook: The Endgame is a Super-Linear Network
Ethereum's architectural constraints prevent Web2-like scaling, forcing a modular future of specialized execution layers.
Monolithic scaling hits a wall. Ethereum's single-threaded execution and global consensus create a hard throughput ceiling, unlike horizontally scalable Web2 databases.
Modularity is the only path. Specialized layers like Arbitrum and zkSync Era handle execution, while Celestia and EigenDA provide data availability, decoupling functions.
Super-linear network effects emerge. Each new rollup adds composable liquidity and users, increasing the value of the shared settlement layer (Ethereum L1).
Evidence: The L2 ecosystem now processes ~90% of Ethereum's transactions, with Arbitrum and Base consistently handling over 10 TPS each, a 100x increase over L1 capacity.
takeaways
WHY ETHEREUM CANNOT SCALE LIKE WEB2
Key Takeaways for Builders & Investors
Ethereum's security-first design imposes fundamental trade-offs that prevent it from matching the throughput and cost structure of centralized platforms.
01
The Consensus Bottleneck
Ethereum's global consensus requires every validator to process every transaction, creating a hard throughput cap. This is the antithesis of Web2's horizontally scalable, sharded architecture.
- Throughput Limit: ~15-45 TPS on L1.
- Cost of Security: Every transaction pays for the security of the entire network.
- No Free Lunch: Scaling via larger blocks sacrifices decentralization (the "scalability trilemma").
~30 TPS
Max Throughput
~12s
Finality Time
02
The Data Availability Wall
Storing all transaction data on-chain is prohibitively expensive. This data availability (DA) problem is the primary cost driver for L2s like Arbitrum and Optimism.
- Cost Structure: ~80-90% of an L2's operational cost is paying Ethereum for DA.
- Scalability Ceiling: Throughput is gated by Ethereum's blob capacity (~0.75 MB per block).
- Emerging Solutions: Celestia, EigenDA, and Avail offer external DA to break this link.
~$0.10
Avg. L2 TX Cost
0.75 MB
Blob Capacity/Block
03
Sovereignty vs. Synchrony
Web2 scales via asynchronous, independent services. Ethereum's value is its synchronous composability—the guarantee that all state is globally consistent and instantly accessible.
- Atomic Composability: Allows complex DeFi lego across protocols (e.g., Uniswap -> Aave in one tx).
- The Trade-off: This shared state is the bottleneck; sharding it (like Near or Polkadot) breaks atomicity.
- Builder Implication: Scaling solutions (rollups, app-chains) must choose between sovereignty and seamless composability.
1 State
Global Ledger
High
Composability Premium
04
Modularity is the Only Path
Monolithic scaling (faster L1) has failed. The future is modular blockchains, separating execution, consensus, settlement, and DA into specialized layers.
- Execution Layer: Rollups (OP Stack, Arbitrum Orbit, zkSync Hyperchains) handle transactions.
- Settlement & DA: Ethereum as trust anchor; Celestia/EigenDA for cheap data.
- Investor Takeaway: The value accrual shifts from monolithic L1s to modular infrastructure and shared sequencers.
1000x
Theoretical Scale
Modular Stack
Winning Architecture
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