What Are Layer 2s? How They Make Blockchains Faster and Cheaper

Picture a motorway with one toll booth. Every car, no matter how small the journey, has to queue at that single booth and pay whatever the attendant asks that day. That's roughly how a base blockchain like Ethereum works: every transaction, from a $5 swap to a $5 million settlement, competes for the same limited block space. When demand spikes, the toll — the gas fee — spikes with it. Layer 2s are what happens when someone builds a second, parallel road that feeds back into the motorway, letting most traffic bypass the booth entirely while still ending up at the same destination.

That's the plain-English version of what are layer 2s, and it's worth sitting with before we get technical, because the concept solves a real, unglamorous problem: blockchains that verify everything with every participant are slow and expensive by design. Layer 2s don't get rid of that verification. They just do most of the work off to the side and only check in with the main chain when it matters.

Why blockchains needed a second layer in the first place

Ethereum, at its base layer, processes somewhere in the region of 15 transactions per second when you account for real network conditions. Visa, by comparison, is built to handle tens of thousands. That gap isn't a bug the developers forgot to fix — it's the direct cost of decentralisation. Every full node on Ethereum re-executes every transaction to agree on the state of the network. More nodes verifying more thoroughly means more security, but it also means a hard ceiling on throughput. This is often called the blockchain trilemma: you can optimise for decentralisation, security, and scalability, but pushing hard on any two tends to squeeze the third.

For years the debate was whether to loosen decentralisation (bigger blocks, fewer node operators who can keep up) or loosen security (trust a smaller set of validators). Layer 2s offered a third path: keep the base layer exactly as conservative and slow as it needs to be for security, and build scaling on top of it instead of inside it.

How a layer 2 actually works

A layer 2 network takes a batch of transactions, executes them on its own infrastructure, and then posts a compressed summary — plus, critically, a proof or a dispute window — back to the base layer, which is usually called layer 1 in this context. The base layer doesn't need to re-run every individual transaction. It just needs enough information to confirm the batch was handled correctly, or to allow anyone to challenge it if it wasn't.

There are two dominant designs for doing this. Optimistic rollups assume transactions are valid by default and post them to layer 1 with a challenge period — usually about a week — during which anyone can submit a fraud proof if something looks wrong. Arbitrum and Optimism are the best-known examples. Zero-knowledge rollups, or ZK-rollups, take the opposite approach: they generate a cryptographic proof that the batch of transactions was executed correctly and submit that proof alongside the data, so there's no waiting period because the maths itself is the guarantee. zkSync and Starknet are built this way, and Polygon runs versions of both models across its ecosystem.

The practical difference shows up mostly in withdrawal times. Pulling funds back to layer 1 from an optimistic rollup can take days because of the challenge window; withdrawing from a ZK-rollup is typically much faster because the proof is already verified. Neither is strictly better — optimistic rollups have historically been easier to build general-purpose smart contracts on, while ZK-rollups have needed more specialised cryptography but are closing that gap quickly.

Why this matters for your wallet, not just the network

The abstract engineering matters less to most people than the concrete effect: fees. A token swap that might cost $15 to $40 in gas during a busy period on Ethereum mainnet can cost a matter of cents on Arbitrum, Optimism, Base, or zkSync. That's not a marginal improvement — it's the difference between a network that's usable for someone moving $50 and one that only makes economic sense for six-figure transfers.

Speed follows the same pattern. Layer 1 confirmations can take anywhere from 15 seconds to several minutes depending on network congestion and how many confirmations you want before treating a transaction as final. Layer 2s routinely confirm in a second or two, because they're not competing with the entire global user base for the same block space.

The trust model — what you're actually relying on

It's worth being precise about what security you're getting, because "layer 2" isn't a single guarantee. The whole design rests on the assumption that transaction data eventually lands on the base layer in a form that's verifiable — that's what lets you, in principle, reconstruct your balance even if the layer 2's own operator disappeared tomorrow. That property is called data availability, and it's the main thing separating a rollup from a sidechain.

Sidechains, like early versions of Polygon PoS, run their own independent consensus and only loosely connect back to Ethereum via a bridge. That makes them fast and cheap, but if the sidechain's own validators misbehave, layer 1 offers no automatic protection. Rollups, by contrast, inherit much more of Ethereum's security because the data and the proofs live on the base chain itself. This is the detail that separates marketing from mechanics — always check whether a network is actually posting its data to layer 1 or just claiming to be "secured by Ethereum" in a press release.

Bridging — the part that actually causes losses

Moving funds from layer 1 to a layer 2, or between two different layer 2s, requires a bridge. This is, bluntly, where most of the money has been lost in this entire category. The Ronin bridge hack cost roughly $625 million; the Wormhole exploit cost around $325 million. Neither of those was a flaw in the layer 2 concept itself — both were flaws in the specific bridge software holding the funds in escrow.

The rule of thumb: use the official bridge for a given network when possible, be suspicious of any bridge offering unusually generous incentives to route through it, and understand that funds sitting in a bridge contract are a single point of failure regardless of how secure the layer 2 itself is. If you're moving a meaningful amount, check the bridge's audit history and how long it's operated without incident before trusting it.

Picking a layer 2 in practice

For everyday use — swaps, NFT mints, small DeFi positions — the differences between Arbitrum, Optimism, Base, and zkSync matter less than people online will tell you. Fees are broadly comparable and all four have meaningful liquidity and active development. What matters more is which one has the app you actually want to use, since liquidity and tooling still cluster unevenly across networks.

For anything involving real money, check three things before you commit funds: how long the network has been live without a major incident, whether it's a rollup or a sidechain (the security trade-off discussed above), and whether withdrawal to layer 1 is straightforward or requires a third-party service you'd be trusting on top of the network itself.

The bigger picture

Layer 2s aren't a temporary patch — they're increasingly treated as the default execution environment, with Ethereum's base layer settling into a role closer to a security and settlement backbone rather than where everyday activity happens. That's a deliberate shift in how the ecosystem thinks about scaling, and it's why so much new development activity over the past two years has happened on rollups rather than layer 1 itself.

None of this requires you to understand zero-knowledge cryptography to use safely. What it does require is knowing the one question that actually protects you: where does the data for my transaction ultimately get recorded, and who can I trust to keep it honest. Get that answer for any network before you move meaningful funds onto it, and the rest of the complexity becomes optional reading.