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

Choosing between building and buying blockchain infrastructure is one of the most consequential early decisions for any Web3 team. Self-hosting means running your own blockchain nodes, managing servers, handling client updates, and maintaining uptime, delivering full control and sovereignty but demanding significant DevOps expertise, weeks of initial setup, and ongoing operational investment. Using a managed provider lets teams launch in minutes with elastic scaling, built-in multi-chain support, and minimal operational overhead. The right choice depends on your team's capabilities, regulatory requirements, performance needs, and stage of development. Many mature organizations adopt a hybrid approach where a managed provider handles primary production traffic while self-hosted nodes serve as fallback infrastructure for resilience.

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.

Aspect	Web2	Web3
Bron van de waarheid	Gecentraliseerde database	Blockchain
Wie voert de gegevens in?	App-backend met eigen inloggegevens	Gebruiker via portemonneehandtekening
Identiteit	Gebruikersnaam en wachtwoord	Portemonnee-adres
Toegang tot gegevens	Directe databasequery's	RPC-eindpunten en indexers
Bestandsopslag	Cloudservers	IPFS soortgelijke netwerken

Laag	Functie	Voorbeeld
Portemonnee	Gebruikersidentiteit en ondertekening van transacties	MetaMask, Phantom
RPC-eindpunten	Lees- en schrijftoegang tot ketens	Quicknode API
Indexeerders	Zorg ervoor dat on-chain-gegevens doorzoekbaar zijn	The Graph, Streams
Gedecentraliseerde opslag	Sla grote bestanden off-chain op	IPFS, Arweave
Slimme contracten	Toepassingslogica op de blockchain	Solidity-contracten
Layer 2-netwerken	De doorvoer opschalen en de kosten verlagen	Arbitrum, Base

Wil je op de hoogte blijven?

Ontwikkelaarstools

Documenten en handleidingen

Hoe de Web3-infrastructuur werkt

De eenvoudige uitleg

De architectuur van een dapp

Wat zijn de belangrijkste onderdelen van de Web3-infrastructuur?

Gegevens lezen versus gegevens schrijven

Multi-Chain-realiteit

Moet je je eigen node draaien om een dapp te bouwen?

Hoe Quicknode de Web3-infrastructuur Quicknode

Veelgestelde vragen

Wat is het verschil tussen een endpoint een indexer?

Kan een dapp zonder backend werken?

Hoe verifieert een gebruiker zich in een Web3-app?

Waarom maken de meeste teams gebruik van een infrastructuurprovider?

Is de Web3-infrastructuur volledig gedecentraliseerd?

Aanvullende literatuur

Begin nu met bouwen