Future

Cover image for Web3 Infrastructure: RPCs, Nodes, Infura/Alchemy (The Invisible Plumbing)
Ribhav
Ribhav

Posted on

Web3 Infrastructure: RPCs, Nodes, Infura/Alchemy (The Invisible Plumbing)

#crypto #blockchain #web3 #beginners

You click "Swap" on Uniswap. MetaMask pops up. Transaction flies to Ethereum. Magic? Nope.

There's invisible plumbing making every wallet click and smart contract call possible: RPC nodes.

Today on Day 22 we pull back the curtain on what actually powers your MetaMask, dApps, and every blockchain interaction. 🛠️

Blockchains are "blind" without nodes

Remember Day 6? Smart contracts live on-chain. But they can't "see" your wallet balance, pending transactions, or even the current block without asking someone.

That "someone" is an RPC node — a computer constantly synced to the blockchain, ready to answer questions like:

  • "What's my ETH balance?"
  • "Did my transaction confirm?"
  • "What's the latest block?"

Without nodes, MetaMask is just a fancy calculator with no internet connection.

Analogy: Your phone doesn't store the entire internet. It asks Google ("Hey, what's the weather?"). RPC nodes are Web3's Google.

What is an RPC node? (Simple version)

RPC = Remote Procedure Call — fancy talk for "computer A asks computer B to run a function and send results back."

RPC Node = A full blockchain copy that:

  1. Downloads every block, transaction, and smart contract state
  2. Speaks JSON-RPC (standard language for blockchain queries)
  3. Serves as a middleman between your dApp/wallet and the chain

Every time you:

  • Check balance in MetaMask
  • Send a transaction
  • Query Uniswap prices MetaMask sends an RPC request to a node somewhere.

Real example: When you deployed your first contract on Sepolia (Day 9), Remix IDE asked an RPC endpoint: "Hey, broadcast this transaction for me."

The RPC URL — Web3's "phone number"

Every blockchain connection starts with an RPC URL like:

https://eth-sepolia.g.alchemy.com/v2/YOUR_API_KEY
https://mainnet.infura.io/v3/YOUR_PROJECT_ID

Breakdown:

  • eth-sepolia = Ethereum Sepolia testnet
  • alchemy.com / infura.io = the node provider
  • YOUR_API_KEY = your free developer account

MetaMask settings → Networks → Ethereum Mainnet → RPC URL = exactly this.

Pro tip: Copy your Alchemy/Infura URL from their dashboard, paste into MetaMask custom networks. Instant connection to any chain.

Running your own node vs using providers

Option 1: Run your own (hardcore)

$ geth --sepolia --http --http.api eth,net,web3

Downloads 100s of GBs. Runs 24/7. Full control. But... electricity bill + crashes when your laptop sleeps.

For: Privacy nuts, MEV bots, enterprise dApps

Option 2: Use providers (99% of devs)

Infura (ConsenSys) + Alchemy power 90% of Web3.

Why they win:

  • 99.99% uptime (your node crashes = your dApp dies)
  • Auto-scaling (Uniswap does 1M+ requests/sec)
  • Free tiers (300k requests/day)
  • Built-in analytics, debugging, archiving

Day 9 Sepolia deploy? You used their node without knowing.

Infura vs Alchemy — The node provider showdown

Feature Infura Alchemy Winner
Free Tier 100k req/day 300k req/day Alchemy
Uptime 99.9% 99.99% Alchemy
Analytics Basic God-tier dashboard Alchemy
L2 Support Good Excellent Alchemy
Ethereum Foundation ties Strong Growing Tie

My pick: Alchemy. Better free tier + dashboard makes debugging way easier.

Switching test: Both give free API keys. Try deploying the same contract to both. Speed + reliability identical for small projects.

Real-world: How MetaMask + RPCs actually work

  1. You click "Swap ETH → USDC" on Uniswap
  2. Uniswap asks RPC: "What's my ETH balance? USDC price?"
  3. MetaMask asks RPC: "Can I sign this tx? Gas price?"
  4. You approve → MetaMask broadcasts tx via RPC
  5. RPC broadcasts to Ethereum miners/validators
  6. 6 blocks later → RPC confirms "Tx success!"

Every step? RPC call. No RPC = no Web3.

"What if Infura goes down?" → Switch RPC URL in MetaMask settings. 30 seconds.

Why this matters for builders (the DevRel angle)

Junior dev: "My contract deploy failed!" → Check RPC status first.
Scaling dApp: Free tier ends → paid plans start at $49/mo
Privacy-focused: Run your own node + Tor
MEV bot: Need archive nodes (full historical data)

From my Sepolia deploys: Spent 2hrs debugging "transaction underpriced" before realizing my RPC was rate-limited. Never again.

Pro move: Always have 2-3 RPC URLs ready. Primary + backup + self-hosted.

Hands-on: Set up your own RPC pipeline (5 mins)

  1. Sign up: alchemy.com (free)
  2. Create app → Copy Sepolia RPC URL

  3. MetaMask → Settings → Networks → Add Network:
    Name: Sepolia (Alchemy)
    RPC URL: https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY
    Chain ID: 11155111
    Currency: ETH

  4. Test: Send 0.001 Sepolia ETH to your address. Watch it appear instantly.

Challenge: Deploy Day 9 contract using your Alchemy RPC vs Infura. Compare speed.

Reflection: The "aha" moment

RPCs felt boring until I realized: MetaMask isn't magic. It's just a fancy RPC client.

Understanding nodes = understanding why:

  • Transactions "get stuck" (RPC rate limits)
  • dApps crash during congestion (provider overload)
  • "Private" wallets aren't private (shared RPCs see everything)

Next time someone says "Web3 is just JSON over HTTPS," nod knowingly.

Key Takeaway

RPC nodes are Web3's Google — every wallet click, swap, and contract call goes through them. Infura/Alchemy handle 90% of traffic so you don't have to.

What to do next

Learning:

  • Set up Alchemy account + custom RPC in MetaMask
  • Read Day 23 (On-chain identity) knowing ENS queries hit RPCs too (Stay Tuned)

Building:

  • Bookmark 3 RPC providers (Alchemy, Infura, QuickNode)
  • Never hardcode single RPC URL in production

Join us:

Further Reading

Top comments (0)