As demand for blockchain applications grows, the need for scalable infrastructure has become paramount. Whether it’s the congestion seen during the 2017 CryptoKitties craze, the gas wars of DeFi summer, or the rise of on-chain AI agents, blockchains must process increasing transaction loads without compromising decentralization or security. Scalability is no longer a theoretical challenge—it’s a practical necessity for blockchain adoption.
Two dominant paradigms have emerged in tackling scalability: Layer 1 scaling (modifying the base blockchain itself) and Layer 2 scaling (building auxiliary protocols atop existing blockchains). This chapter provides a clear comparison between these approaches—highlighting their benefits, trade-offs, and how they shape the future of decentralized systems.
Layer 1 refers to the base blockchain protocol, such as Ethereum, Bitcoin, or Solana. Scaling Layer 1 involves changing the underlying consensus mechanism, data structure, or execution environment to boost performance.
Sharding, for instance, divides the blockchain into smaller, parallel chains (shards) that process transactions independently. This not only increases throughput but also reduces the storage and computational burden on individual nodes, making it easier for more participants to run full nodes and maintain decentralization.
Increasing Block Size or Block Frequency
More transactions per block or faster blocks can increase throughput. However, this increases the resource requirements for running full nodes, possibly reducing decentralization.
Optimizing Execution Environments
Ethereum’s move toward the Ethereum Virtual Machine (EVM) and other chains adopting alternative VMs (MoveVM, WASM) aim to reduce computation cost and improve parallelizability.
Consensus Optimization
Switching from energy-intensive PoW (Proof of Work) to more efficient PoS (Proof of Stake) improves finality and throughput. Further optimizations like pipelining and signature aggregation reduce consensus latency.
Sharding
Dividing the blockchain into smaller parts (shards) so different transactions can be processed in parallel. This increases throughput while keeping node requirements manageable.
Layer 2 (L2) solutions operate on top of Layer 1, offloading computation and storage while anchoring security back to the base layer. L2s are increasingly favored for their modularity, faster innovation cycles, and lighter trust assumptions (by leveraging Layer 1 security).
While Optimistic Rollups offer lower computational costs and are easier to implement, they introduce a challenge period (typically 7 days) during which transactions can be disputed. This delay can be a bottleneck for applications requiring instant finality. In contrast, zkRollups provide near-instant finality through cryptographic proofs but require more complex infrastructure and higher upfront costs.
State Channels
Two parties lock funds on L1 and interact off-chain, only submitting the final state to L1. Great for recurring transactions between fixed participants.
Plasma
A hierarchical chain structure where child chains handle transactions and periodically commit results to L1.
Optimistic Rollups
Transactions are executed off-chain and posted to L1 with a challenge period. Assumes correctness unless proven otherwise. Lower cost, but slower finality due to dispute windows.
Zero-Knowledge Rollups (zkRollups)
Batch transactions are executed off-chain and verified on-chain using succinct cryptographic proofs. Offers fast finality and lower gas, but comes with higher complexity.
| Feature | Layer 1 Scaling | Layer 2 Scaling |
|---|---|---|
| Definition | Scaling the base protocol | Scaling via secondary protocols on top of L1 |
| Security Anchoring | Native to L1 | Inherited from L1 |
| Decentralization Impact | Can decrease if node costs increase | Preserves decentralization (if well designed) |
| Implementation Complexity | Protocol-level changes | Independent, can evolve rapidly |
| Upgrade Speed | Slow (requires consensus) | Fast (independent teams, less governance) |
| Modularity | Less modular | Highly modular (e.g., shared sequencers) |
| Examples | Ethereum 2.0, Solana, Aptos | Arbitrum, Optimism, Starknet, Reddio |
| Throughput (TPS) | 10–100 (Ethereum), 4,000+ (Solana) | 2,000–50,000 (Rollups) |
| Latency | High (minutes to hours) | Low (seconds to minutes) |
| Cost per Transaction | High (gas fees) | Low (amortized across batches) |
Both approaches present trade-offs that reflect deeper engineering and governance decisions.
Layer 1 Scaling is critical for long-term systemic performance and for enabling L2s to thrive (e.g., Ethereum’s proto-danksharding for rollup data). However, it requires broad consensus, rigorous testing, and risks centralization if node requirements rise.
Layer 2 Scaling allows rapid experimentation and composability. Projects like Starknet and Optimism push forward zk and fraud-proof technologies, while enabling users and devs to benefit from Ethereum’s trust guarantees.
Ethereum’s transition to Proof of Stake (PoS) with the Merge is a prime example of Layer 1 scaling. By reducing energy consumption and improving finality, PoS has laid the groundwork for future scalability improvements like sharding. Meanwhile, Layer 2 solutions like Arbitrum and Starknet have already reduced gas fees by up to 90%, making DeFi applications more accessible to everyday users.
While Layer 2 solutions offer significant scalability improvements, they are not without risks. For example, Optimistic Rollups rely on fraud proofs, which require users to monitor the chain for malicious activity. If users fail to do so, they risk losing funds. Similarly, zkRollups, while secure, require complex cryptographic infrastructure that can be challenging to implement and maintain.
Rather than being in conflict, Layer 1 and Layer 2 solutions are complementary. Layer 1 provides a secure and decentralized foundation, while Layer 2 enables scalable and application-specific environments.
Scaling blockchain is not a single-track journey. While Layer 1 changes lay the groundwork for a performant base, Layer 2 innovations accelerate real-world usability. Understanding their strengths, limitations, and interplay is crucial for builders, researchers, and users shaping the decentralized future.
In the next chapter, we’ll dive deeper into Layer 1 scaling—exploring the techniques used to scale consensus, execution, and data availability within the core protocol. As we’ll see, scaling the base layer is not just about increasing throughput—it’s about balancing performance, security, and decentralization in a way that supports the entire blockchain ecosystem.