How Consensus, Rollups, and Smart Contracts Combine to Run Web3
Most explanations of Web3 start in the wrong place. They open with a token, a protocol name, or a headline-grabbing exploit, and try to build understanding outward from there. The result is a patchwork of facts that never quite connects. You roughly know what a rollup is, you’ve heard the word oracle used somewhere, but you couldn’t explain how the two relate, or why either one needed to exist in the first place.
A more useful way to think about Web3 is as a stack: a set of layers, each solving a specific problem, each depending on the layer beneath it. This isn’t a new idea. The internet works the same way. A web page you load today depends on HTTP, which depends on TCP/IP, which depends on physical networking hardware, and you never think about any of it because each layer quietly does its job and hands off to the next. Web3 has developed something similar, though it’s still visibly under construction in places. Understanding it layer by layer is the difference between memorizing vocabulary and knowing how the thing works.
This piece walks through five layers in order: the base protocol, the scaling layer built on top of it, the data layer that keeps everything honest, the execution layer where logic runs, and finally the middleware and applications that users touch directly.
The Base Layer: Consensus and Settlement
At the bottom of the stack sits the base-layer blockchain: Bitcoin, Ethereum, Solana, and others like them. Its job sounds simple and is anything but. It has to get a large number of independent participants, none of whom trust each other, to agree on a single ordered history of transactions.
This is what consensus mechanisms do. Proof of Work has participants compete to solve a computational puzzle, and whoever solves it first gets to propose the next block; the cost of solving that puzzle is what makes cheating expensive. Proof of Stake replaces that computational cost with financial cost instead. Participants lock up capital, and dishonest behavior gets that capital taken away. Both are answers to the same underlying question: how do you make honesty the cheapest available strategy in a system with no central referee to enforce it?
What matters more than raw speed at this layer is finality, the point at which a transaction is settled and can no longer be reversed. A base chain that processes transactions quickly but takes a long time to finalize them hasn’t really solved the problem it exists to solve. This is also where the familiar trade-off triangle shows up: decentralization, security, and scalability. Push hard on any two, and the third tends to give way. No base-layer chain has escaped this tension entirely. Each has simply made a different bet about which corner matters most.
The Scaling Layer: Rollups, Sidechains, and Modular Chains
Base layers, precisely because they prioritize security and decentralization, tend to be slow and expensive once usage grows. This is where the scaling layer comes in, not as a replacement for the base layer but as a way of extending its capacity without touching its core guarantees.
Rollups are the dominant approach here. They execute transactions off the base chain, then post a compressed summary back to it for verification. Optimistic rollups assume transactions are valid by default and leave a window of time during which anyone can challenge a bad one. Zero-knowledge rollups take a different route: for each batch of transactions, they generate a cryptographic proof of correctness first, then post the batch and its proof together to the base chain, so validity is confirmed before the base chain ever accepts it. The practical difference shows up in withdrawal times and cost. Optimistic rollups are cheaper to run but require waiting out a challenge period before funds can move freely; ZK rollups settle faster, but generating the proof itself is computationally heavier.
Sidechains take a different path entirely. They run their own independent consensus rather than inheriting security from the base chain. That independence is genuinely useful, since it lets a sidechain make its own trade-offs on speed and cost without being bound by the base chain’s rules. But it also means a sidechain’s security is only as strong as its own validator set, not the base chain’s — a meaningfully different risk profile than it might first appear.
A newer framing ties these ideas together: modular blockchain design. Instead of one chain handling execution, consensus, and data availability all at once, which is the traditional monolithic approach, modular architectures split these responsibilities across specialized layers that each do one job well. It’s essentially the same instinct that produced the internet’s layered design, applied to blockchains decades later.
The Data Layer: Where Information Lives
Every rollup and sidechain still needs somewhere to publish its data so that outside observers can verify nothing shady happened. This is the job of the data layer, and it’s easy to overlook precisely because it’s so invisible.
On-chain storage is expensive by design. Every byte stored on a base layer has to be replicated across every participating node, which is exactly what makes the chain secure, and exactly why storing much of anything there is costly. Data availability layers exist to solve this problem: they let rollups publish just enough information for anyone to reconstruct and verify the full transaction history, without requiring the base chain itself to store all of it.
Oracles solve an adjacent but different problem. A blockchain, by design, only knows what happens inside itself. It has no native way of knowing today’s ETH price, whether a flight was delayed, or what a sports score was. Oracles bring real-world data onto the chain in a form smart contracts can trust and act on, and this turns out to be one of the more fragile points in the entire stack. A manipulated price feed can trigger real financial damage even when every other layer functioned exactly as intended.
Decentralized storage networks are a related but separate idea. They’re not about verifying transaction data; they’re about storing larger files, like images or documents, across a distributed set of nodes rather than a single company’s servers. It’s a meaningfully different problem from data availability, even though the two get conflated often enough that the distinction is worth holding onto.
The Execution Layer: Smart Contracts and Virtual Machines
This is where logic runs. A virtual machine, the Ethereum Virtual Machine being the best-known example, provides a shared, deterministic environment in which code executes identically no matter which node runs it. That determinism is the whole point. If the same input could produce different outputs on different machines, consensus would be impossible from the start.
Smart contracts are the code that lives inside this environment: self-executing agreements that carry out their logic exactly as written, with no room for renegotiation once deployed. It’s worth separating the contract’s logic from its deployment. Writing a contract is one thing, but pushing it onto a live chain, where it becomes immutable and publicly executable, is a distinct and consequential step that can’t easily be undone.
Gas fees are often described loosely as transaction fees, which undersells what they’re actually pricing. Gas pays for computation and storage. Every operation a contract performs, every piece of state it modifies, has a cost, and that cost is what gas measures. A complex contract interaction costs more gas not because it’s a bigger transaction in some abstract sense, but because it does more computational work under the hood.
Get Moledao’s stories in your inbox
Join Medium for free to get updates from this writer.
Cross-chain execution remains one of the stack’s unsolved problems. Two chains with different virtual machines, different consensus rules, and different security assumptions don’t naturally understand each other, which is why interoperability is a much harder problem than the word suggests. It’s also why so much of the industry’s security failures have clustered around the systems built specifically to bridge that gap.
The Middleware Layer: Infrastructure Users Never See
Between the execution layer and the applications people actually use sits a layer of infrastructure that almost no one thinks about until it breaks. RPC nodes and indexers are the plumbing here. They let an application query the blockchain’s current state without every user having to run their own full node, and they organize raw blockchain data into something applications can query efficiently.
Wallets belong in this layer too. A wallet is identity and signing infrastructure: it holds the keys that prove ownership and authorize transactions, while the assets themselves live on the blockchain rather than inside the wallet. Losing a wallet’s private key doesn’t mean losing a container full of coins; it means losing the ability to prove that you’re you.
Bridges and messaging protocols round out this layer, moving assets and data between chains. This layer, more than any other, is where usability breaks down for newcomers and where security exploits have concentrated. Bridges in particular have been the site of some of the industry’s largest losses, precisely because they sit at the seams between systems that were never designed to trust each other.
The Application Layer: Where Users Interact
Everything below builds toward this layer, which is what most people mean when they say Web3 in casual conversation. DeFi protocols are composable financial primitives: lending, trading, and yield mechanisms built directly on top of smart contracts, often stacking on top of one another like financial building blocks. A lending protocol can accept a token as collateral, and a separate trading protocol can then use that same deposit as a building block for its own product, with neither needing permission from the other.
NFTs and token standards are better understood as ownership and access-control primitives than as collectibles. A non-fungible token represents unique, verifiable ownership of something, whether digital or otherwise, and that ownership record is what a marketplace, a game, or a membership system checks before granting access to whatever the token represents.
DAOs layer governance and coordination on top of this same infrastructure. Token holders typically submit and vote on proposals, and once a vote passes, the outcome can be executed automatically by a smart contract rather than left to a manager’s discretion. That shifts organizational decision-making from hierarchy to code-enforced rules, for better and for worse, since a poorly written governance contract can lock in a bad decision just as permanently as a good one.
None of this innovation exists independently. A DeFi protocol is only as trustworthy as the execution layer it runs on, which is only as trustworthy as the data layer verifying it, which is only as sound as the base layer settling it underneath everything else. Application-layer creativity is real and often genuinely inventive, but it inherits every weakness present in the layers beneath it, whether or not anyone using the application realizes that.
Tracing a Transaction Through the Stack
Consider something as ordinary as swapping one token for another. A wallet signs the transaction first — that signature is what the middleware layer exists to produce. The signed transaction is then submitted through an RPC node and executed by a smart contract running on a virtual machine, the execution layer’s core job. If this is happening on a rollup, the transaction batch eventually gets posted back to the base chain along with data proving it can be verified, drawing on the scaling and data layers together. Finally, the base chain settles the outcome, making it final. One swap, five layers, dozens of components working in sequence, and the entire thing happens in a few seconds.
This is also why isolated failures tend to spread further than they logically should. A bridge exploit doesn’t just cost the bridge money; it damages trust in every application that relied on the assets that bridge moved, even though those applications had nothing to do with the failure itself. The layered structure that makes Web3 efficient is the same structure that makes it interconnected in ways that aren’t always obvious until something breaks somewhere else in the chain.
Looked at this way, it becomes easier to see where the industry’s infrastructure has genuinely matured and where it hasn’t. Base-layer consensus and core execution environments are, by now, well-tested and battle-hardened. The fragility tends to concentrate at the seams instead: bridges, oracles, and the middleware that ordinary users depend on every day without realizing it’s there.
A Grounded Way to Read Web3 Going Forward
Treating Web3 as a single technology invites assumptions that don’t hold up well under scrutiny: the sense that a breakthrough at any one layer solves everything, or that a failure at any one layer discredits everything else. Treating it as a stack invites something more useful instead — the ability to ask which layer a given claim, failure, or innovation actually belongs to, and to judge it on those terms rather than on the reputation of Web3 as a whole.
This architecture isn’t heading toward some final, settled form either. If the internet’s own history is any guide, the layers themselves will keep shifting. Responsibilities will keep moving between execution and data availability, and new middleware will keep emerging to smooth over friction that current users simply tolerate today without complaint. The stack will keep evolving rather than converge on one dominant design. Understanding it as layers, rather than as a single monolithic idea, is what makes that ongoing evolution legible instead of confusing.
Join Moledao and Kickstart Your Web3 Career!
Moledao is a community dedicated to Web3 talent growth, connecting learning, building, and real opportunities. Whether you are transitioning from Web2 to Web3 or looking to scale your depth in the blockchain ecosystem, we provide structured learning paths, mentorship, and job matching.
- Website: https://moledao.io/
- Telegram: https://t.me/Moledao
- X (Twitter): https://x.com/moledao_io
#Moledao #Web3 #TechStack #DeFi #Rollups #SmartContracts
