Execution Layer Limits Developers Keep Hitting

EVM's single-threaded execution serializes all transactions, capping throughput at ~50-100 TPS on L1. This creates network-wide congestion and volatile gas fees, making cost prediction impossible for users.

• Problem: A single NFT mint can spike gas for all DeFi swaps.
• Solution: Parallel execution engines like Solana's Sealevel, Monad's MonadVM, and Aptos' Block-STM process independent transactions simultaneously, achieving 10,000+ TPS.

Reading and writing to global state is the primary cost driver. Every SLOAD and SSTORE opcode consumes gas, punishing applications with complex logic or large datasets.

• Problem: On-chain games and social graphs are economically unviable due to constant state updates.
• Solution: Alternative state models like Fuel's UTXO-inspired design and Arbitrum Stylus with its WASM runtime reduce state collisions and enable cheaper, localized computation.

Atomic composability—the ability for transactions to seamlessly interact within a single block—is Ethereum's killer feature. However, scaling solutions fragment this liquidity and logic across rollups, appchains, and L2s.

• Problem: Users and protocols are siloed; a swap, lend, and bridge operation requires 3 separate transactions across 3 chains.
• Solution: Shared sequencers (Espresso, Astria), hyper-connected L2s (Eclipse, Movement), and intent-based architectures (UniswapX, Across) abstract away fragmentation, restoring a unified execution environment.

Global state bloat on L1s like Ethereum creates unsustainable hardware requirements and high sync times. The solution is a shift to stateless clients and verkle trees, which separate execution from state validation.

• Key Benefit: Reduces node requirements from ~2TB SSD to ~50GB RAM.
• Key Benefit: Enables lightweight verification, paving the way for zk-EVMs and safer light clients.

Sequential processing on EVM chains caps throughput at ~100-200 TPS. Projects like Solana, Sui, and Aptos treat parallel execution as a first-principle, while Ethereum L2s like Monad and Sei are building parallelized EVMs.

• Key Benefit: Unlocks 10,000+ TPS for specific workloads (e.g., DEX arbitrage).
• Key Benefit: Dramatically reduces latency for complex DeFi transactions, improving user experience.

Users shouldn't micromanage transaction paths. UniswapX, CowSwap, and Across use intents—declarative statements of desired outcomes—which are fulfilled by a decentralized solver network.

• Key Benefit: ~20% better swap rates via MEV capture and optimal routing.
• Key Benefit: Gasless signing for users, shifting complexity and cost to competitive solvers.

Rollups are bottlenecked by posting data to expensive L1 calldata. Celestia, EigenDA, and Avail provide specialized, cheap data availability layers, decoupling security from execution cost.

• Key Benefit: Reduces L2 transaction costs by 80-90% by moving data off the main chain.
• Key Benefit: Enables sovereign rollups with independent governance and upgrade paths.

Individual rollup sequencers create fragmentation, poor UX, and MEV leakage. Espresso, Astria, and Radius are building decentralized sequencer sets that order transactions for multiple rollups.

• Key Benefit: Enables atomic cross-rollup composability (e.g., a single trade across 3 L2s).
• Key Benefit: Democratizes MEV revenue and provides censorship resistance through decentralization.

General-purpose chains force all dApps to compete for the same congested block space. dYdX, Aave, and Frax are migrating to app-chains (sovereign or rollup) for full control over throughput, fees, and governance.

• Key Benefit: Sub-second block times and zero gas fees for users, funded by protocol treasury.
• Key Benefit: Custom VM design allows for optimized state models (e.g., orderbook vs. AMM).

Global shared state forces sequential execution, capping throughput at ~50 TPS on Ethereum L1. Every transaction competes for the same memory slots, creating a congestion tax.

• Problem: Hot contracts (e.g., Uniswap, USDC) serialize all operations.
• Solution: Parallel execution via optimistic concurrency (Aptos, Sui) or sharded state (Monad, Fuel).
• Impact: Enables 10,000+ TPS by processing independent transactions simultaneously.

Complex logic (DeFi strategies, ZK proofs) hits the 30M gas block limit, forcing protocol logic off-chain or onto expensive L2s. This stifles innovation in-app.

• Problem: Single transaction cost exceeds $100+ during L1 congestion for advanced ops.
• Solution: Native account abstraction (ERC-4337) for batching, and L2s with ~10x cheaper execution (Arbitrum, Optimism).
• Future: Verkle trees and stateless clients will decouple execution cost from state size.

The lack of native transaction ordering control surrenders value to searchers and limits complex cross-contract atomicity. This breaks composability for advanced DeFi.

• Problem: Frontrunning and sandwich attacks extract $500M+ annually, distorting user outcomes.
• Solution: Encrypted mempools (Shutter Network), SUAVE, and intents-based flow (UniswapX, CowSwap).
• Result: Protocols reclaim control over execution, enabling guaranteed atomic bundles.

EVM's 'everything in one block' model is both its superpower and its kryptonite. It forces protocols into a fragile, interdependent lattice that crashes under load.

• Problem: A single failing transaction can revert an entire complex DeFi sequence, creating systemic risk.
• Solution: Asynchronous design patterns via rollups with fast finality (Solana-inspired L2s) and optimistic execution with fallback paths.
• Shift: Moving from synchronous function calls to message-passing across execution domains.