Every scaling argument ends the same way: blockchains cannot be fast, cheap, and decentralised at once, so the work moved to layers on top. Layer 2s execute transactions somewhere else and post the results back to the base chain, inheriting its security while escaping its throughput ceiling. That one-sentence summary hides most of the engineering — and most of the trade-offs a user or a founder actually feels. This guide walks the parts that matter in practice: how rollups pay for data, why optimistic and ZK designs disagree, what bridging really does, and how to choose a network without the marketing.
Rollups are a trade, and the trade is data
A rollup runs its own execution — hundreds of transactions bundled into one — then posts a compressed result to Layer 1. Execution is cheap because it is off-chain; security is real because the data needed to reconstruct the chain lives on Ethereum. The bottleneck that decides everything is that posting step: data availability, the guarantee that anyone can verify the rollup's state even if every rollup operator vanished.
EIP-4844 changed the economics here. Blob space gave rollups a dedicated data lane priced separately from normal gas, and fee curves that were wild became merely seasonal. When you see an L2 fee of a fraction of a cent, this is the mechanism underneath — and when L2 fees spike together, it is usually blob demand, not your specific rollup misbehaving.
Optimistic and zero-knowledge are two ways to answer the same question
The question: how does Layer 1 know a rollup's posted result is honest without re-running everything?
Optimistic rollups assume results are valid and give challengers a window — historically about seven days — to prove fraud with a fault proof. The cost is the withdrawal delay, a week of waiting for funds to leave unless a liquidity provider fronts you for a fee. The benefit is maturity: the longest-running L2s, Arbitrum and Optimism among them, use this design, and their tooling reflects years of production traffic.
Zero-knowledge rollups prove validity mathematically before posting, so withdrawals clear as soon as the proof verifies — minutes, not days. The cost has been engineering: the EVM does not map cleanly onto proofs, so ZK rollups either run a compatible-but-different virtual machine or pay overhead to prove standard EVM execution. That gap has narrowed enough that ZK networks now carry real volume; the design trade is no longer "mature versus experimental," it is "years of tooling versus faster exits and stronger state guarantees."
For a user, the practical difference compresses to one question: how often do you need to move funds back to mainnet, and what is that waiting worth to you?
Validiums and sidechains: the same trade pushed further
The title of this guide promised validiums, so here is the part most explainers skip. A validium keeps the validity-proof math of a ZK rollup but moves the data availability off-chain: the proof guarantees correct execution, but the data needed to reconstruct state lives with a committee or an external DA layer instead of on Ethereum. That removes the data cost — validium transactions can be dramatically cheaper — and reintroduces a trust assumption with it. If the data committee withholds data, your funds are not lost, but they are frozen until the committee cooperates. This is the exact trade a rollup refuses, which is why L2BEAT classifies validiums as a separate category rather than a kind of rollup.
A sidechain pushes the trade further still: it runs its own consensus entirely and periodically checkpoints to the main chain, if that. Nothing about an Ethereum checkpoint secures the sidechain's internal blocks — a compromised sidechain validator set can reorder or censor transactions between checkpoints, and the bridge out is only as good as the bridge contract. Polygon PoS is the canonical example: enormously successful by adoption, but its security story is Polygon's, not Ethereum's.
The useful mental model is a dial, not a taxonomy. At one end, a rollup: everything guaranteed by Layer 1. At the other, a sidechain: everything guaranteed by someone else. Volitions — systems that let a per-application choice between rollup and validium mode — make the dial explicit. Where a design sits on the dial should be stated in its documentation in one sentence; if you cannot find that sentence, treat the silence as the answer.
Who is actually running these things
A rollup's decentralisation story is a chain of roles: who sequences transactions, who posts data, who can force inclusion if the sequencer censors you. Most major rollups still run centralized sequencers today — one operator orders transactions — while the fraud- or validity-proof layer keeps that operator honest about state. The honest summary is "sequencer trust, proof-guaranteed correctness," and the upgrade paths (shared sequencers, decentralised prover sets) are the live work in the space.
What you can check rather than trust: whether escape hatches exist. A rollup where users can force a withdrawal through Layer 1 even if the operator disappears is categorically safer than one where the operator is the only exit. This is a documentation question, answerable in ten minutes, and it filters more marketing than any benchmark.
Decentralisation also has stages, and the stages are auditable. L2BEAT's framework — Stage 0 through Stage 2 — grades exactly this: a Stage 0 system depends on operator goodwill or training wheels, a Stage 1 system runs functioning proofs with a security council that has narrow powers, and a Stage 2 system is fully trust-minimised, with proofs that cannot be overridden. Checking an L2's current stage takes five minutes and tells you more about its maturity than any throughput claim, because the stage grades the failure modes — what happens when things go wrong — rather than the happy path.
Bridging exposes every assumption at once
Bridges fail differently than chains: the chain keeps running while your wrapped assets on the other side become unbacked. Every major bridge exploit in this space has been a contract or key compromise, not a chain-level break, which means bridge choice is really about custody — who controls the locked funds and who can pause the system.
Native rollup bridges inherit L1 security and are the slow-but-sure option, especially outbound from optimistic designs. Third-party bridges trade trust assumptions for speed; the liquidity networks that settle instantly between L2s avoid wrapped assets entirely for supported tokens. Match the bridge to the amount: convenience designs for small transfers, native paths for anything that would hurt to lose.
The fee picture, plainly
Post-4844, a typical token transfer on a major L2 costs fractions of a cent to a few cents; the same transfer on mainnet costs orders of magnitude more. Swap fees add a percentage, and heavy applications (perps, minting) add their own layer. The variation between L2s is real but small next to the L1 baseline — if a network markets itself on being a tenth of a cent cheaper than a competitor, that is not a reason to move.
The fee that actually surprises people is the exit: withdrawing through the native optimistic path costs an L1 transaction, which can exceed everything you saved by using the L2 that week. Frequent small users should stay on L2; people shuttling funds constantly are paying the bridge tax in time or money, one way or the other.
A worked comparison makes the shape of the decision concrete. A hundred small transactions — the volume a moderately active user generates in a few months — cost a few dollars in total on a major L2 and would cost tens of thousands on mainnet at 2021 fee peaks. The same hundred transactions plus one native optimistic exit costs the L2 total plus one mainnet transaction: the exit dominates the bill the moment you leave. The lesson is not "exits are expensive" — it is that L2 economics reward depth of stay, and any strategy built on frequent round-trips has chosen the wrong layer.
How an L2 fee is actually built
Every L2 transaction fee decomposes into two parts, and knowing which is which explains most fee behaviour. The first is the L1 data fee: your transaction's compressed share of the blob space the rollup posts to Layer 1. This part floats with blob demand — when a burst of mints or a busy market hour congests blob space, every rollup's fees rise together, which is the correlation people read as "all L2s are down." The second is the L2 execution fee, priced by the rollup's own market for its compute, and this is the part that varies meaningfully between networks.
The decomposition also explains why transaction type matters more than most people expect: a simple transfer carries a few bytes of data, while an NFT mint or a contract interaction carries many more, so the same network can charge a fraction of a cent for the first and several cents for the second. Wallets that show a fee breakdown are showing you this decomposition; the L1 data line is the one you cannot influence, the execution line is the one the rollup can tune.
The interop problem is the real user cost
The quiet cost of the rollup-centric roadmap is fragmentation: rollups do not talk to each other natively. Moving a stablecoin from one L2 to another means either routing through Layer 1 — hours to a week depending on the source design — or using a liquidity network that settles instantly for a fee. Neither is broken; both are friction, and the friction compounds for every new L2 that launches.
The ecosystem's answers are in progress: shared sequencers that order transactions across multiple rollups, messaging standards that give rollups a common way to pass proofs and assets, and intent-based bridges that abstract the routing entirely. Until those mature, the practical rule is what experienced users already do: keep the assets you actively use on one L2, keep long-term holdings where withdrawal assumptions are strongest, and treat cross-L2 movement as a real cost to minimise — not a free right the ecosystem owes you.
Choosing a network
In order of what actually matters: does the application you want run there natively; does the rollup have force-inclusion and a live proof system; how deep is the liquidity for what you do; and only then, fees. Ecosystem gravity is real — apps go where the users are, and users go where the apps are — so "where is my application deployed" answers most questions before throughput benchmarks get a word in.
The deeper shift worth understanding: with blobs and rollup maturity, scaling stopped being the user's problem. Choosing an L2 in 2026 is less like choosing a chain and more like choosing a region to deploy in — a real decision, but one with fewer catastrophic wrong answers every quarter.
If you are deploying: the pre-deployment checklist
Choosing a network as a user is a five-minute exercise. Choosing one as a founder is heavier, because your contract inherits the chain's assumptions permanently. The checklist that matters, in order: is the proof system live and at what stage; can users force-include transactions past a censoring sequencer; what is the data availability mode, and who can withhold data; who controls bridge upgrades, and with what timelock; and how does the sequencer's fee volatility behave under blob-demand spikes — because your users will experience that volatility as your app's cost. A design that is fine for a consumer app can be wrong for a payments product, and the difference is almost always the exit assumptions.
Two habits keep the decision honest. Write down, at deployment time, the one-paragraph trust summary of your chain — who can freeze withdrawals, who can reorder transactions, who holds upgrade keys — because that paragraph is what you will be asked for in diligence, in audits, and by sophisticated users. And revisit it when the chain's stage changes: an upgrade from Stage 0 to Stage 1 materially changes what you have promised your users, in your favor; a change in data availability mode can change it against you.
References
Next, read Modular Blockchains. More in Infrastructure & Scaling.