Web3 Infrastructure Stack in 2026: The Complete Developer Guide

TL;DR

• The Web3 infrastructure stack has matured with 75+ major projects across key categories.
• Core layers: Node services (Alchemy, Infura), Data indexing (The Graph), Storage (IPFS, Filecoin), Wallets (embedded + AA).
• Alchemy powers 71% of top crypto apps across 80+ networks—it’s the dominant infrastructure provider.
• Development frameworks: Hardhat for Ethereum/EVM, Foundry for advanced testing, Anchor for Solana.
• Account Abstraction (ERC-4337) is transforming UX with gas sponsorship and embedded wallets.
• Cross-chain interoperability (LayerZero, Wormhole) enables multi-chain product architectures.
• Web3 developers are still <1% of global developers—massive opportunity as the stack becomes more accessible.

---

The Modern Web3 Stack

┌─────────────────────────────────────────────────────────────┐
│                  APPLICATION LAYER                          │
│  Your dApp: Frontend, business logic, user experience       │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────┼──────────────────────────────────┐
│                  WALLET & AUTH LAYER                        │
│  Embedded wallets, AA smart accounts, social login          │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────┼──────────────────────────────────┐
│                  DATA & INDEXING LAYER                      │
│  The Graph, event indexing, analytics                       │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────┼──────────────────────────────────┐
│                  NODE & API LAYER                           │
│  Alchemy, Infura, QuickNode, JSON-RPC                       │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────┼──────────────────────────────────┐
│                  BLOCKCHAIN LAYER                           │
│  Ethereum, Polygon, Arbitrum, Base, Solana, etc.            │
└─────────────────────────────────────────────────────────────┘

Layer 1: Node Services

What Node Services Do

Your dApp needs to interact with the blockchain. Options:

• Run your own node (expensive, complex)
• Use a node service (recommended for most)

Approach	Pros	Cons
Self-hosted node	Full control, no dependencies	$500-2000+/month, maintenance burden
Node service	Instant setup, managed, scalable	Vendor dependency, usage costs

Major Providers

Provider	Networks	Strengths
Alchemy	80+	Dominant market share (71%), enhanced APIs
Infura	15+	Ethereum pioneer, ConsenSys backing
QuickNode	25+	Fast, developer-friendly
Ankr	50+	Decentralized RPC

Alchemy Implementation

import { createAlchemyWeb3 } from "@alch/alchemy-web3";

const web3 = createAlchemyWeb3(
  `https://eth-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}`
);

// Enhanced APIs beyond standard JSON-RPC
const nfts = await web3.alchemy.getNftsForOwner(address);
const transfers = await web3.alchemy.getAssetTransfers({
  fromAddress: address,
  category: ["erc20", "erc721"],
});

Key Features

Feature	What It Does
Enhanced APIs	NFT APIs, token APIs, trace APIs
Webhooks	Real-time notifications for on-chain events
Mempool access	Pending transaction data
Archive data	Historical state access
Debug APIs	Transaction tracing, simulation

Layer 2: Data Indexing

The Indexing Problem

Blockchains are append-only logs. Querying them directly is slow and expensive. Indexing solutions pre-process blockchain data for fast queries.

The Graph

The dominant decentralized indexing protocol:

# Define a subgraph schema
type Transfer @entity {
  id: ID!
  from: Bytes!
  to: Bytes!
  value: BigInt!
  timestamp: BigInt!
  blockNumber: BigInt!
}

# Query indexed data
{
  transfers(
    first: 10
    where: { from: "0x..." }
    orderBy: timestamp
    orderDirection: desc
  ) {
    id
    to
    value
    timestamp
  }
}

Other Indexing Solutions

Solution	Approach	Best For
The Graph	Decentralized subgraphs	Standard indexing
Goldsky	Managed + Mirror	Real-time data
Dune Analytics	SQL queries	Analytics, dashboards
Footprint	No-code analytics	Business intelligence

Layer 3: Storage

On-Chain vs. Off-Chain

Storage Type	Use Case	Cost
On-chain	Critical state, small data	$$$$
IPFS	Immutable content, media	$
Filecoin	Long-term archival	$$
Arweave	Permanent storage	$$$

IPFS for NFT Metadata

import { create } from 'ipfs-http-client';

const ipfs = create({ url: 'https://ipfs.infura.io:5001' });

async function uploadMetadata(metadata: NFTMetadata) {
  // Upload image first
  const imageResult = await ipfs.add(metadata.image);
  
  // Upload metadata with IPFS image URL
  const metadataWithImage = {
    ...metadata,
    image: `ipfs://${imageResult.path}`,
  };
  
  const metadataResult = await ipfs.add(
    JSON.stringify(metadataWithImage)
  );
  
  return `ipfs://${metadataResult.path}`;
}

Layer 4: Wallets & Authentication

Evolution of Wallet UX

Generation	Technology	UX
Gen 1	Browser extensions	Install extension, backup seed phrase
Gen 2	WalletConnect	Mobile wallet + QR code
Gen 3	Embedded wallets	Social login, invisible wallet
Gen 4	Smart accounts (AA)	Gas sponsorship, batched txs

Embedded Wallet Implementation

import { ThirdwebProvider, ConnectButton } from "@thirdweb-dev/react";

function App() {
  return (
    <ThirdwebProvider
      clientId={clientId}
      supportedWallets={[
        // Social login creates embedded wallet
        inAppWallet({
          auth: { options: ["google", "apple", "email"] },
        }),
        // Smart account wrapper
        smartWallet(inAppWallet(), {
          factoryAddress: FACTORY,
          gasless: true,
        }),
      ]}
    >
      <ConnectButton />
    </ThirdwebProvider>
  );
}

Account Abstraction Benefits

Feature	EOA	Smart Account
Gas payment	User pays ETH	App sponsors
Transaction batching	One at a time	Multiple in one
Recovery	Seed phrase	Social/guardian
Signature schemes	ECDSA only	Flexible (passkeys)

Layer 5: Cross-Chain

The Multi-Chain Reality

Modern dApps often span multiple chains:

Chain	Strength	Use Case
Ethereum	Security, liquidity	High-value, DeFi
Polygon	Low cost, speed	Gaming, social
Arbitrum	EVM, scaling	DeFi, general
Base	Coinbase ecosystem	Consumer apps
Solana	Speed, low cost	High-frequency, payments

Interoperability Solutions

Solution	Approach	Use Case
LayerZero	Omnichain messaging	Cross-chain tokens, NFTs
Wormhole	Bridge protocol	Asset transfers
Axelar	General message passing	Cross-chain dApps
CCIP	Chainlink protocol	Enterprise interop

Development Frameworks

Hardhat (EVM)

The standard for Ethereum development:

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";

const config: HardhatUserConfig = {
  solidity: "0.8.24",
  networks: {
    hardhat: {},
    sepolia: {
      url: process.env.SEPOLIA_URL,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY,
  },
};

export default config;

Foundry

Advanced testing and fuzzing:

// test/Token.t.sol
pragma solidity ^0.8.24;

import "forge-std/Test.sol";
import "../src/Token.sol";

contract TokenTest is Test {
    Token token;
    
    function setUp() public {
        token = new Token();
    }
    
    function testTransfer(uint256 amount) public {
        // Fuzz testing with random amounts
        vm.assume(amount <= token.balanceOf(address(this)));
        token.transfer(address(1), amount);
        assertEq(token.balanceOf(address(1)), amount);
    }
}

Framework Comparison

Framework	Language	Strengths	Best For
Hardhat	JS/TS	Ecosystem, plugins	Most projects
Foundry	Solidity	Speed, fuzzing	Advanced testing
Anchor	Rust	Solana native	Solana programs

Implementation Checklist

Initial Setup

• Choose node provider (Alchemy recommended)
• Set up development framework (Hardhat/Foundry)
• Configure networks (mainnet, testnet)
• Set up wallet connection

Data Layer

• Determine indexing needs
• Deploy subgraph (if using The Graph)
• Set up webhooks for events
• Configure storage (IPFS for media)

Wallet & UX

• Implement embedded wallet
• Add Account Abstraction
• Configure gas sponsorship
• Set up social login

Production

• Monitor RPC usage
• Set up alerting
• Configure rate limiting
• Plan for multi-chain if needed

FAQ

Should I run my own node?

For most projects, no. Node services are more cost-effective until you’re at massive scale or have specific requirements (like MEV extraction).

Which chain should I build on?

Depends on your use case. Ethereum for high-value DeFi, L2s (Arbitrum, Base) for general apps, Solana for high-frequency/payments.

Do I need Account Abstraction?

For consumer apps, strongly recommended. The UX improvement is dramatic. For DeFi power users, traditional EOAs may still be preferred.

How do I choose between indexing solutions?

The Graph for standard needs, Goldsky for real-time/streaming, Dune for analytics dashboards.

Is multi-chain necessary?

Not for MVP. Build on one chain first. Add multi-chain when you have clear user demand.

What about privacy?

Consider zk-rollups (zkSync, Scroll) or privacy-focused chains. Standard EVM chains are fully transparent.

Sources & Further Reading

• Web3 Infrastructure Map — 75+ project overview
• Alchemy Documentation — Node service guide
• Web3 Developer Stack — Coinbase guide
• Alchemy Web3 Stack Guide — Detailed stack breakdown
• Web3 User Onboarding — Related: wallet UX
• Web3 Marketplace MVP — Related: building dApps