Rollups, Sidechains, and Alternative L1s

The blockchain scalability problem—scaling without sacrificing security or decentralization—is the fundamental challenge. The main approaches are Layer 2 solutions (rollups), sidechains, sharding, and alternative Layer 1 blockchains. Each makes different blockchain trilemma tradeoffs.

Layer 2 Solutions: Rollups

L2 solutions: process off-chain, prove on-chain. Layer 2 solutions execute transactions off the main blockchain (Layer 1), then post proofs or transaction data back to Layer 1 for security.

Execution is expensive, but verification is cheap. Rollups move execution off-chain where it can be fast and cheap, while keeping verification on-chain where it inherits Layer 1 security.

How rollups work:

1. Users send transactions to the rollup operator

2. The operator executes thousands of transactions off-chain

3. The operator batches these transactions and submits a single summary to Layer 1

4. Layer 1 validates the summary (much cheaper than re-executing every transaction)

5. Layer 1 stores enough data to reconstruct the rollup state if needed

One Layer 1 transaction might include 1,000 rollup transactions. This 1,000-to-one compression is why rollups scale.

Optimistic Rollups (Arbitrum, Optimism, Base):

Optimistic rollups assume transactions are valid unless someone proves otherwise. The operator posts transaction batches to Layer 1 without proof. Anyone can challenge a batch within a dispute period (typically seven days) by proving it is invalid.

If no one challenges within the dispute period, the batch is considered final. If someone successfully challenges, the invalid batch is reverted, and the operator loses staked funds.

This optimism gives high throughput—no expensive proofs for every batch. But withdrawals are delayed. Moving assets from the rollup back to Layer 1 requires waiting for the dispute period to ensure no one will challenge your withdrawal.

Zero-Knowledge Rollups (StarkNet, zkSync, Scroll):

ZK rollups generate cryptographic proofs that transactions were executed correctly. The operator posts transaction batches plus a zero-knowledge proof to Layer 1. Layer 1 verifies the proof, which is much cheaper than re-executing the transactions.

Zero-knowledge proofs guarantee correctness without revealing transaction details or requiring trust. If the proof verifies, the transactions are mathematically certain to be correct.

This gives instant finality—no waiting period for challenges. Once the proof is verified on Layer 1, withdrawals can complete immediately. But generating zero-knowledge proofs is computationally expensive and requires specialized hardware.

Rollups inherit Layer 1 security—transactions are protected by Ethereum's security model. Transaction costs drop 10 to 100 times compared to Layer 1, and throughput increases by a similar factor. Users can use familiar wallets and tools.

But rollups add complexity—assets must bridge between layers, optimistic rollups have withdrawal delays, and ZK rollups require expensive proof generation. All rollups are still limited by Layer 1 data availability.

Sidechains: Separate Security

Sidechains are separate blockchains with their own consensus mechanisms, connected to the main chain through bridges. Polygon PoS is the most widely used Ethereum sidechain.

Unlike rollups, sidechains do not inherit the main chain's security. They are responsible for their own security through their own validator sets and consensus mechanisms.

How sidechains work:

1. Lock assets on the main chain

2. Corresponding assets are minted on the sidechain

3. Transact freely on the sidechain with its own rules and speed

4. When ready, burn assets on the sidechain

5. Unlock corresponding assets on the main chain

Sidechains can optimize for different tradeoffs than the main chain. They might sacrifice decentralization for higher throughput, or use different consensus mechanisms better suited to specific applications.

Sidechains can change any rule or parameter without Layer 1 constraints, achieve very high throughput since they are not limited by Layer 1 data availability, and cost less to operate. Developers can experiment without affecting the main chain.

But sidechains have a separate security model—they are not protected by the main chain, and bridges between chains are common attack targets. Sidechains typically have fewer validators than the main chain, reducing security guarantees while fragmenting liquidity across multiple chains.

Sharding: Parallel Chains

Sharding splits the blockchain into multiple parallel chains that process transactions simultaneously. Instead of one chain processing all transactions, multiple shards process subsets of transactions in parallel.

Sharding is horizontal scaling—instead of making one chain faster, multiple chains run in parallel.

How sharding works:

1. Divide accounts and contracts across multiple shards

2. Each shard processes transactions affecting only its accounts

3. Cross-shard transactions require coordination between shards

4. A beacon chain coordinates the shards and ensures consistency

If 64 shards each process 15 transactions per second, total throughput reaches 960 transactions per second.

Sharding has major challenges. Cross-shard communication is complex and slow, and security per shard decreases since the validator set is split across shards. State becomes fragmented—you cannot easily query across shards—and the protocol design is far more complex.

Ethereum is implementing sharding, but full deployment will take years and requires fundamental protocol changes.

Alternative Layer 1 Blockchains

Alternative Layer 1 blockchains redesign the entire architecture from first principles to achieve different trilemma tradeoffs. Solana, Sui, Aptos, and Avalanche each take different approaches to the scalability problem.

Instead of building on Ethereum's sequential execution model, alternative L1s redesign consensus mechanisms, execution environments, and data structures to optimize for higher throughput.

Common approaches include parallel execution, where independent transactions process simultaneously using multiple CPU cores (which requires knowing which transactions conflict before execution). Optimized consensus uses Proof of Stake with different parameters—fewer validators, faster block times, different finality guarantees—trading some decentralization for speed. Different virtual machines replace the EVM with execution environments optimized for parallel processing or specific use cases. Novel data structures redesign how transactions and state are stored for faster access and modification.

Alternative L1s can achieve much higher throughput—1,000 to 50,000+ TPS—with lower transaction costs and faster finality. Many are purpose-built for specific use cases.

But these chains are less battle-tested than Ethereum or Bitcoin. They often have fewer validators, trading decentralization for speed, and their ecosystems are smaller with fewer applications and tools. Hardware requirements are higher—validation is more expensive—while network effects favor established chains and make it harder for new L1s to attract users and developers.

Comparing Solutions

Each scaling solution makes different tradeoffs:

Use Ethereum L1 for maximum security on high-value transactions. Use optimistic rollups for general-purpose applications that need L1 security with lower costs. Use ZK rollups for applications that need instant finality with L1 security. Use sidechains for specialized use cases that accept separate security. Sharding is for long-term scaling of established chains but is still being developed. Use alternative L1s for applications that prioritize throughput and cost over maximum decentralization.

The right choice depends on security requirements, throughput needs, cost constraints, and decentralization priorities.

The Path Forward

Layer 2s, sidechains, sharding, alternative L1s—each approach makes different tradeoffs. Some inherit Ethereum's security but add complexity. Some sacrifice decentralization for speed. Others rethink the entire architecture from first principles.

Solana approaches the scalability challenge differently: order everything first using Proof of History, then execute non-conflicting transactions simultaneously.