Question 1

How Web3 infrastructure works

Accepted Answer

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. The Simple Explanation 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. How Is Web3 Infrastructure Different From Web2? 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. AspectWeb2Web3Source of truthCentralized databaseBlockchainWho writes dataApp backend with its own credentialsUser via wallet signatureIdentityUsername and passwordWallet addressData accessDirect database queriesRPC endpoints and indexersFile storageCloud serversIPFS 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. LayerRoleExampleWalletUser identity and transaction signingMetaMask, PhantomRPC endpointsRead and write access to chainsQuicknode Core APIIndexersMake on-chain data queryableThe Graph, StreamsDecentralized storageStore large files off-chainIPFS, ArweaveSmart contractsOn-chain application logicSolidity contractsLayer 2 networksScale throughput and cut feesArbitrum, 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. Frequently Asked Questions 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. Further Reading What is blochain indexing? - Quicknode Glossary What is a crypto wallet? - Quicknode Glossary What is an RPC endpoint? - Quicknode Glossary The Web3 Infrastructure Stack - Quicknode Glossary What is fastest RPC Infrastructure? - Quicknode Core-api Getting Started with Streams - Quicknode Docs Introduction to Quicknode Products

Question 2

Build vs buy blockchain infrastructure

Accepted Answer

Whether to build or buy blockchain infrastructure is one of the biggest early decisions a Web3 team makes. Self-hosting means running your own nodes, servers, client updates, and uptime. You get full control, but it takes real DevOps skill, weeks of setup, and ongoing effort. A managed provider lets you launch in minutes with elastic scaling, multi-chain support, and little to operate. The right choice depends on your team's skills, regulatory needs, performance needs, and stage. Many mature teams use a hybrid: a managed provider handles production traffic, and self-hosted nodes act as a fallback.

Question 3

The Web3 infrastructure stack

Accepted Answer

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.

方面	Web2	Web3
真相之源	集中式数据库	区块链
谁负责写入数据	具有独立凭据的应用程序后端	通过钱包签名进行用户认证
身份	用户名和密码	钱包地址
数据访问	直接数据库查询	RPC 端点和索引器
文件存储	云服务器	IPFS 以及类似的网络

图层	角色	示例
钱包	用户身份验证与交易签名	MetaMask、Phantom
RPC 端点	对链的读写权限	Quicknode 核心 API
索引器	实现链上数据的可查询性	The Graph，Streams
去中心化存储	将大文件存储在链下	IPFS, Arweave
智能合约	链上应用逻辑	Solidity 合约
第2层网络	扩大吞吐量并降低费用	Arbitrum,Base

想随时了解最新动态吗？

开发者工具

文档与指南

Web3 基础设施的工作原理

简明解释

dapp 的架构

Web3 基础设施的核心组成部分有哪些？

读取数据与写入数据

多链现实

开发去中心化应用（dapp）是否需要运行自己的节点？

Quicknode 如何为 Web3 基础设施提供动力

常见问题解答

RPCendpoint 与索引器之间有什么区别？

一个去中心化应用（dapp）可以在没有后端的情况下运行吗？

用户如何在 Web3 应用中进行身份验证？

为什么大多数团队都会使用基础设施提供商？

Web3 基础设施是否完全去中心化？

延伸阅读

立即开始构建