The Quiet Auction Happening Every Twelve Seconds
You post a transaction on your favourite rollup and the fee is a fraction of a cent. Fine. You try again two hours later and it's ten times higher, even though the Ethereum base layer looks perfectly calm. No congestion warning. No explanation. The rollup just costs more right now, and nobody sends you a memo.
What's happening underneath is a fee market most people haven't read about: the blob fee market introduced by EIP-4844. It runs on its own logic, entirely separate from the gas market, and it gets genuinely interesting once several large rollups start competing for the same fixed supply of blob space inside a single block.
Let's work through exactly how that competition plays out.
What a Blob Is and Why the Supply Is Fixed
Before EIP-4844, rollups posted their transaction data to Ethereum as calldata, permanent and expensive because it lives in the chain's history forever. Blobs are different: large data chunks, roughly 128 KB each, that Ethereum nodes store for a short window (approximately 18 days under the initial spec) and then prune. Cheaper to store, cheaper to price, purpose-built for rollups.
The protocol sets a target of three blobs per block and a hard cap of six. Those numbers are not suggestions. A block physically cannot contain a seventh blob. Twelve seconds later, another block arrives with its own fresh supply of up to six. The auction resets. Demand doesn't.
Think of it like seats on a commuter train that runs every twelve seconds. Six seats, always. If nine rollups each want two seats, four of them are getting bumped, and they'll have to bid higher or wait for the next train.
The Pricing Mechanism Itself
The blob base fee works like Ethereum's EIP-1559 gas base fee: it adjusts algorithmically based on whether recent blocks landed above or below the target. Above three blobs, the base fee rises. Below three, it falls. The adjustment factor is 12.5% per block, which is aggressive enough that a sustained demand spike can push costs up by orders of magnitude in minutes.
Here's a concrete scenario with actual numbers. The blob base fee sits at 1 gwei. Three large rollups, call them A, B, and C, each need to post two blobs this block, totalling six. Block is exactly full. Base fee stays flat, everyone is served, life is peaceful.
Now Rollup D enters. It just processed a burst of on-chain activity and also needs two blobs. Total demand: eight blobs. Supply: six. Someone gets excluded. To guarantee inclusion, each rollup must offer a priority tip above the base fee. Rollup A and B are large enough that exclusion is genuinely costly: users get angry, withdrawals slow, sequencer revenue suffers. So they tip. The next block's base fee rises 12.5%, to roughly 1.125 gwei. If demand stays elevated across four or five consecutive blocks, the base fee compounds: 1 gwei becomes roughly 1.8 gwei after five blocks of sustained overfilling. After twenty blocks of sustained pressure, you're looking at a base fee over 10 gwei. After forty, it's north of 100 gwei.
That compounding is not a bug. It's the mechanism working exactly as intended: price signals are supposed to ration scarce space.
Why Rollups Don't Just Wait for a Quiet Block
A reasonable question: why not hold your blobs and post when the market cools?
Some rollups can, and do. Others face structural pressure to post quickly. A rollup offering fast finality guarantees, or one running a fraud-proof window tied to L1 data availability, cannot afford to sit on unposted data for twenty minutes. Every block of delay is a block where users' funds sit in a limbo the rollup's safety model didn't account for.
There's also a sequencer incentive problem worth naming plainly. Rollup sequencers collect fees from users on L2. If they delay posting to L1 to save on blob fees, they're pocketing the spread between what users paid and what they're saving. Some protocols have mechanisms to prevent this. Many don't, or don't fully. So sequencers face a genuinely mixed incentive: post fast to look trustworthy, or post slow to capture margin.
The result is that during genuine demand spikes, the rollups that most need to post are also the least able to wait. That's a recipe for a bidding war even when the rational move, in aggregate, would be to stagger submissions.
The Part That Runs Deeper Than Most People Expect
This is where the mechanics get genuinely subtle, and where the blob fee market differs from the gas fee market in a way that actually matters.
With gas, every user in every transaction across every rollup competes in the same pool. The fee signal is noisy but broad. With blobs, competition is between rollups as institutions, not between individual users. A rollup's blob-posting strategy is made by its sequencer software, often algorithmically, optimising for the rollup's aggregate position rather than any single user's experience.
Blob fee spikes are invisible to end users until they're already expensive. A user on Rollup A doesn't see the blob auction. They see the L2 transaction fee that Rollup A's sequencer charges them, which may or may not reflect the current blob market accurately or promptly. Some sequencers update their fee models in real time. Others update infrequently. Consider Priya and Marco: both using different rollups built on Ethereum, both submitting economically identical transactions at the same moment, paying wildly different fees because their sequencers have different blob-cost-passthrough policies. Neither of them has any idea why.
That asymmetry matters for market efficiency (meaning: how accurately prices reflect real scarcity). If sequencers absorb blob cost volatility rather than passing it through, they're subsidising demand and dampening the price signal. Users don't reduce activity in response to blob scarcity because they never see it. Demand stays elevated, blobs stay scarce, and the subsidy comes from somewhere, usually sequencer margins or, in some designs, protocol token treasuries.
The cleaner design, in terms of honest price discovery, is full cost passthrough. Users pay fees that reflect real-time blob costs. That makes rollups feel more expensive during competition spikes, but it gives users actual information to act on. Whether rollup teams choose that design is partly technical and partly competitive. A rollup that smooths fees looks cheaper in normal conditions, and that's a marketing advantage, even if it creates a hidden balance sheet risk. In my view, the smoothing approach is a short-term play that ages badly: it works until a prolonged congestion period blows through the buffer and users notice the discrepancy all at once.
One more wrinkle: blob space is priced per blob, not per byte of data inside the blob. A rollup posting a blob that's 30% full pays the same as one posting a blob that's 100% full. This creates a strong incentive to batch aggressively, to fill blobs as completely as possible before posting. Rollups that batch well get more data per unit of fee spent. Rollups posting sparse blobs are essentially donating capacity to nobody, since unused space inside a blob cannot be claimed by another rollup. That wasted capacity is, to put it plainly, just money left on the table.
What a Congestion Spike Actually Looks Like End-to-End
Pull the pieces together. A major NFT mint or a high-profile airdrop claim period launches on a rollup. Transaction volume spikes. The sequencer needs to post four blobs this block instead of two. Combined with normal demand from two other large rollups, total blob demand in that window hits eight or nine blobs per block. The hard cap is six.
The blob base fee starts climbing at 12.5% per block. Within thirty blocks, roughly six minutes, it has quadrupled. The rollup running the mint passes those costs to users, or eats them. Either way, every other rollup posting blobs in that window also pays the elevated base fee, even though they have nothing to do with the mint. Collateral damage in someone else's demand spike.
Users on Rollup B, facilitating routine token transfers, find their fees elevated because Rollup C is running a popular event. They have no idea why. The system is working correctly. That is just how a shared, capacity-constrained resource behaves when pricing is global.
Blobs Are Cheap Until They Aren't
The blob fee market is elegantly simple in design and genuinely complex in practice. A fixed supply, an algorithmic price adjuster, and a set of institutional competitors with different latency requirements and different fee-passthrough policies produce outcomes that are hard to predict from any single rollup's perspective.
The target of three blobs per block was chosen deliberately to leave headroom: in ordinary conditions, demand sits below the target and fees stay low. But the headroom is finite. As the rollup ecosystem grows, the distance between ordinary conditions and full blocks will shrink. When that gap closes regularly rather than occasionally, the blob fee market stops being a background curiosity and becomes a line item that rollup teams model carefully every single week.
The question worth sitting with: if your rollup's blob-batching efficiency is poor, who is actually paying for that waste? The answer, in one form or another, is always your users.
Fill your blobs or pay the same price to post air. That's not a design flaw to route around. It's the mechanism telling you something.