Answers>Learn about Web3 infrastructure architecture>How Web3 infrastructure works
How Web3 infrastructure works
// Tags
Web3 infrastructuredApp architecture
TL;DR: Web3 infrastructure is the set of tools, services, and protocols that enable applications to read from and write to blockchain networks. Unlike traditional web applications that rely on centralized databases controlled by a single company, Web3 applications (dapps) use blockchain as their source of truth and require a specialized infrastructure stack to interact with it. This stack includes wallet connections for user authentication and transaction signing, RPC endpoints for communicating with blockchain nodes, indexers for making onchain data queryable, decentralized storage for large files, and Layer 2 networks for scaling. Understanding how these pieces fit together is essential for any developer building on blockchain.
간단한 설명
A traditional web application has a straightforward architecture: a user opens a browser, the browser loads a frontend from a web server, the frontend talks to a backend API, and the backend reads from and writes to a database. The company operating the application controls every layer: the servers, the database, the API, and the rules for who can access what.
A Web3 application replaces the centralized database with a blockchain. But blockchains are not databases. You cannot run SQL queries against them. You cannot connect to them with a standard database driver. You cannot write data to them by calling an API with a secret key. Interacting with a blockchain requires a fundamentally different infrastructure stack, and understanding that stack is the first step to building production-quality dapps.
The core difference is the transaction model. In a traditional app, the backend writes to the database using its own credentials. In a Web3 app, the user writes to the blockchain by signing transactions with their own private key, through their own wallet. The application facilitates this process but never has direct write access to the user's onchain state. This shift from server-controlled data to user-controlled data is what makes Web3 "decentralized," and it is also what makes the infrastructure more complex.
The clearest way to understand Web3 infrastructure is to compare it to the Web2 stack most developers already know. The data lives in a different place, and the path to read and write it changes accordingly.
양상
Web2
웹3
Source of truth
Centralized database
블록체인
Who writes data
App backend with its own credentials
User via wallet signature
Identity
Username and password
Wallet address
Data access
Direct database queries
RPC endpoints and indexers
File storage
Cloud servers
IPFS and similar networks
Because you cannot query a chain like a database, most reads go through an RPC endpoint for simple lookups and through blockchain indexing for complex, structured queries.
The Architecture of a dapp
A typical production dapp consists of several layers, each serving a distinct function. The frontend is the user interface, usually a web application built with React, Next.js, or similar frameworks. The frontend handles rendering, user input, and wallet interaction. It connects to the user's wallet (MetaMask, Phantom, etc.) through a provider API (like ethers.js or wagmi) that enables the dapp to request wallet addresses, display balances, and prompt transaction signatures.
The wallet is the user's identity and authentication mechanism. Instead of logging in with a username and password, Web3 users connect their wallet. The wallet provides the user's public address (their identity) and the ability to sign transactions (their authorization). When the dapp needs to write data onchain (send tokens, interact with a smart contract, mint an NFT), it constructs a transaction, sends it to the wallet for signature, and the wallet broadcasts the signed transaction to the network.
RPC endpoints are the gateway between the dapp and the blockchain. Every read operation (checking a balance, querying a smart contract's state, fetching a transaction receipt) and every write operation (submitting a signed transaction) flows through an RPC endpoint. The endpoint connects to a blockchain node that processes the request and returns the result. The choice of RPC provider directly impacts your application's speed, reliability, and data accuracy.
The backend (optional but common in production) handles off-chain logic that does not belong on the blockchain: user session management, API aggregation, caching, analytics, webhook processing, and integration with traditional services. Many dapps also use a backend to manage server-side transaction submission for operations that do not require the user's wallet signature (like administrative operations or gasless meta-transactions).
Indexers transform raw blockchain data into queryable databases. The blockchain itself does not support complex queries. You cannot ask it "show me all NFTs owned by this address" or "what is the total volume traded on this DEX today" using standard RPC methods. Indexers (like The Graph, or custom pipelines built with Quicknode Streams) process every block, decode transactions and events, and store the results in a database that supports SQL or GraphQL queries. This indexed data powers portfolio displays, transaction histories, analytics dashboards, and search functionality.
Smart contracts are the onchain logic of the application. They define the rules for token transfers, DeFi operations, NFT minting, governance voting, and any other programmable onchain behavior. Smart contracts are deployed once and execute deterministically whenever called. They are the "backend logic" that lives on the blockchain rather than on a company's server.
What Are the Core Components of Web3 Infrastructure?
Although architectures vary, most production dapps rely on the same set of building blocks. The table below maps each layer to its role and a common example.
레이어
Role
Example
지갑
User identity and transaction signing
MetaMask, Phantom
RPC endpoints
Read and write access to chains
Quicknode Core API
Indexers
Make on-chain data queryable
The Graph, Streams
Decentralized storage
Store large files off-chain
IPFS, Arweave
Smart contracts
On-chain application logic
Solidity contracts
Layer 2 networks
Scale throughput and cut fees
Arbitrum, Base
Scaling layers such as a Layer 2 network, the smart contracts that hold your logic, and a real-time pipeline like Streams all plug into this same architecture.
Reading Data vs Writing Data
The reading and writing paths in a dapp are fundamentally different.
Reading data is relatively simple. The frontend (or backend) sends an RPC request to a node asking for specific data: a balance, a contract's state, a block's contents. The node looks up the answer and returns it. For simple reads, this round trip takes tens of milliseconds with a good provider. For complex data needs (like "show me this wallet's complete transaction history across all tokens"), the dapp queries an indexer's database rather than the blockchain directly, because the indexer has already done the heavy lifting of processing and structuring the data.
Writing data is more involved. The user initiates an action (like swapping tokens). The dapp constructs a transaction specifying the smart contract to call, the function to execute, and the parameters to pass. The dapp estimates the gas cost and presents it to the user. The user reviews and approves the transaction in their wallet, which signs it with their private key. The signed transaction is submitted to the network through an RPC endpoint. The transaction enters the mempool and waits for a validator to include it in a block. Once included, the transaction is confirmed. The dapp detects the confirmation (either by polling or via a WebSocket subscription) and updates the UI to reflect the new state.
This multi-step write process, involving the user's wallet, gas estimation, mempool propagation, validator inclusion, and confirmation detection, is why Web3 writes feel slower than clicking a button in a traditional app. It is also why reliable, low-latency RPC infrastructure is critical: every step from gas estimation to transaction submission to confirmation detection flows through the RPC endpoint.
Multi-Chain Reality
Modern dapps rarely operate on a single chain. A DeFi protocol might deploy on Ethereum mainnet, Arbitrum, Base, Optimism, and Polygon. An NFT marketplace might support Ethereum, Solana, and multiple L2s. A wallet app needs to display balances and enable transactions across dozens of chains simultaneously.
This multi-chain reality multiplies the infrastructure requirements. Each chain needs its own RPC endpoints, its own indexing pipeline, and its own understanding of chain-specific quirks (different finality models, different gas mechanisms, different transaction formats). Managing this complexity across 5, 10, or 80+ chains is a significant engineering challenge that most teams solve by using an infrastructure provider rather than running their own nodes for every chain.
Do You Need to Run Your Own Node to Build a dapp?
In most cases, no. You can ship a production dapp using a managed RPC provider without ever operating a node. Running your own node gives you maximum control and privacy, but it also means provisioning hardware, syncing chains, handling upgrades and hard forks, and monitoring uptime around the clock, for every chain you support. That is why the build versus buy decision usually favors a provider for teams that want to focus on product rather than operations. If you do want full control, our overview of running your own node weighs the costs and benefits.
How Quicknode Powers Web3 Infrastructure
Quicknode provides the infrastructure backbone that dapps depend on. The Core API delivers production-grade RPC endpoints across 80+ blockchain networks from a single platform, with globally distributed nodes, 99.99% uptime, and response times 2.5x faster than competitors. This means developers can support multiple chains without managing separate node infrastructure for each one.
Quicknode Streams replaces custom indexing infrastructure with a push-based data pipeline that delivers filtered blockchain data directly to your database or warehouse with guaranteed delivery and automatic reorg handling. Instead of building and maintaining polling scripts for each chain, you configure a Stream and Quicknode handles extraction, filtering, delivery, and data consistency.
For the broader dapp stack, Quicknode offers IPFS gateways and pinning for decentralized storage, Marketplace add-ons for enhanced APIs (token balances, NFT data, DeFi analytics), and the Quicknode SDK for streamlined integration in JavaScript and TypeScript. Together, these tools provide a complete infrastructure platform for building, scaling, and operating production Web3 applications.
자주 묻는 질문
What is the difference between an RPC endpoint and an indexer?
An RPC endpoint answers direct questions about current chain state, such as a balance or a single transaction. An indexer processes the full history into a database so you can run complex queries, like a wallet's entire transaction history, that RPC alone cannot serve efficiently.
Can a dapp work without a backend?
Yes. Many dapps are fully client-side: the frontend talks to RPC endpoints and the user's wallet directly. A backend is optional and is added for off-chain tasks like caching, analytics, and gasless transactions.
How does a user authenticate in a Web3 app?
Users connect a wallet instead of creating an account. The wallet address acts as the identity, and signing a message or transaction proves control of that address, replacing usernames and passwords.
Why do most teams use an infrastructure provider?
Supporting many chains reliably requires running and maintaining nodes, indexers, and storage for each one. A provider consolidates this into a single platform, which is faster to adopt and cheaper to operate than building it in-house.
Is Web3 infrastructure fully decentralized?
Parts of it are, and parts are not. The chains and smart contracts are decentralized, but supporting services like RPC providers and frontends often run on centralized cloud platforms. Real-time data feeds, such as blockchain data streaming, typically come from managed providers as well.
