Decentralized systems like the electric grid and the World Wide Web scaled by solving communication bottlenecks. Blockchains, a triumph of decentralized design, should follow the same pattern, but early technical constraints caused many to equate decentralization with inefficiency and sluggish performance.

As Ethereum turns 10 this July, it’s evolved from a developer playground into the backbone of onchain finance. As institutions like BlackRock and Franklin Templeton launch tokenized funds, and banks roll out stablecoins, the question now is whether it can scale to meet global demand—where heavy workloads and millisecond-level response times matter.

For all this evolution, one assumption still lingers: that blockchains must trade off between decentralization, scalability, and security. This “blockchain trilemma” has shaped protocol design since Ethereum’s genesis block.

The trilemma isn’t a law of physics; it’s a design problem we’re finally learning how to solve.

Lay of the Land on Scalable Blockchains

Ethereum co-founder Vitalik Buterin identified three properties for blockchain performance: decentralization (many autonomous nodes), security (resilience to malicious acts), and scalability (transaction speed). He introduced the “Blockchain Trilemma,” suggesting that enhancing two typically weakens the third, especially scalability.

This framing shaped Ethereum’s path: the ecosystem prioritized decentralization and security, building for robustness and fault tolerance across thousands of nodes. But performance has lagged, with delays in block propagation, consensus, and finality.

To maintain decentralization while scaling, some protocols on Ethereum reduce validator participation or shard network responsibilities; Optimistic Rollups, shift execution off-chain and rely on fraud proofs to maintain integrity; Layer-2 designs aim to compress thousands of transactions into a single one committed to the main chain, offloading scalability pressure but introducing dependencies on trusted nodes.

Security remains paramount, as financial stakes rise. Failures stem from downtime, collusion, or message propagation errors, causing consensus to halt or double-spend. Yet most scaling relies on best-effort performance rather than protocol-level guarantees. Validators are incentivized to boost computing power or rely on fast networks, but lack guarantees that transactions will complete.

This raises important questions for Ethereum and the industry: Can we be confident that every transaction will finalize under load? Are probabilistic approaches enough to support global-scale applications?

As Ethereum enters its second decade, answering these questions will be crucial for developers, institutions and billions of end users relying on blockchains to deliver.

Decentralization as a Strength, Not a Limitation

Decentralization was never the cause of sluggish UX on Ethereum, network coordination was. With the right engineering, decentralization becomes a performance advantage and a catalyst to scale.

It feels intuitive that a centralized command center would outperform a fully distributed one. How could it not be better to have an omniscient controller overseeing the network? This is precisely where we would like to demystify assumptions.

Read more: Martin Burgherr — Why ‘Expensive’ Ethereum Will Dominate Institutional DeFi

This belief started decades ago in Professor Medard’s lab at MIT, to make decentralized communication systems provably optimal. Today, with Random Linear Network Coding (RLNC), that vision is finally implementable at scale.

Let’s get technical.

To address scalability, we must first understand where latency occurs: in blockchain systems, each node must observe the same operations in the same order to observe the same sequence of state changes starting from the initial state. This requires consensus—a process where all nodes agree on a single proposed value.

Blockchains like Ethereum and Solana, use leader-based consensus with predetermined time slots in which nodes must come to agreement, let’s call it let’s call it “D”. Pick D too large and finality slows down; pick it too small and consensus fails; this creates a persistent tradeoff in performance.

In Ethereum’s consensus algorithm each node attempts to communicate its local value to the others, through a series of message exchanges via Gossip propagation. But due to network perturbations, such as congestion, bottlenecks, buffer overflow; some messages may be lost or delayed and some may be duplicated.

Such incidents increase the time for information propagation and hence, reaching consensus inevitably results in large D slots, especially in larger networks. To scale, many blockchains limit decentralization.

These blockchains require attestation from a certain threshold of participants, such as two-thirds of the stakes, for each consensus round. To achieve scalability, we need to improve the efficiency of message dissemination.

With Random Network Linear Coding (RLNC), we aim to enhance the scalability of the protocol, directly addressing the constraints imposed by current implementations.

Decentralize to Scale: The Power of RLNC

Random Linear Network Coding (RLNC) is different from traditional network codes. It is stateless, algebraic, and entirely decentralized. Instead of trying to micromanage traffic, every node mixes coded messages independently; yet achieves optimal results, as if a central controller were orchestrating the network. It has been proven mathematically that no centralized scheduler would outperform this method. That’s not common in system design, and it is what makes this approach so powerful.

Instead of relaying raw messages, RLNC-enabled nodes divide and transmit message data into coded elements using algebraic equations over finite fields. RLNC allows nodes to recover the original message using only a subset of these coded pieces; there’s no need for every message to arrive.

It also avoids duplication by letting each node mix what it receives into new, unique linear combinations on the fly. This makes every exchange more informative and resilient to network delays or losses.

With Ethereum validators now testing RLNC through OptimumP2P — including Kiln, P2P.org, and Everstake — this shift is no longer hypothetical. It’s already in motion.

Up next, RLNC-powered architectures and pub-sub protocols will plug into other existing blockchains helping them scale with higher throughput and lower latency.

A Call for a New Industry Benchmark

If Ethereum is to serve as the foundation of global finance in its second decade, it must move beyond outdated assumptions. Its future won’t be defined by tradeoffs, but by provable performance. The trilemma isn’t a law of nature, it’s a limitation of old design, one that we now have the power to overcome.

To meet the demands of real-world adoption, we need systems designed with scalability as a first-class principle, backed by provable performance guarantees, not tradeoffs. RLNC offers a path forward. With mathematically grounded throughput guarantees in decentralized environments, it’s a promising foundation for a more performant, responsive Ethereum.

Read more: Paul Brody — Ethereum Has Already Won