Answers>Learn about Web3 infrastructure architecture>The Web3 infrastructure stack
The Web3 infrastructure stack
// Tags
Web3 stackblockchain stack
TL;DR: The Web3 infrastructure stack is a layered architecture of protocols, services, and tools that power decentralized applications from the consensus layer to the user interface. At the base, Layer 1 blockchains provide consensus and smart contract execution. Above that, node access providers deliver RPC endpoints that connect applications to the chain. Data services (indexers, streaming pipelines) transform raw blockchain data into queryable formats. Application services handle authentication, storage, identity, and cross-chain communication. At the top, the application layer combines frontends, smart contracts, and backend logic into the user-facing product. Understanding each layer and how they interact is essential for making informed architecture decisions when building on blockchain.
The Simple Explanation
Building a Web3 application is like building a house. You need a foundation (the blockchain), plumbing and electrical (node access and data services), walls and structure (application services), and the rooms people actually live in (the frontend and user experience). Most people only see the finished house, but the quality of every hidden layer determines whether the house is solid or falls apart.
The Web3 stack is more complex than the traditional web stack because it replaces a centralized database (which a single company controls and maintains) with a decentralized network (which thousands of independent participants maintain according to protocol rules). This decentralization provides benefits like censorship resistance, trustlessness, and user sovereignty, but it also requires specialized infrastructure at every layer to bridge the gap between blockchain's raw capabilities and the polished application experience users expect.
Layer 1: The Blockchain
At the foundation of the stack is the Layer 1 blockchain: Ethereum, Solana, Bitcoin, or any of the dozens of other networks that provide consensus, transaction processing, and smart contract execution. The L1 is the source of truth. It determines which transactions are valid, what the current state is, and how disputes are resolved.
Each L1 has its own consensus mechanism (Proof of Stake, Proof of Work, Delegated PoS, BFT variants), its own virtual machine or execution environment (EVM, SVM, MoveVM), its own transaction format, and its own performance characteristics. Ethereum offers the largest ecosystem and strongest security guarantees but relatively low throughput (15-30 TPS). Solana offers high throughput (thousands of TPS) and sub-second finality but a smaller validator set. Bitcoin offers the strongest security and decentralization but minimal programmability.
Layer 2 networks (Arbitrum, Base, Optimism, zkSync, StarkNet) extend L1 capabilities by processing transactions off-chain and settling proofs or compressed data back to the L1. They inherit the L1's security while providing dramatically higher throughput and lower fees. From a stack perspective, L2s are accessed through the same infrastructure patterns as L1s (RPC endpoints, indexers, data streams) but with their own chain-specific configurations.
Layer 2 of the Stack: Node Access
Above the blockchain itself sits the node access layer. Applications do not interact with the blockchain directly. They communicate through blockchain nodes via RPC (Remote Procedure Call) endpoints. Running and maintaining your own nodes across multiple chains is operationally complex, expensive, and a full-time job. This is why node access providers exist.
A node access provider operates a globally distributed network of blockchain nodes and exposes them through API endpoints. When your application sends an RPC request (like checking a balance or submitting a transaction), the provider routes it to a healthy, synced node, processes the request, and returns the result. The provider handles all the operational complexity: hardware provisioning, client software updates, hard fork management, sync monitoring, failover, and scaling.
The quality of your node access layer directly determines your application's performance and reliability. Slow endpoints mean a sluggish user experience. Unreliable endpoints mean downtime. Stale endpoints mean incorrect data. For production applications, this layer is the most critical infrastructure dependency.
Layer 3 of the Stack: Data Services
Raw blockchain data, as served through RPC endpoints, is difficult to work with at scale. RPC methods support point lookups (get this block, get this transaction, get this balance) but not complex queries (show me all transfers from this address in the last 30 days, calculate total DEX volume this week). Data services transform raw blockchain data into formats that applications can query efficiently.
Indexers process every block, decode transactions and events, and store structured records in a queryable database. The Graph is the leading decentralized indexing protocol, where developers define "subgraphs" that specify which contracts and events to index and how to map them to a queryable schema. Custom indexers built with streaming pipelines provide more flexibility for teams with specific data requirements.
Streaming services deliver real-time blockchain data to application backends, databases, and warehouses as blocks are produced. Instead of applications polling for new data (which is slow, wasteful, and unreliable), streaming services push data as it becomes available. This is the foundation for real-time dashboards, event-driven architectures, and continuous data pipelines.
Analytics platforms provide pre-processed, queryable datasets for research, business intelligence, and protocol analytics. Platforms like Dune Analytics expose historical blockchain data through SQL interfaces, enabling ad-hoc analysis without building custom data infrastructure.
Layer 4 of the Stack: Application Services
Application services provide the middleware and utilities that bridge the gap between raw blockchain access and user-facing features.
Wallet authentication (Sign-In with Ethereum, Solana wallet adapter) lets users prove their identity by signing a message with their wallet, replacing traditional username/password authentication. This provides a seamless, passwordless login experience that is cryptographically secured by the same key that controls the user's onchain assets.
Decentralized storage (IPFS, Arweave, Filecoin) provides a place to store data that is too large or too expensive for the blockchain itself. NFT images, metadata files, application assets, and large datasets are stored on decentralized storage networks and referenced onchain through content hashes or URIs. IPFS uses content-addressed storage where files are retrieved by their cryptographic hash. Arweave provides permanent storage through a one-time payment model.
Identity and naming services (ENS, Solana Name Service) map human-readable names to blockchain addresses. Instead of sharing a 42-character hex address, a user can share "alice.eth." Identity protocols also aggregate reputation, credentials, and social connections onchain.
Cross-chain communication (bridges, messaging protocols) enables applications to operate across multiple chains. Bridge protocols transfer assets between chains, while messaging protocols (like LayerZero, Wormhole, and Hyperlane) enable smart contracts on different chains to communicate with each other.
Layer 5 of the Stack: The Application
At the top of the stack is the application itself: the frontend, smart contracts, and optional backend that compose the user-facing product.
Frontends are typically built with React or Next.js and connect to the blockchain through wallet libraries (ethers.js, viem, wagmi for EVM; @solana/web3.js for Solana). The frontend handles UI rendering, wallet connection, transaction construction, and state management. It communicates with the blockchain through RPC endpoints and with indexed data through GraphQL or REST APIs.
Smart contracts are the onchain business logic. They are deployed to the blockchain, immutable by default, and execute deterministically whenever called. Smart contract development uses languages like Solidity (EVM), Rust (Solana), and Move (Aptos, Sui), with frameworks like Hardhat, Foundry, and Anchor for testing and deployment.
Backends handle off-chain logic: API aggregation, caching, event processing, transaction queuing, notification delivery, and integration with traditional services. While some simple dapps can operate without a traditional backend (with the frontend connecting directly to RPC and indexed data), most production applications benefit from a backend that provides performance optimization, business logic, and operational control.
What are the layers of the Web3 infrastructure stack?
The Web3 stack is best understood as five layers, each depending on the one below it. The base provides consensus and execution, the middle layers turn raw chain access into usable data and services, and the top is the product users actually touch. A reliable blockchain node connection sits at the heart of it, because every layer above ultimately reads and writes through the node access layer. The table below maps each layer to its role and typical examples.
Layer
Role
Examples
Layer 1 and Layer 2
Consensus and execution
Ethereum, Solana, Bitcoin, Arbitrum, Base
Node access
RPC connectivity to chains
RPC endpoints, node providers
Data services
Query and stream onchain data
Indexers, streaming pipelines, analytics
Application services
Middleware: auth, storage, identity
Wallet sign-in, IPFS, ENS, bridges
Application
User-facing product
Frontend, smart contracts, backend
How is the Web3 stack different from the traditional web stack?
The biggest difference is the base layer. A traditional app reads and writes to a database that one company owns, while a Web3 app reads and writes to a decentralized network governed by protocol rules. That swap adds layers with no direct Web2 equivalent: a node access layer to reach the chain, and data services to make onchain data queryable. For a fuller picture of how these pieces connect, see how Web3 infrastructure works.
Should you build or buy Web3 infrastructure?
You can run your own nodes and indexers, or you can rely on managed providers for each layer. Self-hosting gives you maximum control, but it turns infrastructure into a full-time operational job: provisioning hardware, tracking client upgrades, handling hard forks, monitoring sync, and staffing on-call rotations. The expense and risk multiply with every additional chain you support. For most teams, the realistic cost of running a node across several networks outweighs the control it provides, which is the heart of the classic build vs buy decision. The right answer depends on your team size, budget, and how core infrastructure is to your product.
How do you choose a Web3 infrastructure provider?
Because the node access layer is the dependency every other layer rests on, evaluate providers on the qualities that keep an application online. Node reliability determines whether your reads return correct, current data, and high availability determines whether the endpoint is reachable when traffic spikes or a region goes down. Breadth of chain support matters if you plan to expand, and the presence of higher layers like indexing and streaming lets you consolidate onto one provider instead of stitching several together. Pricing models and rate limits round out the comparison, since they shape both cost and the ceiling on your throughput.
Frequently Asked Questions
How many layers are in the Web3 stack?
Most models describe five: the blockchain (Layer 1 and Layer 2), node access, data services, application services, and the application itself. The exact count varies by author, but the key idea is that each layer depends on the one beneath it, so weakness at any layer affects everything above.
What is the most important layer of the stack?
For production applications, the node access layer is usually the most critical dependency, because every read and write flows through it. Slow or unreliable endpoints surface as a sluggish or broken product, which is why capabilities like automatic failover matter so much at this layer.
Do I need an indexer to build a dapp?
Simple apps can read directly from RPC endpoints, but anything that needs complex queries (transfers by address, aggregated volume, historical search) benefits from blockchain indexing, which stores decoded data in a queryable database so each query is fast.
Can one provider cover the whole stack?
Increasingly, yes. Some providers span node access, data services, and parts of the application services layer, which lets you build on a single platform rather than integrating separate vendors for RPC, indexing, streaming, and storage.
Where do Layer 2s fit in the stack?
Layer 2 networks live in the base layer alongside Layer 1s. From the stack's perspective they are accessed the same way, through RPC endpoints, indexers, and streams, just with their own chain-specific configuration.
How Quicknode Fits Across the Stack
Quicknode provides infrastructure across multiple layers of the Web3 stack. At the node access layer, the Core API delivers production-grade RPC endpoints across 80+ chains with 99.99% uptime and globally distributed, low-latency nodes. At the data services layer, Quicknode Streams provides push-based data delivery with guaranteed ordering, reorg handling, and support for both real-time streaming and historical backfills. At the application services layer, Quicknode offers IPFS gateways and pinning for decentralized storage, Marketplace add-ons for enhanced APIs, and the Quicknode SDK for streamlined integration.
This full-stack coverage means developers can build on a single infrastructure platform rather than stitching together separate providers for each layer. Whether your application is a single-chain DeFi protocol or a multi-chain platform spanning dozens of networks, Quicknode provides the infrastructure foundation that everything else builds on.
