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.
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.
