Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
solana-and-the-rise-of-high-performance-chains
Blog

Why Ecosystem Funds Must Bet on Infrastructure, Not Just Apps

A cynical look at the flawed app-first funding model, arguing that capital directed at core primitives like RPCs, oracles, and indexers creates a durable, multiplicative advantage for high-performance chains like Solana.

introduction
THE MISALLOCATION

The App-First Funding Fallacy

Ecosystem funds that prioritize application development over core infrastructure create fragile, high-friction environments that ultimately limit their own growth.

Infrastructure is the bottleneck. Applications like Uniswap or Aave are demand-side products, but they rely entirely on the supply of performant, composable base layers. Funding apps on weak infrastructure is building on sand.

The composability tax is real. Every new app in an ecosystem introduces integration overhead for wallets, indexers, and oracles like Chainlink or Pyth. Without funded, standardized infrastructure, this overhead becomes exponential friction.

Evidence from Layer 2 scaling. Arbitrum and Optimism succeeded because their foundational grants targeted core developer tools and block explorers first, creating a low-friction plane for applications to later proliferate.

thesis-statement
THE CAPITAL ALLOCATION

Infrastructure is a Force Multiplier; Apps Are a Single Point of Failure

Ecosystem funds that prioritize applications over infrastructure are subsidizing single points of failure while ignoring the force multipliers that enable entire categories.

Infrastructure compounds value. Funding a single DEX yields one DEX. Funding a zero-knowledge proof prover like RiscZero or a modular DA layer like Celestia enables a thousand DEXs, games, and social apps to be built cheaper and faster.

Applications are ephemeral. The top ten dApps by TVL in 2020 are not the top ten today. Infrastructure is persistent. The EVM, pioneered by Ethereum, remains the dominant execution environment, outlasting countless application-layer experiments.

Apps are a single point of failure. A bug in a lending protocol like Aave or Compound triggers an isolated collapse. A failure in core infrastructure like a sequencer (e.g., Arbitrum Nova's 2023 outage) or a bridge (e.g., Wormhole's 2022 exploit) paralyzes entire ecosystems.

Evidence: The 2021-22 cycle saw billions in ecosystem funding flow to apps. The 2023-24 cycle's dominant narratives—modular blockchains, restaking with EigenLayer, and intent-based architectures—are all infrastructure plays that apps depend on.

market-context
THE DATA

The Solana Stress Test: Infrastructure Won the War

The March 2024 memecoin frenzy exposed a critical truth: resilient infrastructure, not viral applications, determines ecosystem survival and growth.

Infrastructure is the moat. The Solana network processed over 100 billion RPC requests in March, a 400% increase. Applications like Jupiter and Raydium functioned only because core infrastructure—RPC providers like Helius and Triton, block explorers, and indexers—absorbed the load. Ecosystem funds that bet on apps without funding their underlying data layer are financing castles on sand.

The bottleneck shifted upstream. Congestion wasn't at the consensus layer but at the RPC and data indexing tier. This created a two-tier user experience where those using premium RPC endpoints (e.g., Helius) had transactions go through, while others faced constant failures. The war for users is now won by who provides the most reliable data access, not the shiniest frontend.

Evidence: During peak load, the public RPC endpoint success rate plummeted below 25%, while dedicated services maintained over 95%. This performance delta directly translated to application success; protocols with robust infrastructure partnerships captured the majority of sustainable volume.

ECOSYSTEM FUND ALLOCATION

The Multiplicative Effect: Infrastructure vs. Application ROI

A capital efficiency comparison of investing in foundational infrastructure versus consumer-facing applications.

Investment MetricInfrastructure Layer (e.g., EigenLayer, Celestia, AltLayer)Application Layer (e.g., DeFi, Gaming, Social DApp)Hybrid Layer (e.g., L2 Rollup, Appchain)

Capital Multiplier (Leverage)

10-100x (Enables entire app categories)

1-5x (Scales with own user base)

3-20x (Scales with app + shared security)

Time to Liquidity (Typical)

24-36 months

12-18 months

18-30 months

Protocol Fee Capture

Recurring, protocol-level (e.g., sequencer fees, DA fees)

One-time or variable (e.g., swap fees, NFT mint fees)

Hybrid (e.g., base fee + app-specific fee)

Downside Protection (Moats)

High (Consensus, data availability, interoperability)

Low (Forkable UI, high competition)

Medium (Customizability with shared security)

Ecosystem Dependence

Low (Serves multiple chains/apps)

High (Depends on underlying L1/L2 health)

Medium (Tied to host chain but can migrate)

Failure Mode

Systemic risk (e.g., slashing event, DA failure)

Isolated risk (Project fails, ecosystem intact)

Contained risk (App fails, infra persists)

Example Success ROI

Ethereum (2015): >100,000x

Uniswap (2018): >1,000x

dYdX (2020): >100x (migrating to appchain)

Required Check Size (Seed)

$5M - $50M

$1M - $10M

$10M - $30M

deep-dive
THE UNSEEN ENGINE

Deconstructing the Core Primitives: RPCs, Oracles, Indexers

Infrastructure primitives are the non-negotiable, high-margin plumbing that determines which application ecosystems survive.

RPCs dictate user experience. A slow or unreliable RPC endpoint from providers like Alchemy or QuickNode directly translates to failed transactions and lost users, creating a hard ceiling for any app's growth.

Oracles are the execution layer. The price feed from Chainlink or Pyth is not just data; it's the trigger for billions in DeFi liquidations and trades, making oracle reliability a systemic risk.

Indexers enable complex state. Without The Graph or a custom indexer, querying on-chain data for an NFT marketplace or social app becomes a slow, expensive engineering quagmire.

Infrastructure compounds value. Every performant RPC call and accurate oracle update improves every dApp built on top, creating a network effect that apps alone cannot replicate.

counter-argument
THE INFRASTRUCTURE PRIMACY

Steelman: "But Apps Drive User Adoption and TVL"

Apps are downstream beneficiaries of infrastructure, which is the actual bottleneck and value accrual layer.

Infrastructure is the bottleneck. Apps like Uniswap and Aave are constrained by the underlying data availability, sequencing, and interoperability layers. Their growth hits a ceiling without ZK-proof scaling from Polygon zkEVM or modular execution from Celestia.

Value accrues upstream. The app-layer is commoditized; infrastructure captures the rent. Ethereum's base fee and L2 sequencer revenue are sticky. An app's success funds its underlying infra, not the other way around.

TVL is a lagging indicator. High TVL follows reliable infrastructure, not precedes it. The Arbitrum Odyssey drove adoption by proving its Nitro stack's capability, not by launching another DEX fork.

Evidence: The 2021-22 cycle saw over $30B deployed into app-focused funds with marginal protocol innovation, while a $2B investment in ZK-rollup infrastructure (StarkWare, zkSync) enabled the next generation of apps.

case-study
WHY ECOSYSTEM FUNDS MUST BET ON INFRASTRUCTURE

Case Studies in Capital Allocation

Investing in applications without foundational primitives is like building skyscrapers on sand. Here's where capital creates non-linear returns.

01

The Avalanche Rush Fallacy

Avalanche's $180M Rush program bought short-term TVL but failed to build sustainable activity. The ecosystem lacked the developer tooling and cross-chain primitives to retain capital long-term, leading to a ~90% TVL decline post-incentives.

  • Lesson: Liquidity incentives are a leaky bucket without sticky infrastructure.
  • Contrast: Solana's parallel execution (Sealevel) and Arbitrum's Nitro stack created durable developer moats first.
-90%
TVL Churn
$180M
Program Size
02

Polygon's ZK Bet vs. Competitor Hype Cycles

While others chased app-specific grants, Polygon committed ~$1B to ZK research (zkEVM, Miden, Zero). This built a multi-year technical moat now powering AggLayer, while competitors face modularity fragmentation.

  • Result: Secured partnerships with Stripe, Nubank via infrastructure reliability.
  • Data Point: zkEVM processes ~1M daily transactions at ~$0.01 cost, enabling new economic models.
$1B
ZK Investment
~$0.01
Avg. TX Cost
03

Cosmos: The App-Chain Factory That Forgot the Tools

Cosmos SDK spawned 50+ chains but under-invested in shared security (Interchain Security v1 took 4 years) and liquidity fragmentation solutions. This created a winner-take-most dynamic for Osmosis while stunting broader ecosystem composability.

  • Consequence: Celestia's data availability and dYdX's migration exposed the SDK's missing infrastructure layer.
  • Metric: <20% of IBC-connected chains have meaningful economic activity.
50+
Chains Built
<20%
Active Economies
04

Solana: Betting the House on Throughput as a Service

Solana Foundation and VC capital focused relentlessly on core infrastructure: Firedancer validator client, QUIC networking, local fee markets. This turned ~400ms block times and ~$0.002 costs into a defensible platform for high-frequency DeFi (Drift, Phoenix) and consumer apps.

  • Outcome: Survived the FTX collapse due to technical, not financial, resilience.
  • Contrast: Competing L1s that prioritized grant farming over client diversity.
~400ms
Block Time
~$0.002
Avg. TX Cost
05

The Starknet Foundation's Prover Subsidy Play

Instead of another DeFi farm, Starknet is subsidizing prover infrastructure and Cairo verifiers. This reduces costs for all apps on the stack and attracts enterprise-scale users who need predictable, sub-cent fees.

  • Strategic Move: Makes Starknet L3s economically viable vs. OP Stack alternatives.
  • Leverage: Ethereum's security + Cairo's performance creates a unique infrastructure wedge.
~$0.001
Target TX Cost
100K+
TPS Potential
06

Base's Superchain: Vertical Integration as Capital Allocation

Coinbase didn't just fund an L2; it's building the OP Stack standard, Base Sequence validator, and onchain compliance rails. This turns infrastructure into a business model, capturing value from every Superchain transaction while apps handle distribution.

  • Metrics: $5B+ TVL driven by native USDC integration and cheap block space.
  • Contrast: Isolated L2s that must constantly bribe users for liquidity.
$5B+
TVL
~$0.01
Avg. TX Cost
investment-thesis
THE INFRASTRUCTURE BET

The New VC Playbook: Fund the Boring Stuff

Venture capital must shift from funding speculative applications to financing the foundational infrastructure that enables them.

The app layer is saturated. Funding another DeFi yield aggregator or NFT marketplace yields diminishing returns. The real alpha is in the protocols and tooling that power these applications, like EigenLayer for restaking or Celestia for modular data availability.

Infrastructure creates ecosystem lock-in. An investment in a core oracle network like Pyth or Chainlink secures a position in every application that depends on its data. This is a more durable moat than any single dApp's frontend.

The evidence is in the data. The total value secured by restaking protocols like EigenLayer now exceeds $15B. This capital is not betting on a single app, but on the underlying cryptoeconomic security primitive that will underwrite hundreds of new protocols.

Compare this to app investing. A fund that backed Uniswap won big. A fund that backed the EVM standard won bigger, capturing value from Uniswap, Aave, Compound, and every subsequent fork.

takeaways
WHY INFRASTRUCTURE IS THE ALPHA

TL;DR for Busy CTOs and VCs

Apps are the frontend; infrastructure is the protocol layer where the real value accrues and network effects compound.

01

The App Graveyard Problem

Funding apps is a lottery. Infrastructure is the casino. Apps compete in a winner-take-most market with high mortality. The underlying infrastructure (e.g., RPCs, indexers, sequencers) captures value from all apps, winners and losers, creating a durable revenue moat.

>90%
App Churn
100%
Infra Utilization
02

The Interoperability Tax

Every new chain fragments liquidity and UX. Funding bridges and messaging layers like LayerZero and Axelar isn't a bet on a single chain's success, but on the inevitability of a multi-chain world. The entity that solves secure, cheap cross-chain state gets a cut of trillions in future flow.

$100B+
Bridged Value
~50+
Active L1/L2s
03

The Developer Time Sink

Teams waste months on non-core infra. Bets on developer primitives (e.g., thirdweb for deployment, Alchemy for RPC, The Graph for queries) directly accelerate the entire ecosystem. These tools become sticky, high-margin SaaS businesses with network effects.

-70%
Dev Time
10x
Launch Speed
04

The Modular Stack Arbitrage

Monolithic chains are being unbundled. Strategic capital in specialized layers (e.g., Celestia for data availability, EigenLayer for shared security, Espresso for decentralized sequencing) captures value from entire rollup ecosystems, not just dApps. This is a higher-order bet on architectural trends.

$1B+
DA Savings
100+
Rollups Served
05

The Intent-Based Future

The next UX leap abstracts wallets and gas. Funding intent-centric infrastructure (e.g., UniswapX, CowSwap, Across) is a bet on the democratization of execution. These systems become the liquidity routers and settlement layers for all user actions, capturing fees from optimized flow.

~30%
Better Prices
1-Click
UX
06

The Data Moats

Raw blockchain data is useless. Capital deployed into indexing & analytics (e.g., Dune, Flipside, Goldsky) builds proprietary data graphs that become essential for trading, risk management, and on-chain AI. This creates defensible, high-utility businesses with recurring enterprise demand.

PB-scale
Data Processed
$Value
In Insights
ENQUIRY

Get In Touch
today.

Our experts will offer a free quote and a 30min call to discuss your project.

NDA Protected
24h Response
Directly to Engineering Team
10+
Protocols Shipped
$20M+
TVL Overall
NDA Protected Directly to Engineering Team