Ethereum has a capacity problem that becomes easier to see when the network is busy: every transaction competing for space on the main chain adds pressure to a system where block space is limited.
That creates an obvious question. If Ethereum is not going to process every transaction directly on its mainnet, where does the work happen — and how can the network still know that the result is correct?
That is the basic idea behind Ethereum rollups. They move much of the transaction execution to a Layer 2 network, bundle many operations together and send the relevant information back to Ethereum for settlement and verification.
The important part is not simply that rollups can make transactions cheaper. It is understanding what they move away from Ethereum, what still depends on Ethereum, and why that distinction matters.
Why Ethereum does not need to execute every transaction itself
Ethereum’s mainnet is valuable partly because it provides a shared environment where the network can independently verify transactions and state changes. But that security comes with a practical constraint: block space is scarce.
If every application, user and transaction has to compete directly for that same space, demand can push gas fees higher.
Rollups approach the problem differently. A Layer 2 can execute transactions away from Ethereum’s main execution layer, allowing many more operations to be processed without requiring every individual transaction to be executed separately on the mainnet.
Ethereum’s own documentation describes rollups as scaling solutions that process transactions off-chain and then publish information back to the mainnet. A single batch can represent thousands of individual transactions.
That changes the economics.
Instead of paying to record every operation independently on Ethereum, a rollup can combine many transactions into a batch. The cost of publishing the relevant data can then be shared across those transactions.
Ethereum remains involved. What changes is where most of the execution takes place.
The journey from a rollup transaction to Ethereum
Imagine sending a transaction through a Layer 2.
First, the transaction is received and executed by the rollup’s infrastructure rather than directly by Ethereum’s mainnet. The rollup processes the resulting state changes and groups multiple transactions together.
The next step is consolidation. Rather than sending thousands of separate operations to Ethereum, the rollup publishes a compressed representation of the batch and the information needed to establish what happened.
This is where the word rollup becomes useful. Many individual operations are effectively rolled into a smaller package before being settled on Ethereum.
The final stage depends on the type of rollup.
Ethereum has to have a way to determine whether the proposed state changes are valid. An arbitrary Layer 2 could simply claim that its transactions were correct, but that would not provide the security users expect from Ethereum.
Rollups therefore use different verification mechanisms to connect off-chain execution with Ethereum’s settlement layer.
Optimistic and ZK-Rollups solve the same problem differently
The two broad categories are Optimistic Rollups and ZK-Rollups.
Optimistic Rollups work on the assumption that submitted transactions are valid unless someone proves otherwise. They publish transaction data to Ethereum and allow incorrect state changes to be challenged through a fraud-proof mechanism.
The logic is relatively straightforward: do not require the Ethereum mainnet to re-execute every transaction itself, but leave a mechanism through which an invalid result can be contested.
ZK-Rollups take a different route.
They use cryptographic validity proofs to demonstrate that the proposed state transition is correct. Ethereum can verify that proof on the mainnet instead of redoing all of the computation itself.
For a newcomer, the distinction can be reduced to one idea:
Optimistic Rollups assume correctness unless challenged; ZK-Rollups provide a cryptographic proof of correctness.
Both are trying to achieve the same broader goal: move expensive execution away from Ethereum while retaining important security guarantees from the main network.
Why bundling transactions can reduce Ethereum fees
This is the part that matters most to an everyday user.
Ethereum transaction fees reflect demand for scarce block space and the resources required to process and publish information. A rollup changes how much information has to reach the Ethereum mainnet on an individual-transaction basis.
Suppose a rollup processes hundreds of transactions before publishing a batch. The underlying cost of using Ethereum for that batch is no longer attached to one transaction alone. It is distributed across many users.
Compression can reduce the amount of data that needs to be published as well.
Ethereum’s introduction of blobs made this process more efficient by creating a cheaper way for rollups to publish temporary data to the network. Blobs are priced separately from ordinary execution gas and are designed specifically to support rollup data.
That does not mean rollups make Ethereum free.
They still depend on Ethereum for settlement and data availability, and publishing information to the mainnet still has a cost. The key difference is that the cost can be spread across far more activity.
So the better way to think about rollups is not “a way around gas fees”.
It is a more efficient way of using Ethereum’s limited block space.
The overlooked part: rollups still need Ethereum
It is tempting to describe a Layer 2 as a separate blockchain that simply happens to work alongside Ethereum. That misses the most important architectural detail.
Rollups are designed to derive significant security properties from Ethereum. They use the mainnet to anchor state changes and make important information available for verification.
Data availability matters here.
Even when a ZK-Rollup supplies a validity proof, users still need access to the underlying state data to check balances, reconstruct the chain’s state and interact with it properly. A proof can demonstrate that a state transition is valid; it does not magically make the state itself unnecessary.
This is one reason rollups are different from simply running transactions on a completely separate chain.
The Layer 2 gains efficiency by moving work elsewhere, but it keeps a connection to Ethereum’s base layer for the guarantees that make the system useful.
The bigger change of Ethereum rollups isn’t cheaper transactions
There is a slightly counterintuitive idea at the heart of Ethereum’s rollup strategy.
The goal is not necessarily for more transactions to happen on Ethereum’s mainnet. In fact, successful scaling means that more activity can happen away from it.
That sounds like a contradiction until the role of the mainnet becomes clearer.
Ethereum can increasingly function as a shared settlement and security layer, while Layer 2 networks handle much of the everyday execution. Instead of forcing every application to compete for the same block space, the ecosystem can distribute activity across multiple environments while keeping Ethereum as the underlying settlement layer.
This changes what “using Ethereum” means.
A person swapping tokens on a Layer 2 may interact with Ethereum indirectly rather than submitting every transaction to the mainnet. Yet the security and settlement of that activity can still depend on Ethereum underneath.
That is the real significance of Ethereum rollups. They are not simply a trick for lowering gas fees. They represent a different way of organising blockchain infrastructure: let specialised networks handle more of the activity, while the base layer concentrates on the functions that are hardest to outsource.
The more effective that division becomes, the less Ethereum has to do directly — and that may be precisely what allows the network to support substantially more activity without making every additional transaction compete for the same scarce space.