The Modular Stack Is Getting Too Complex - Time for Abstraction

General
1

I need to vent. I spent the last three weeks building a new DeFi protocol, and the number of decisions I had to make about infrastructure - before writing a single line of business logic - was absurd.

The Decision Tree From Hell

Here’s what building a “simple” DeFi app looks like in 2026:

  1. Execution layer: Arbitrum? Optimism? Base? zkSync? Scroll? Linea? Starknet? Each has different dev tooling, gas semantics, and quirks.

  2. Data availability: Should I care? Celestia is cheaper but adds a dependency. EigenDA is Ethereum-aligned but newer. Or just use Ethereum blobs and pay more?

  3. Settlement: Ethereum L1, obviously. But wait - some L2s are building L3s that settle to L2s. Do I need to think about this?

  4. Shared security: EigenLayer AVS? Or just deploy to an L2 that handles this? What does “shared security” even mean for my lending protocol?

  5. Interoperability: If I deploy on Base, how do users on Arbitrum interact? LayerZero? Chainlink CCIP? Wormhole? Hyperlane?

  6. Indexing: The Graph? Subsquid? Self-hosted? Each chain has different indexing support.

The Comparison

DeFiLlama now tracks 396 blockchains. The long tail grew from 9% to 12% of total TVL in a year. More chains, more fragmentation, more complexity.

Meanwhile, on Solana:

  1. Pick Solana
  2. Deploy
  3. Done

I’m not saying Solana is better. But the monolithic developer experience is dramatically simpler.

What We Actually Need

Chain abstraction is the buzzword, but the concept is right:

  • Users shouldn’t know which rollup they’re on
  • Developers shouldn’t need a PhD in modular architecture to deploy a lending protocol
  • The “stack” should be an implementation detail, not a product decision

Projects like Particle Network (Universal Accounts), NEAR’s Chain Signatures, and Abstract Chain are trying to solve this. But we’re years away from these being mature enough for production.

The Uncomfortable Question

Has modularity become complexity for its own sake? Are we building infrastructure for infrastructure’s sake while actual users can’t even bridge $50 without three transactions and a prayer?

I love the modular thesis in theory. In practice, it’s crushing developer productivity.

Who else is feeling this?

2

I hear you, but I think you’re conflating “complex” with “wrong.”

The Modularity Thesis Still Holds

The whole point of modularity is specialization. Each layer does one thing well:

  • Execution layers optimize for computation
  • DA layers optimize for data throughput
  • Settlement layers optimize for security

This is the same pattern that made the internet work. TCP/IP, DNS, HTTP, TLS - each layer is specialized. Nobody complains that the internet protocol stack is “too modular.”

The Problem Isn’t Modularity - It’s Maturity

When HTTP was new, building a website was painful too. There was no WordPress, no Vercel, no React. You wrote raw HTML, managed your own servers, and handled TCP connections.

We’re at the “raw HTML” phase of modular blockchains. The abstractions will come.

What’s Already Working

OP Stack is a great example. You don’t need to understand consensus, DA, or settlement to launch an L2. Coinbase launched Base with a small team using OP Stack.

Rollup-as-a-Service providers (Caldera, Conduit, AltLayer) abstract most infrastructure decisions.

The tooling is improving rapidly:

  • 2023: Roll your own rollup
  • 2024: RaaS providers handle deployment
  • 2025: One-click L2/L3 deployment
  • 2026: Chain abstraction hides everything

Where I Agree

The DA fragmentation is real. Having 5+ DA layers competing creates confusion. But competition drives innovation and lower prices. EigenDA cut prices 10x specifically because of Celestia competition.

The market will consolidate. We’ll probably end up with 2-3 DA layers, just like we have 2-3 cloud providers.

3

From an operations perspective, the modular stack is a nightmare.

The Monitoring Problem

For a monolithic app on Solana, I monitor:

  • One RPC endpoint
  • One chain’s health
  • One set of programs

For a modular app on Arbitrum + Celestia:

  • Arbitrum sequencer health
  • Ethereum L1 finality
  • Celestia DA availability
  • Bridge contract status
  • Cross-chain message queues
  • Multiple RPC endpoints

6x the monitoring surface for the same business logic.

Incident Response Complexity

When something breaks in a monolithic system, the blast radius is contained. When something breaks in a modular system:

  1. Is it the execution layer? Check the sequencer.
  2. Is it DA? Check Celestia/EigenDA.
  3. Is it settlement? Check Ethereum.
  4. Is it bridging? Check LayerZero/CCIP.
  5. Is it the indexer? Check The Graph.

Debugging across layer boundaries is painful. Logs don’t correlate. Timestamps don’t match. Error propagation is unpredictable.

The Operations Tax

I estimate modular infrastructure requires:

  • 2-3x more monitoring than equivalent monolithic
  • 3-5x longer MTTR (Mean Time To Resolution) for cross-layer issues
  • 2x more on-call engineers for adequate coverage

None of this is in the marketing materials for modular blockchains. The thesis says “separation of concerns” but operations says “separation of blame.”

Modularity is great for architecture diagrams. It’s terrible for 3AM incident response.

4

The startup perspective on this is brutal: analysis paralysis is killing velocity.

Our Decision Process

We spent 6 weeks evaluating where to deploy. SIX WEEKS. For a team of 5 people burning $80K/month in runway.

The evaluation matrix:

Factor Base Arbitrum zkSync Starknet
Dev tooling Great Good Okay Painful
User base Growing Largest Small Tiny
Cost Low Low Low Medium
Ecosystem Coinbase Diverse Limited Niche
Future-proof Unclear Likely Unclear Unclear

Every chain has trade-offs. Every advisor has a different opinion. Every VC portfolio company pushes their ecosystem.

The Real Cost

Those 6 weeks cost us:

  • $120K in runway burned on evaluation
  • 3 engineers not writing product code
  • A competitor who just picked Solana and shipped

What Startups Need

  1. Opinionated defaults - “If you’re building X, use Y”
  2. Migration paths - “Start here, move there later”
  3. Honest benchmarks - Not marketing, real performance data
  4. Fewer choices - Consolidation is good for builders

The modular thesis might be technically correct. But if it takes a startup 6 weeks to pick a deployment target, the ecosystem has failed at developer experience.

We ended up on Base because our PM said “just pick one.” That’s not how infrastructure decisions should work.