Theoretical TPS is irrelevant. It measures an empty highway, ignoring the congested on-ramps (sequencer), toll booths (prover), and final destination (L1 settlement). Users experience the slowest link, not the fastest.
zk-rollups-the-endgame-for-scaling
Blog
Why Theoretical TPS Limits Are a Dangerous Illusion for L2s
Advertised peak TPS figures for ZK-rollups ignore network congestion, prover bottlenecks, and state growth, creating a dangerous gap between marketing and real-world capacity for architects.
introduction
THE ILLUSION
Introduction
Peak theoretical TPS is a vanity metric that distracts from the real bottlenecks defining L2 user experience.
Real bottlenecks are systemic. The constraint shifts from L1 data posting to sequencer mempools and cross-chain messaging via LayerZero or Axelar. A 100k TPS chain with a 10 TPS bridge is a 10 TPS system.
Evidence: Arbitrum Nitro's theoretical limit exceeds 100k TPS, yet its sustained real-world throughput is constrained by Ethereum calldata costs and the centralized sequencer's capacity, not its VM execution speed.
key-insights
BEYOND THE MARKETING HYPE
Executive Summary
Layer 2 scaling narratives are dominated by theoretical TPS figures that ignore the real-world constraints of data availability, state growth, and economic security.
01
The Data Availability Bottleneck
Theoretical TPS assumes infinite, cheap data posting. Reality is constrained by the base layer's data bandwidth (e.g., Ethereum's ~80 KB/s blob capacity). This creates a hard, shared ceiling for all rollups, making individual L2 TPS claims meaningless without DA context.
~0.2 MB/s
Ethereum DA Cap
Shared
Resource
02
State Growth vs. Node Requirements
High TPS exponentially grows the state database. To remain decentralized, node hardware requirements must stay low. Solutions like stateless clients and Verkle trees are years away. Today, sustained 10k+ TPS would require enterprise-grade SSDs, centralizing the network.
TB/year
State Growth
Consumer HW
Node Target
03
The Sequencer Centralization Trap
To achieve peak TPS, sequencers must batch and order transactions at hyperscale. This creates a single point of failure and censorship. True decentralized sequencer sets (like Espresso, Astria) add latency and complexity, capping practical TPS far below theoretical max.
1
Active Sequencer
+500ms
Decentralization Tax
04
Economic Security is the Real Metric
Throughput is useless if the chain is insecure. The security budget (fees to pay for DA & proving) must exceed the cost to attack. High TPS with low fees creates an economic vulnerability. Security scales with value secured, not transactions processed.
$TVL
Secured
Fee Revenue
Security Budget
thesis-statement
THE THROUGHPUT TRAP
The Core Illusion
Peak TPS is a vanity metric that distracts from the real bottlenecks of state growth and data availability costs.
Theoretical TPS is meaningless. A chain's peak transaction capacity is a function of its block gas limit and the cheapest possible transaction. This creates a marketing illusion where chains like Solana claim 65k TPS, but real-world usage is constrained by state bloat and economic incentives.
The real bottleneck is state growth. Every transaction modifies the global state, which validators must store and compute. High TPS without a state expiry or stateless client roadmap guarantees eventual centralization, as seen in early Ethereum scaling debates.
Data availability dictates cost. For L2s like Arbitrum and Optimism, the cost to post data to Ethereum's calldata is the ultimate constraint. Innovations like EIP-4844 blobs and validiums (e.g., StarkEx) are the real throughput solutions, not tweaking gas limits.
Evidence: Arbitrum One's sustained TPS is ~40-50, not its theoretical millions. The real scaling race is reducing the cost of data availability and managing state, not winning spec sheet benchmarks.
key-trends
THE REAL L2 SCALING WALLS
The Three Real Bottlenecks
Forget theoretical TPS. Real-world scaling is gated by three concrete, non-negotiable bottlenecks that every L2 must solve.
01
The Problem: State Growth
Every transaction changes the state. Unbounded growth makes nodes impossible to run, centralizing the network. This is the data availability and state bloat crisis.
- Cost: Storing 1TB of state can cost a node operator ~$20/month just in storage fees.
- Sync Time: A new node can take days to weeks to sync an L2, killing decentralization.
- Solutions: Stateless clients, state expiry (EIP-4444), zk-verified state proofs.
1TB+
State Size
Days
Sync Time
02
The Problem: Sequencer Centralization
Most L2s use a single, centralized sequencer for speed. This creates a single point of failure and censorship risk, negating crypto's core value proposition.
- Latency: Centralized sequencing enables ~100ms inclusion times, but at a cost.
- Risk: Users are trusting a single entity not to censor or reorder transactions for MEV.
- Solutions: Shared sequencer networks (Espresso, Astria), based sequencing (EigenLayer), PoS decentralization.
1
Active Sequencer
~100ms
Inclusion Time
03
The Problem: Cross-Domain Liquidity Fragmentation
Capital trapped in siloed L2s is useless. Moving assets between chains via bridges adds ~10-20 minute delays and introduces billions in smart contract risk.
- Cost & Time: A standard bridge transfer costs ~$5-20 and takes 10-30 minutes for finality.
- TVL at Risk: $2B+ has been stolen from bridges (Axie Infinity, Wormhole).
- Solutions: Native liquidity (LayerZero, Chainlink CCIP), fast withdrawal pools, intents (Across, UniswapX).
10-30min
Bridge Delay
$2B+
Stolen
PERFORMANCE REALISM
Theoretical vs. Sustained TPS: A Reality Check
Comparing advertised peak transaction capacity against real-world, sustainable throughput under network stress, highlighting the bottlenecks that separate marketing from production.
| Critical Bottleneck / Metric | Theoretical TPS (Marketing Claim) | Sustained TPS (Production Reality) | Primary Limiting Factor |
|---|---|---|---|
Peak Advertised Throughput | 10,000 - 100,000+ TPS | 100 - 4,000 TPS | Sequencer/Prover Compute & State Growth |
Data Availability Cost at Scale | Ignored | $0.10 - $2.00 per tx (est.) | Blob Gas Pricing & Base Layer Congestion |
State Growth (GB/year at 1k TPS) | Not Modeled | 500 - 1500 GB | Merkle Tree Updates & Storage Proofs |
Prover Time per Batch (Seconds) | < 1 | 30 - 600 | ZK Circuit Complexity & Hardware |
Time to Censorship Resistance | Instant (claimed) | 1 hour - 7 days | Fraud/Validity Proof Finality & Challenge Periods |
Cost per Tx at 90% Capacity | $0.001 | $0.05 - $0.50 | Gas Auction on L1 for Data & Proof Settlement |
Congestion Handling | Assumes None | Queueing & Spikes > 10x Base | Sequencer Centralization & Mempool Design |
deep-dive
THE ILLUSION
Why This Gap Matters for Architects
Theoretical TPS is a marketing metric that obscures the real-world bottlenecks that define user experience and protocol viability.
Theoretical limits are irrelevant. Architects design for real-world conditions, not lab benchmarks. The actual bottleneck is the L1 data availability layer, not the L2's execution engine. A 100k TPS claim is meaningless if the underlying Ethereum blobspace or Celestia block space saturates at 100 TPS-equivalent.
This creates systemic fragility. Protocols like Uniswap and Aave that rely on atomic composability fail when the mempool is congested. Users face failed transactions and unpredictable costs, not the advertised throughput. This gap is where protocols like dYdX migrated to a dedicated app-chain.
Architects must design for the weakest link. Your system's effective TPS is the minimum of your execution layer, DA layer, and bridging infrastructure (e.g., Across, LayerZero). Optimizing only the execution engine is like widening a highway that funnels into a single-lane bridge.
Evidence: Arbitrum Nova uses off-chain Data Availability (DAC) to bypass Ethereum's limits, trading decentralization for throughput. This is the architectural trade-off the TPS number hides.
risk-analysis
THE PRODUCTION GAP
Architectural Risks of Ignoring Real TPS
Layer 2s boasting theoretical TPS are selling a fantasy; real-world bottlenecks create systemic fragility.
01
The Problem: Sequencer Centralization Creates a Single Point of Failure
High theoretical TPS requires a centralized sequencer for speed, creating a critical vulnerability. This is the Achilles' heel of Optimistic Rollups like Arbitrum and Optimism.
- Censorship Risk: A single entity can reorder or block transactions.
- Liveness Risk: Sequencer downtime halts the chain, negating decentralization promises.
- Economic Capture: MEV extraction is centralized, undermining user trust.
~0.3s
Forced L1 Finality
1-of-N
Failure Mode
02
The Problem: Data Availability is the True Bottleneck
Sustained high TPS is impossible without cheap, reliable data posting. Ethereum calldata costs and alternative DA layers like Celestia or EigenDA introduce new risks.
- Cost Spikes: Real TPS craters during L1 congestion, as seen with Arbitrum in bull markets.
- Security Fragmentation: Using external DA trades Ethereum security for scalability, a dangerous compromise.
- Settlement Lag: Proof generation or fraud proof windows depend on data being available, creating latency cliffs.
$10B+ TVL
At Risk
80%+
Cost from DA
03
The Problem: State Growth Cripples Node Operators
High TPS exponentially grows the state, making node synchronization and operation prohibitively expensive. This leads to recentralization of infrastructure.
- Barrier to Entry: New validators cannot sync the chain, reducing network resilience.
- Performance Degradation: Full nodes become slower, increasing reliance on centralized RPC providers like Alchemy and Infura.
- Unbounded Liability: State bloat is a permanent cost, unlike transient gas fees.
TB/year
State Growth
Days
Sync Time
04
The Solution: Embrace Modularity with Shared Sequencing
Decouple execution from sequencing via a shared sequencer network like Espresso or Astria. This preserves decentralization while enabling high throughput.
- Censorship Resistance: Multiple sequencers provide liveness guarantees.
- Atomic Composability: Enables cross-rollup transactions without centralized coordination.
- MEV Democratization: Proposer-builder separation models can be applied at the L2 layer.
10x+
More Resilient
~100ms
Cross-Rollup TX
05
The Solution: Aggressive State Management (WASM, Statelessness)
Move beyond EVM to WASM-based execution (Fuel, Artela) and adopt stateless architectures. This reduces the operational burden of high TPS.
- Parallel Execution: WASM enables true parallel processing, unlocking real throughput.
- Constant Sync Time: Stateless clients verify via proofs, not state replay.
- Future-Proofing: Separates execution logic from state storage, a first-principles redesign.
1000x
Theoretical TPS
MBs
Client Footprint
06
The Solution: Benchmark Real, Not Theoretical, Workloads
Protocols must be stress-tested against real-world transaction mixes (NFT mints, DEX arbitrage, liquidations) not simple transfers. This exposes hidden bottlenecks.
- Worst-Case Gas: Measure TPS under contract deployment and complex smart contract interactions.
- Adversarial Load: Simulate spam attacks and MEV bots to test economic security.
- Public Dashboards: Demand real-time metrics like actual TPS and inclusion latency from teams.
<10%
Real vs. Claimed TPS
2s+
P95 Latency
future-outlook
THE ILLUSION
The Path to Honest Scaling
Layer 2 scaling metrics are a marketing trap that distorts architectural trade-offs and user experience.
Theoretical TPS is meaningless. It measures a vacuum, not a network. The real constraint is data availability cost and proving latency. A chain claiming 100k TPS on Celestia ignores the 7-day window for fraud proofs, creating a massive security gap.
Honest scaling requires holistic metrics. Compare single-slot finality (Solana) versus optimistic confirmation (Arbitrum). Users experience the former as instant; the latter as a 7-day withdrawal delay bridged via Across or Hop. The advertised speed is a lie.
The benchmark is cost-per-real-user-action. This includes proof settlement and bridging. A zkEVM processing 2000 TPS on Ethereum still pays ~$0.02 per L1 batch. Scaling that crushes this cost requires centralized sequencers, which defeats decentralization.
takeaways
THE BOTTLENECK REALITY
TL;DR for Builders
Peak TPS is a marketing vanity metric; real-world scalability is defined by data availability, state growth, and economic security.
01
The Data Availability Wall
Sequencers can process infinite transactions, but publishing them to L1 is the hard cap. Ethereum's ~80 KB/s blob bandwidth is the ultimate shared resource for all rollups.
- Key Constraint: ~10 rollups saturate current blob capacity.
- Real Metric: Blobs per second, not TPS.
- Solution Path: EigenDA, Celestia, or expensive calldata.
~80 KB/s
Ethereum DA Cap
Shared
Resource
02
State Growth & Execution
High TPS rapidly inflates the state size, crippling node synchronization and hardware requirements. This is the verifier's dilemma.
- Problem: A 10k TPS chain grows state by ~1 TB/year.
- Consequence: Centralizes nodes, breaking decentralization.
- Required: Statelessness, state expiry, or aggressive rent models.
~1 TB/year
State Bloat
Verifier's Dilemma
Risk
03
Economic Security Collapse
High throughput with low-value transactions makes fraud proofs and data withholding attacks economically rational. The $1B+ stake needed to secure a high-TPS chain is unrealistic.
- Attack Cost: Must exceed profit from stealing ~7-day challenge window funds.
- Result: Security becomes probabilistic, not absolute.
- Mitigation: ZK-rollups (validity proofs) or extremely high-valued chains.
$1B+
Stake Needed
7-day
Vulnerability Window
04
The Sequencer Centralization Trap
To achieve high TPS, L2s rely on a single, performant sequencer. This creates a single point of failure for censorship and liveness, negating L1 security guarantees.
- Reality: Decentralized sequencer sets (like Espresso, Astria) add ~500ms+ latency.
- Trade-off: You choose speed or decentralization.
- Architecture: Shared sequencer networks sacrifice sovereignty.
1
Default Sequencer
~500ms+
Decentralized Latency
05
Interoperability Tax
High-throughput L2s become isolated islands. Bridges and cross-chain messaging (LayerZero, Axelar, Chainlink CCIP) cannot keep pace with internal TPS, creating massive latency and risk for cross-chain assets.
- Bottleneck: Cross-chain finality is minutes to hours, not seconds.
- Risk: Creates arbitrage and liquidity fragmentation.
- Future: Requires synchronous composability (shared sequencers, EigenLayer).
Minutes
Bridge Latency
Fragmented
Liquidity
06
Focus on Sustainable Throughput
Build for real user activity, not benchmark scores. Optimize for cost, finality, and developer experience at ~100-1000 TPS.
- Target: Sub-cent fees with <2 second pre-confirmations.
- Strategy: Use ZK-rollups for security, blobs for cheap DA.
- Examples: zkSync Era, Starknet, Scroll are scaling this way.
100-1000
Practical TPS
<2 sec
Target Finality
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