What Slows Ethereum Down Under Load

Every node must process every transaction to reach consensus, creating a hard throughput ceiling. This is the fundamental limit of a monolithic blockchain.

• Throughput Cap: ~15-45 TPS for base layer.
• Scalability Trade-off: Increasing block size/gas limit directly compromises decentralization by raising node hardware requirements.
• Network Effect: The security and liquidity of the L1 become its own scaling constraint.

The EVM processes transactions in a single, sequential thread within a block. Complex computations (e.g., DeFi swaps) consume disproportionate gas, crowding out simpler transactions.

• Gas Auction: Users bid for limited execution slots, leading to volatile and unpredictable fees during congestion.
• Inefficient Resource Use: A single large DApp transaction can fill a block, while 99% of node CPU sits idle.
• Developer Constraint: Innovation is gas-gated, favoring simple logic over complex on-chain applications.

Every byte of transaction data must be stored forever by all full nodes for state verification. This creates a massive and growing cost barrier to running a node.

• State Bloat: The Ethereum state grows ~20 GB per year, demanding expensive SSDs.
• Cost Externalization: High calldata costs are passed to users, making L1 data publishing prohibitive for rollups.
• Centralization Pressure: Rising hardware costs push node operation towards professional entities, not individuals.

Global state is the ultimate bottleneck. Every transaction must read/write to a shared database, capping throughput at ~50 TPS. This is why rollups (Arbitrum, Optimism) and parallel VMs (Solana SVM, Monad) are existential bets.

• Key Constraint: Single-threaded EVM execution.
• Architectural Shift: Move computation off-chain (L2s) or parallelize state access (L1 redesign).

The public mempool is a free-for-all. Under load, it becomes a frontrunning battleground, where bots spam transactions, inflating fees and creating unpredictable latency for users. This drives adoption of private mempools (Flashbots SUAVE, bloXroute) and intent-based architectures.

• Key Problem: Transaction ordering as a public good is exploited.
• Solution Path: Private order flow, encrypted mempools, and declarative intents (UniswapX).

Paying for computation with a volatile asset (ETH) creates unpredictable and often prohibitive costs during congestion. This is a primary driver for gas abstraction (ERC-4337, Paymasters) and L2s with stable fee currencies. The endgame is users never touching ETH for gas.

• Key Implication: UX and adoption are gated by ETH price action.
• Architectural Fix: Abstract the fee asset via smart accounts and sponsored transactions.

Even with rollups, publishing data to Ethereum L1 is expensive and rate-limited by block space. This data availability (DA) bottleneck is why dedicated DA layers (Celestia, EigenDA, Avail) and danksharding (EIP-4844) are critical. Throughput is ultimately bounded by how cheaply data can be posted and verified.

• Root Cause: L1 block space is a scarce, expensive resource.
• Scalability Lever: Offload DA to specialized, cheaper layers.

Ethereum's greatest strength—atomic composability—becomes its weakness under load. A single congested DeFi primitive (e.g., a large Uniswap swap) can stall an entire ecosystem of dependent contracts. This forces a redesign towards asynchronous messaging (LayerZero, Hyperlane) and self-contained app-chains.

• Architectural Trade-off: Atomicity vs. throughput and isolation.
• Emerging Pattern: Sovereign rollups and interop layers for cross-chain state.

As L2s scale, the cost and latency of verifying their state correctness on L1 becomes prohibitive. Light clients and zk-proof aggregation (e.g., zkSync's Boojum, Polygon zkEVM) are essential to maintain security without reintroducing centralization. The trust model must evolve from "everyone replays" to "someone proves."

• Core Challenge: Scaling verification, not just execution.
• Endgame: Succinct cryptographic proofs (ZKPs) as the universal settlement language.