Reading the room in a room of code.
Over the past seven days, the total value secured by dedicated data availability (DA) layers—Celestia, Avail, EigenDA—has ticked up by a meager 2.3%, even as new rollup announcements flood X feeds. Meanwhile, Ethereum's blob space remains persistently underused: average blob utilization hovers around 12% of the target, with only occasional spikes during memecoin mania. I’ve been watching these on-chain metrics since I started running my own light nodes in 2022, and the pattern is unmistakable: the market is pricing in a DA shortage that doesn’t exist.
Let me state the obvious: the modular blockchain thesis—separate execution from consensus, outsource data availability—is intellectually elegant. But elegance isn’t demand. And demand is what pays for security budgets.
Context
The DA narrative exploded in late 2023 when Celestia’s mainnet launched, promising "scalable, verifiable data availability" for rollups. The pitch was simple: why pay Ethereum’s hefty blob fees when you can post data to a custom chain optimized for throughput? In theory, rollups could achieve lower costs and higher throughput by using alternative DA layers. The modular narrative became the darling of VCs, with Celestia raising $55 million at a $1 billion valuation, followed by Avail and EigenDA raising similar sums.
But here’s the friction point I keep hitting when I audit rollup architectures: most rollups aren’t actually generating enough transaction data to justify the switching cost. A standard optimistic rollup like Arbitrum or Optimism produces roughly 500-700 kilobytes of calldata per day during normal activity. That’s less than a single JPEG image. Ethereum blobs (4844) currently allow 6 blobs per block at ~125 kB each, totaling about 750 kB every 12 seconds. The math is brutal: even during peak activity, a single blob can absorb an entire rollup’s daily output.
Why would a rollup developer jump through the hoops of integrating a new DA provider, adding trust assumptions and latency, when Ethereum’s native capacity is already sitting idle?
Core Insight: The Data Volume Mismatch
Let’s quantify this. Over the last 30 days, the average daily calldata posted by the top 10 rollups (by TVL) was: - Arbitrum One: ~2.1 MB - Optimism: ~1.8 MB - Base: ~3.5 MB - zkSync Era: ~1.2 MB - Starknet: ~0.9 MB
Now compare that to Ethereum’s blob capacity. Post-4844, the target blob count per block is 3, with a maximum of 6. At 125 kB per blob, that’s a target throughput of ~375 kB per block or ~3.5 MB per minute. Even if we conservatively assume only 50% of blocks achieve target, that’s still ~1.75 MB per minute. In one minute, Ethereum can already handle the daily output of most rollups. The system is dramatically overprovisioned.
I don’t need to be a cryptographer to see the mismatch. I ran the numbers using my own Python script pulling blob data from Etherscan’s API. The results confirmed what I observed in late 2024: blob demand is spiky, driven by short-lived NFT mints or airdrop claims, but the baseline is low. The average daily blob utilization rate (blobs used / max possible) over the past month is 11.7%. That’s a huge gap.
Why are rollups not using blobs more aggressively? Partly because blob fees are still non-zero (average 0.01 ETH per blob, ~$20), but mostly because rollup operators are conservative. They’re waiting for the next L1 upgrade to make blobs cheaper, or they’re simply not growing fast enough. Either way, the demand for dedicated DA layers is a solution in search of a problem.
The Contrarian Angle: The Real Bottleneck Is Settlement, Not Availability
Here’s what the modular narrative gets wrong: the bottleneck for rollup throughput isn’t where you put the data—it’s how fast you finalize it. A rollup can post a million bytes of data per second to Celestia, but if the settlement layer (Ethereum mainnet) takes seven days for fraud proofs (optimistic) or hours for validity proofs (ZK), the user experience of "fast finality" is an illusion. The data availability only matters after the data is committed to an L1. But current L1 settlement latency is still the weakest link.
I’ve been tracking proof finality times for ZK rollups. Over the past two weeks, the average time from submitting a batch to receiving a validity proof on Ethereum is 12 minutes for Scroll, 8 minutes for Linea, and 23 minutes for Polygon zkEVM. That’s orders of magnitude slower than the data posting itself. If we truly want sub-second L2 transactions, we need faster settlement—not faster DA. Optimistic rollups are even worse: they wait the entire challenge period (7 days) before bridging capital out, even if they use a dedicated DA.
The overlooked truth: dedicated DA layers introduce a new trust assumption without solving the finality problem. To use Celestia, a rollup must trust that Celestia’s light nodes (or sampling quorum) are honest—at least for the duration of the data availability window. That’s a heavier assumption than relying on Ethereum’s full nodes, which have been battle-tested for over a decade. In my conversations with rollup engineers at the Modular Summit 2025, most admitted that they maintain an emergency fallback to Ethereum blobs precisely because they don’t fully trust DA layer liveness.
Takeaway: What the Narrative Misses
The DA overhype will correct. Not because the technology is flawed, but because the demand curve is too flat. Most rollups will never hit the scale where Ethereum’s blob capacity becomes a bottleneck—at least not until L2 user activity grows by an order of magnitude. The sustainable narrative is not "DA layers replace Ethereum blobs," but "DA layers serve as high-throughput niche use cases (gaming, DePIN) where settlement finality is less critical."
I don’t know if we’ll see a DA market crash in 2026, but I do know this: the next bull run will be built on settlement innovation (parallel execution, ZK proof aggregation, native L1 finality), not on glorified data buses. The modular thesis is a valuable tool, but it’s not the entire cathedral.
Reading the room in a room of code—the real signal is in the settlement stack, not the blob bus.