A developer's guide to the web3 stack

Starting an onchain project in 2026 means choosing a stack, not a chain. Before you write a line of business logic, you pick a network, a smart contract framework, a wallet pattern, an infrastructure provider, and a frontend library, and each of those choices shapes the next year of engineering work.

The web3 stack is the layered set of tools a developer touches when building anything that runs on a blockchain: networks, infrastructure, smart contracts, wallets, frontend libraries, storage, applications, and a newer agentic layer where AI agents act as their own users. This guide is the working map: who the leaders are at each layer, where the real choices live, and what to pick when the answer depends on what you are building.

The eight layers of the web3 stack

Layer 1: Networks

A blockchain is the bottom of the stack, and "the blockchain" can now mean three things: layer 1s that run their own consensus, layer 2 rollups that borrow security from a layer 1, and modular components that let a team assemble its own chain.

Three layer 1s anchor most activity. Ethereum holds the most liquidity and is home to most stablecoins and DeFi. Solana is the fastest in production use, which makes it the default for payments and consumer apps. Bitcoin holds the most value and, through a growing set of layer 2s, is becoming programmable. Beyond these, chains like BNB Smart Chain, Tron, Avalanche, and Polygon carry real production traffic, and newer L1s such as Hyperliquid, Monad, and Sui are worth watching.

Layer 2 rollups run transactions on their own chain and post back to a layer 1 for security, which keeps fees low while inheriting the base chain's guarantees. The largest (Arbitrum, Base, OP Mainnet) use optimistic proofs; a second group (zkSync, Starknet, Linea) use zero-knowledge proofs for faster final settlement. Almost all live on Ethereum today; Bitcoin and Solana rollups exist but are much earlier. Our Ethereum scaling solutions overview goes deeper.

Modular components let you assemble a chain instead of joining one. The OP Stack and Arbitrum Orbit turn launching an Ethereum L2 into a configuration choice, and data-availability layers like Celestia and EigenDA let a new chain store its data without paying Ethereum prices for it. Rollups-as-a-service providers (Alchemy, Conduit, Caldera) package the whole thing as a managed service.

In reality, you rarely pick just one in 2026. Most production apps run multichain: an Ethereum L2 for high-value flows, Solana for payments, a Bitcoin L2 for native BTC. That used to mean a separate integration for each chain. It does not anymore, because modern infrastructure providers expose the same API across 100+ chains, so adding a chain is closer to a config change than a rebuild.

Layer 2: Infrastructure

Every blockchain runs on a network of nodes: computers that store the chain's data and run its consensus rules. To read state or send a transaction, your app has to talk to a node, and you can run your own or rent one.

Think of it like a database. You could host Postgres yourself, but most teams rent a managed instance so they can ship features instead of babysitting hardware. Nodes work the same way, with a steeper bill: a self-hosted Ethereum archive node runs $10,000 to $25,000 a year in storage and bandwidth before any engineering time. So most teams rent.

Node and RPC providers are what you rent. They expose the JSON-RPC and WebSocket endpoints your app calls, run nodes across regions with redundancy, and absorb the operational work. Alchemy, QuickNode, Chainstack, Helius (Solana-focused), and dRPC are the major options in 2026.

Raw node access is rarely enough on its own. Answering "all of a wallet's NFTs" or "this token's price history" by querying a node directly is slow and expensive, so most teams also use data and indexing APIs. The Graph pioneered indexing with subgraphs; Alchemy, Dune, and Goldsky offer higher-level data APIs for balances, transfers, prices, and histories.

A few specialized categories round out the layer. Bridges (LayerZero, Wormhole, Chainlink CCIP) move assets and messages between chains. Oracles (Chainlink, Pyth) bring offchain data like prices onchain. Block explorers (Etherscan, Solscan) are the public window into any chain's activity. Our overview of the best blockchain APIs goes deeper on what to look for.

Layer 3: Smart contracts

Smart contracts are programs that run on a blockchain. They are written in a language the chain's virtual machine can execute, compiled, deployed, and called by transactions. The two decisions at this layer are which language to write in and which framework to write it in.

Language choice is mostly determined by which chain you build on:

• Solidity is the dominant Ethereum language and the default for any EVM chain (Arbitrum, Base, Optimism, BNB, Avalanche, Polygon).
• Rust runs Solana programs and appears in NEAR, parts of Aptos, and most modular-stack components. Solana's tradeoffs vs Solidity are covered in our Solidity vs Rust overview.
• Move is the language of Sui and Aptos, designed for safer asset programming with a resource-oriented type system that makes "you cannot accidentally duplicate or lose a token" a property of the type checker.
• Vyper is a Python-like alternative to Solidity used by some EVM DeFi protocols (Curve is the largest).
• Cairo is the language of Starknet, designed for STARK provability.

Once you have picked a language, the framework is what you live in day to day. It compiles your code, runs your tests, deploys to testnets and mainnet, and gives you a local network to simulate against. Three are worth knowing, and there are plenty more.

Foundry is the most popular Ethereum framework. Written in Rust, it compiles and tests Solidity fast, and its built-in fuzzing made thorough testing the norm. Most new EVM projects start with Foundry.

Hardhat is the long-standing alternative, and the natural pick for teams that work in TypeScript end to end. It compiles, tests, and deploys your contracts, runs a local Ethereum network to develop against, and supports both Solidity and TypeScript tests through a large plugin ecosystem.

Anchor is the standard for Solana programs. It generates client SDKs from program IDLs, handles serialization, and is the Solana equivalent of using Foundry plus a frontend client generator together.

For the broader set of frameworks, test libraries, deployment tools, and adjacent dev tooling, our 20 blockchain development tools overview is the working reference.

Layer 4: Wallets and accounts

A wallet plays two roles in a web3 app. It is the user's identity, the account address that represents them onchain, and it is their literal wallet, the place their assets live and the thing that signs transactions to move them. Three patterns cover most builds: externally owned accounts, smart contract wallets, and embedded wallets. Which one you reach for depends on who the user is, from a crypto-native human to a consumer who has never installed a wallet to an AI agent acting on its own.

Externally owned accounts (EOAs) are the original Ethereum wallet pattern: a public/private keypair stored in a browser extension, mobile app, or hardware device. MetaMask, Rabby, Phantom (Solana), and Backpack are the major user-facing examples and how most existing crypto-native users hold their assets.

Smart contract wallets are accounts that are themselves programs. They can require multiple signatures, batch transactions, sponsor gas, set spending limits, rotate keys, and authenticate with passkeys instead of seed phrases. Safe (formerly Gnosis Safe) is the largest by assets held. Coinbase Smart Wallet, Argent, and Ambire are user-facing implementations. The standard underneath them is ERC-4337, which went live on Ethereum mainnet in March 2023 and is now deployed across most major L2s. EIP-7702 extends the pattern by letting a regular EOA temporarily behave like a smart contract, so existing users can get smart-account features without migrating accounts. These same features (spending limits, session keys, scoped permissions) are also what make smart accounts the default for AI agents, which need to transact on their own without holding unlimited authority. Layer 8 picks up that thread.

Embedded wallets are wallets created and managed inside an application instead of a browser extension. The user signs in with email or social and the SDK provisions a wallet they can later export. Privy, Dynamic, Reown, and Coinbase Wallet as a Service are common providers in 2026. Most embedded wallet SDKs use MPC (multi-party computation) under the hood, splitting the key across providers so no single party can sign alone. This is how most consumer crypto products onboard new users today, because most users do not have MetaMask or Phantom installed before they show up.

A wallet address is an identity, but a clumsy one: it is a long hex string that says nothing about who or what is behind it. Two adjacent primitives fill that gap. Naming services like ENS map a readable name (alice.eth) to an address, and SNS does the same on Solana. Proof-of-personhood protocols like World use biometric verification to tie one onchain identity to one real human, which matters more as a growing share of accounts belong to agents rather than people.

Our web3 wallets overview breaks down each category in more detail. The short version: assume existing wallets for technical products, use embedded wallets for consumer products, and use smart accounts when something other than a human is signing.

Layer 5: Frontend libraries and connectors

Frontend libraries handle the chain-interaction work an application needs: reading state from a contract, building and signing transactions, listening for events, formatting addresses and balances. They sit between your application code and the JSON-RPC the chain speaks. Two libraries dominate the EVM, and one dominates Solana.

For Ethereum and EVM chains, Viem and Wagmi are the default pairing for new projects. Viem is a TypeScript library for direct chain interaction (reading state, writing transactions, decoding events) with a smaller bundle, better tree-shaking, and a more typed API than the older libraries. Wagmi is a layer of React hooks built on Viem that handles wallet connection state, transaction lifecycle, and chain switching. Most new EVM apps in 2026 use both together.

ethers.js is the older alternative and is still actively maintained. Many existing dapps run on it, and there is nothing wrong with that, though new projects generally pick Viem and Wagmi for the typing and bundle-size advantages.

On the Solana side, @solana/kit (the modern rewrite of the original @solana/web3.js library) is the standard. Anchor's TypeScript client generators handle the program interface from the frontend.

Once your library can talk to the chain, you still need a way for the user to connect their wallet. Connector libraries handle the "Connect Wallet" button, the modal that lists supported wallets, the network-mismatch prompts, and the session persistence. Without one, you write that hundred lines of UI scaffolding in every app.

• RainbowKit (React, Wagmi-based) is the popular default for Ethereum-only dapps. ConnectKit is the leaner alternative when you want more UI control.
• Reown AppKit, the rebuilt successor to WalletConnect (which rebranded to Reown in 2024), supports hundreds of wallets across EVM, Solana, and Bitcoin.
• Privy and Dynamic (covered in Layer 4) include their own connector logic, so consumer apps that use an embedded wallet can collapse the wallet step and the connect step into one sign-in.

Layer 6: Storage

Most application data does not live onchain, and most of it does not need to. Putting images, video, or large JSON on Ethereum is far too expensive, so the rule of thumb is simple: decentralize the data that has to be, and keep the rest wherever is cheapest. Plenty of production apps serve assets from ordinary cloud storage and reserve decentralized storage for the data that needs to be permanent or censorship-resistant, like the metadata an NFT points to.

When you do need decentralized storage, a few protocols cover most cases:

• IPFS (the InterPlanetary File System) is content-addressed storage, the common home for NFT metadata and app files. Pinata and Filebase keep that data online.
• Arweave offers "permaweb" storage: pay once, store forever. It suits archives and other long-lived content.
• Filecoin is a storage market with paid contracts, used at larger and more enterprise scales. Walrus is a newer Sui-native option built for large media and datasets.

Layer 7: Applications

The application layer is the part users actually interact with, and most apps share a pattern worth learning once: connect a wallet, approve a token, sign a transaction, end up with onchain receipts.

DeFi is the most mature category. Decentralized exchanges (Uniswap leads spot volume, Hyperliquid leads perpetuals, Curve owns stablecoin swaps) let users trade without an account. Lending markets (Aave is the largest) let users borrow against collateral or earn yield. Liquid staking (Lido, Rocket Pool) lets users earn validator yields without running a node.

DeFi also runs on stablecoins, which are worth calling out because they are less an app than the money the apps move. Balances live in normal wallets, transfers settle in seconds, and any contract can hold or move them. USDC, USDT, DAI, PayPal's PYUSD, and Ripple's RLUSD are the major dollar stablecoins, used for trading, payments, treasury, payroll, and as the unit of account across DeFi. Our enterprise stablecoin guide covers the use cases in detail.

Beyond DeFi, the application layer is wide open. Prediction markets (Polymarket, Kalshi) turn real-world outcomes into tradable markets, and their resolution data is increasingly cited by mainstream media. Onchain social apps put a user's graph and content under their control instead of in a private database. NFTs and onchain gaming have moved past the speculative peak into collectibles, ticketing, and persistent game assets. Tokenized real-world assets are now a real revenue category: treasury products from Ondo, Maple, and BlackRock hold billions, and banks and fintechs (JPMorgan, Visa, PayPal, Stripe) are building on the same rails. The honest summary is that the categories keep expanding and you can build almost anything here.

Layer 8: The agentic layer

The newest layer is the one moving fastest. AI agents are now a class of user that signs transactions, pays for API calls, and operates inside applications without a human in the loop. They need the same three things any user does: an identity, a way to pay, and a way to discover what services exist. The agentic layer is the set of primitives that gives them each.

Agent identity is tracked onchain by a wallet, the same way human users are. The same smart accounts humans use can be assigned to an agent. The agent holds the keys (or part of them, via MPC) and signs transactions on its own. The smart-account features that already exist for human users are precisely what bound an agent: a spending limit it cannot exceed, a session key that expires, permissions scoped to a single contract.

Once an agent has an identity, it needs a way to pay. The emerging pattern pairs HTTP's 402 "Payment Required" response with onchain stablecoin transfers: an agent calls an API, gets a 402, pays from its own wallet, and proceeds, with no account, API key, or prior relationship. Several standards define how this works, including Coinbase's x402, MPP, ACP, and A2P. None has won, and most serious deployments expect to support more than one. Proxy platforms, including Alchemy's AgentPay, sit in front of an API and translate between the standards so a merchant integrates once instead of separately per protocol.

The third piece is discovery. Once agents can hold identity and pay, they still need a way to learn what services exist and how to call them. The Model Context Protocol (MCP), originally proposed by Anthropic, defines how an AI agent learns what an external system can do and what tools it offers. Most major API providers now ship MCP servers so agents can use them directly without a human reading the docs first. Our Alchemy MCP server exposes 148 tools across 100+ chains to any MCP-compatible client.

What the agentic layer changes about product design:

• Documentation is also a tool. Skill manifests and MCP servers make capabilities machine-readable, not just human-readable.
• Authentication has new shapes. An agent might not have a person to complete an OAuth flow. Sign-in with Ethereum, EIP-7702 delegations, and session keys give agents portable scoped credentials.
• Pricing assumes microtransactions. A single agent workflow can trigger thousands of pennies-per-call payments per minute, the opposite of how human-paid SaaS pricing is built.

How to choose where to start

Most teams overthink the network layer and underthink everything above it. The decisions that absorb most of your engineering hours are at the infrastructure, smart contract, and wallet layers.

• Pick the chain (or chains) by user. Ethereum L2s for DeFi and high-trust use cases. Solana for payments, consumer apps, and latency-sensitive products. Bitcoin L2s for native BTC products. A second or third chain is no longer expensive once your infra provider already supports it.
• Pick infrastructure by what you actually call. Most teams need an RPC provider with the chains and indexed data APIs they use. Alchemy, QuickNode, Helius, and Chainstack are the major options.
• Pick a smart contract framework by language. Foundry for Solidity-only projects and the fastest test loop. Hardhat for TypeScript-heavy teams. Anchor for Solana.
• Pick a frontend stack by audience. Existing wallets: Viem, Wagmi, and a connector like RainbowKit or AppKit. No wallet expectation: an embedded wallet SDK like Privy or Dynamic.
• Pick wallet patterns by control. Connector libraries for bring-your-own-wallet. Smart accounts when you need to sponsor gas, batch transactions, scope permissions, or build for an agent.

Most of these decisions are reversible. The two that stick are your chain and your wallet pattern, because changing either after launch means migrating users. Get those two right; iterate on the rest.

FAQ

What is the web3 stack?

The web3 stack is the layered set of tools a developer touches when building blockchain-based applications: networks (L1s, L2s, modular components), infrastructure for reading and writing onchain data, smart contracts, wallets and account abstraction (including identity primitives like ENS), frontend libraries and wallet connectors, decentralized storage, and the application layer. An eighth, newer layer (the agentic stack) lets AI agents act as users on top of the same primitives.

What programming languages do web3 developers use?

The most common languages are Solidity (Ethereum and EVM chains), Rust (Solana, NEAR, parts of Aptos and the modular stack), Move (Sui, Aptos), Vyper (some EVM DeFi protocols), and Cairo (Starknet). Solidity is the default for any EVM-compatible chain. Rust dominates outside the EVM.

Which smart-contract framework should I use in 2026?

Foundry for most new Ethereum and EVM projects, especially when the team writes Solidity end to end. Hardhat when the team is TypeScript-heavy and wants the same language across contracts, scripts, and tests. Anchor for Solana programs in Rust.

Do I need to run my own node to build a web3 app?

Almost certainly not. A self-hosted Ethereum archive node runs $10,000 to $25,000 a year, mostly in NVMe storage and bandwidth, before you count the engineering hours to keep it alive. Most production teams use a managed RPC provider (Alchemy, QuickNode, Helius, Chainstack, dRPC) that exposes JSON-RPC and WebSocket endpoints and indexed data APIs as hosted services.

What is account abstraction?

Account abstraction is a pattern where a user's account is itself a smart contract instead of a simple keypair. ERC-4337 is the Ethereum standard that defines how this works without changing the underlying protocol; it went live on mainnet in March 2023. Smart contract wallets can sponsor gas, batch transactions, set spending limits, rotate keys, and authenticate with passkeys. EIP-7702 extends the pattern by letting a regular EOA temporarily behave like a smart contract.

How do AI agents fit into the web3 stack?

Agents use the existing infrastructure with three additions. They use smart accounts as identity, sign their own transactions, and hold their own keys (sometimes via MPC). They pay for API access using one of several emerging standards (x402, MPP, ACP, A2P), all of which combine HTTP 402 with onchain stablecoin transfers, with no single winner yet. They discover capabilities through machine-readable manifests, most often via the Model Context Protocol (MCP). The result is that agents can use blockchain infrastructure end to end without a human-issued account, an API key, or a prior relationship.

What chain should I build on in 2026?

Pick by where your users and liquidity already live. Ethereum and its L2s (Arbitrum, Base, Optimism, zkSync) for DeFi, stablecoins, and high-trust use cases. Solana for payments, consumer apps, and latency-sensitive products. Bitcoin and its L2s for native BTC products. Most production apps are multichain by default, and modern infrastructure providers make running across 100+ chains a configuration choice rather than a separate build.

What are EVM-compatible blockchains?

EVM-compatible blockchains share Ethereum's Virtual Machine, which means Solidity contracts and most Ethereum tooling work across all of them without modification. Arbitrum, Base, Optimism, BNB Smart Chain, Avalanche, and Polygon are all EVM-compatible. The practical benefit for developers is that deploying to a second EVM chain is close to a config change — the same contract code, the same framework, and the same library stack all transfer.

Why can't I store all my application data directly on the blockchain?

Storing data onchain is expensive because every byte has to be processed and stored by every node in the network. Putting images, video, or large JSON on Ethereum would cost orders of magnitude more than equivalent cloud storage. The rule of thumb: keep only the data that needs to be immutable or trustlessly verifiable onchain — transaction state, ownership records, contract logic — and use decentralized storage (IPFS, Arweave, Filecoin) or ordinary cloud storage for everything else.

What types of applications are built on the Web3 stack?

The application layer is wide open. DeFi is the most mature category: decentralized exchanges (Uniswap, Hyperliquid, Curve), lending markets (Aave), and liquid staking (Lido, Rocket Pool). Stablecoins (USDC, USDT, DAI) are the money these apps move. Beyond DeFi: prediction markets (Polymarket), onchain social apps, NFTs and onchain gaming, and tokenized real-world assets from Ondo, Maple, and BlackRock. Banks and fintechs including JPMorgan, Visa, PayPal, and Stripe are building on the same rails.

Start building

The web3 stack has clear leaders in most categories, modular blockchains and account abstraction make the tradeoffs explicit instead of forcing them on you, and modern infrastructure has collapsed the cost of going multichain.

Get a free Alchemy API key for 100+ chains. No credit card, no waitlist, no contracts. Contact sales if you are building at production scale.