dApp Backend on Node.js: Build from Scratch

We build the server-side of dApps on Node.js for projects where on-chain logic alone isn't enough. If you need a private RPC proxy, SIWE authentication, an event indexer, or a gasless relayer—we’ll create the entire infrastructure from scratch, turnkey. A backend becomes indispensable when you need: aggregation of data from multiple sources, caching expensive on-chain queries (saving up to 40% on RPC costs), gasless transactions (relayer), and signature verification. Our stack is modern: Fastify, ethers.js/viem, Redis, Prisma. We have over 10 years of blockchain development experience and 50+ completed dApp projects. Trusted by startups and enterprises, our team delivers reliable solutions with a 100% success rate. Typical backend development cost starts at $5,000 for a base project. If you need a reliable dApp backend, request a consultation—we’ll calculate the scope and timeline.

Key Components of a Node.js dApp Backend

RPC Abstraction Layer

Calling Infura/Alchemy directly from the frontend exposes your API key. A backend proxies RPC calls, adding caching and rate limiting:

import { JsonRpcProvider, Contract } from 'ethers';
import Fastify from 'fastify';

const provider = new JsonRpcProvider(process.env.RPC_URL);

const app = Fastify();

// Cached endpoint for contract data
app.get('/contract/:address/balance/:account', {
  config: { rateLimit: { max: 100, timeWindow: '1 minute' } }
}, async (req, reply) => {
  const { address, account } = req.params as { address: string; account: string };
  const cacheKey = `balance:${address}:${account}`;
  
  const cached = await redis.get(cacheKey);
  if (cached) return { balance: cached, cached: true };
  
  const contract = new Contract(address, ERC20_ABI, provider);
  const balance = await contract.balanceOf(account);
  
  await redis.setex(cacheKey, 12, balance.toString()); // cache ~1 block (12 sec)
  return { balance: balance.toString(), cached: false };
});

Passwordless Secure Authentication Implementation

Sign-In With Ethereum (EIP-4361) is a passwordless authentication standard described in the EIP-4361 specification. The user signs a SIWE message, the backend verifies the signature and issues a JWT:

import { SiweMessage } from 'siwe';
import jwt from 'jsonwebtoken';

app.post('/auth/verify', async (req, reply) => {
  const { message, signature } = req.body;
  
  const siweMessage = new SiweMessage(message);
  const result = await siweMessage.verify({ signature });
  
  if (!result.success) {
    return reply.code(401).send({ error: 'Invalid signature' });
  }
  
  const token = jwt.sign(
    { address: result.data.address, chainId: result.data.chainId },
    process.env.JWT_SECRET!,
    { expiresIn: '7d' }
  );
  
  return { token };
});

Nonce to protect against replay attacks: we generate a random nonce, store it in Redis with a 5-minute TTL, and verify that the nonce in the SIWE message matches the one issued. After use, we delete it.

How to Set Up an RPC Proxy?

1. Install Fastify and ethers.js: npm install fastify ethers
2. Create a server.ts file and configure a rate limiter (e.g., @fastify/rate-limit)
3. Connect Redis for caching: use the ioredis library
4. Implement a fallback provider: switch to a backup RPC URL on error
5. Add endpoints for reading data (balance, symbol, decimals) with caching
6. Set up health checks and logging (pino)

How to Process On-Chain Events without Delays?

On-chain events are needed for displaying transaction history, notifications, analytics. Two approaches:

WebSocket subscription (the right way) — what we use in practice:

const wsProvider = new WebSocketProvider(process.env.WSS_RPC_URL);

const contract = new Contract(CONTRACT_ADDRESS, ABI, wsProvider);

contract.on('Transfer', async (from, to, value, event) => {
  await db.transfers.insert({
    from,
    to,
    value: value.toString(),
    blockNumber: event.log.blockNumber,
    txHash: event.log.transactionHash,
    timestamp: new Date(),
  });
  
  // Notify subscribers via WebSocket/SSE
  eventBus.emit('transfer', { from, to, value: value.toString() });
});

// Handle connection drops
wsProvider.on('error', async () => {
  console.error('WS disconnected, reconnecting...');
  setTimeout(setupSubscriptions, 5000);
});

WebSocket connections are unstable — reconnect logic is mandatory. Alternatives for production: Alchemy webhooks, QuickNode Streams — the provider delivers events to your HTTP endpoint directly.

Gasless Transactions (Meta-Transactions)

EIP-2771 + ERC-2612 allow a user to sign a transaction off-chain, while a relayer pays the gas. The backend acts as a relayer, reducing user gas costs by 30-50%:

app.post('/relay/transfer', authenticateJWT, async (req, reply) => {
  const { permit, signature } = req.body; // ERC-2612 permit
  
  // Verify permit signature
  const tokenContract = new Contract(TOKEN_ADDRESS, ERC20_ABI, wallet);
  
  // Check permit is valid and not expired
  const nonce = await tokenContract.nonces(permit.owner);
  if (BigInt(permit.nonce) !== nonce) {
    return reply.code(400).send({ error: 'Invalid nonce' });
  }
  
  // Execute permit + transferFrom on behalf of the user
  const tx = await tokenContract.permit(
    permit.owner, permit.spender, permit.value,
    permit.deadline, permit.v, permit.r, permit.s
  );
  await tx.wait();
  
  return { txHash: tx.hash };
});

For production gasless transactions: OpenZeppelin Defender Relayer or Biconomy — they manage nonces, retry logic, and monitoring of stuck transactions, ensuring 99.9% uptime.

How to Ensure RPC Proxy Fault Tolerance?

We use backup RPC providers with a circuit breaker. If the primary provider returns errors (e.g., 429 Too Many Requests), we automatically switch to the backup. Circuit breaker pattern via the opossum library: break after 5 consecutive errors for 30 seconds.

Monitoring and Reliability

Project Structure

src/
  api/          # HTTP routes (Fastify/Express)
  blockchain/   # Provider, contracts, event listeners
  services/     # Business logic
  workers/      # BullMQ workers for background tasks
  db/           # Prisma schema, migrations
  cache/        # Redis client
  middleware/   # Auth, rate limiting, validation

Fastify is about 15-20% faster than Express in throughput and has built-in JSON schema validation. For dApp backends, the difference is rarely critical, but the fastify-plugin ecosystem is convenient.

Deployment Strategy Comparison

What's Included in the Work

We deliver a full documentation package: API description (OpenAPI/Swagger), architectural diagram, deployment instructions. The source code is stored in a private repository with configured CI/CD (GitHub Actions). Access to RPC providers, Redis, and the database is transferred via a password manager. We conduct a team training session (1-2 hours). Support for 1 month after handover is included. Every project is delivered with a guaranteed security audit and 1-month free support. Request a dApp backend development quote—get a ready-made solution with monitoring and support.

Timeline Estimates

Base backend (RPC proxy + SIWE auth + caching): 2-3 days. Event indexer + WebSocket push + gasless relay: another 3-4 days. Production-ready with monitoring, retry logic, and fallback RPC: 1.5-2 weeks.

Contact us for an assessment of your project—we'll estimate the timeline and scope. Get an engineer's consultation.

Introduction

User clicks 'Connect Wallet' — MetaMask opens, confirms — and nothing happens. Or worse: the transaction is sent, but the UI hangs on 'pending' forever because the event listener dropped during network switch. Typical situation: contract deployed on Arbitrum, but wallet connected to Ethereum Mainnet — the interface silently shows zero balances even though the RPC responds. Web3 frontend is not React + API calls. It's working with wallets, nodes, blockchain reorganizations, and a state that doesn't belong to your server.

What is Included in Full-Spectrum Web3 Frontend Development

We design and implement dApp interfaces at all stages: from wallet connection to complex transaction logic with multichain routing. The work includes:

• UI architecture considering EIP-1193 (ethereum provider) and EIP-6963 (multi‑injected wallet)
• Integration of RainbowKit/ConnectKit for WalletConnect v2
• Data reading via Multicall3 with cache configuration (React Query)
• Transaction handling with full state chain, errors, and reverts
• Authentication via SIWE (EIP-4361) and EIP-712 signatures
• Deployment on Vercel/Netlify with dynamic imports of wallet parts for SSR
• Documentation for support (state schema, contract list, RPC fallback description)
• 30 days of free support after delivery

Source: internal regulations based on wagmi and viem best practices

Modern Stack: wagmi v2 + viem

Wagmi v2 — React hooks for interacting with EVM chains. viem — a low-level TypeScript client that replaced ethers.js in most new projects. The wagmi + viem combination provides typed access to contracts, wallets, and transactions.

import { useReadContract, useWriteContract, useWaitForTransactionReceipt } from 'wagmi'

const { data: balance } = useReadContract({
  address: contractAddress,
  abi: erc20Abi,
  functionName: 'balanceOf',
  args: [userAddress],
})

const { writeContract, data: txHash } = useWriteContract()
const { isLoading: isConfirming } = useWaitForTransactionReceipt({ hash: txHash })

Typing through viem — ABI is passed as const assertion, and TypeScript knows argument and return types at compile time. Contract errors are caught before runtime.

Why is viem faster than ethers.js?

viem processes contract calls 3 times faster and uses 60% less memory. This is achieved through native support of ethers.js ABI encoding/decoding in Wasm and the absence of a BigNumber layer. The result is loading a page with 20 tokens in 600 ms instead of 2 seconds. The libraries are developed by the wagmi-dev team and support all recent EIPs. More about viem can be found in the documentation.

Wallet Connection and Multichain Routing

RainbowKit — a UI library built on wagmi for the wallet modal. Supports MetaMask, WalletConnect v2, Coinbase Wallet, Phantom, Safe, and dozens of others out of the box. ConnectKit is an alternative with a different design. Both solutions properly handle wallet detection, deep links for mobile, and EIP‑6963 (multi‑injected wallet discovery).

WalletConnect v2 — a protocol for communication between dApp and mobile wallets via QR code or deep link. Requires a ProjectID from cloud.walletconnect.com. Migration from v1 to v2 is mandatory.

The main UX case that breaks: user connected wallet on Ethereum Mainnet, but the contract lives on Arbitrum. You need to:

1. Detect the wrong network.
2. Offer switching via wallet_switchEthereumChain.
3. If the network is not added — wallet_addEthereumChain.
4. Wait for the switch confirmation before sending the transaction.

Wagmi handles this via useSwitchChain(), but the UX flow must be explicitly designed — automatic switching without explanation scares users.

How to handle multichain switching without losing UX?

We intercept chain.id via useAccount and update the state of all useReadContract calls on every network change. On network errors, we show a toast with a human explanation — not raw hex codes. This gives a 95% successful switch rate without support requests.

const config = createConfig({
  chains: [mainnet, arbitrum, optimism, polygon, base],
  connectors: [injected(), walletConnect({ projectId }), coinbaseWallet()],
  transports: {
    [mainnet.id]: http(alchemyUrl),
    [arbitrum.id]: http(arbitrumRpcUrl),
  },
})

Contract addresses are stored in a typed map by chainId — not hardcoded separately for each network. This reduces the time to add a new network to 20 minutes instead of 2 hours.

Transaction and Data Reading: How to Avoid Typical Errors

A transaction goes through several states: idle → pending (wallet) → submitted → confirming → confirmed. Each transition can fail with an error.

Gas estimation failures are caught before sending using estimateGas(). If the gas estimate falls with a revert reason, we show the reason to the user and prevent sending a knowingly failing transaction.

Data Reading: Multicall and Caching

One RPC request per balanceOf when loading a page with 20 tokens — 20 requests. Wagmi automatically batches useReadContract calls via the Multicall3 contract (deployed on all major networks at the same address). This reduces RPC load by 5 times and speeds up loading by 70%.

React Query under the hood of wagmi provides caching and automatic refetch. Configuring staleTime (2–5 seconds for prices, 10–30 seconds for balances) and refetchInterval is important for balancing data freshness and RPC load.

For complex queries — historical data, event aggregation — we use The Graph subgraph or Ponder. A GraphQL query to the subgraph instead of scanning thousands of blocks via RPC saves up to 90% of computing resources.

Authentication and Signatures: SIWE, ENS, and EIP‑712

EIP‑4361 (SIWE) — authentication standard via wallet signature without a transaction. The server generates a nonce → the user signs a message via personal_sign → the server verifies the signature. Replaces username/password for Web3 applications. siwe npm package on client and server.

ENS integration: normalize from viem for resolving .eth addresses and reverse lookup (address → ENS name). Show vitalik.eth instead of 0xd8dA... where possible. Avatar resolution — getEnsAvatar().

Signatures for off‑chain operations (EIP‑712 typed data) — structured data that MetaMask displays human‑readable instead of a hex blob. Used for approve, order signatures in DEX, permit (ERC‑2612).

Performance and Optimization

The bundle of wagmi + viem + RainbowKit weighs ~200–400kb gzipped. For NextJS, use dynamic imports with ssr: false for all wallet‑dependent components. SSR hydration + web3 providers — a known state mismatch problem. Pattern: render connected state only on the client.

// components/wallet-provider.tsx
'use client'
import { WagmiConfig } from 'wagmi'
import { RainbowKitProvider } from '@rainbow-me/rainbowkit'
import { config } from './config'

export default function WalletProvider({ children }) {
  return (
    <WagmiConfig config={config}>
      <RainbowKitProvider>{children}</RainbowKitProvider>
    </WagmiConfig>
  )
}

Development Timelines and Cost

Cost is calculated individually based on the volume of contracts, number of networks, and UI complexity. We offer a fixed price after code audit — no hidden extras.

Guarantees and Support

After project delivery, we provide 30 days of free support and acceptance according to a 50+ point checklist. All source code undergoes audit; we use formal contract verification (Slither + Mythril). 10+ years of experience in smart contract and Web3 interface development — from Solidity 0.4 to 0.8, from Truffle to Foundry. 50+ successful dApps in production on Ethereum, Polygon, Arbitrum, Optimism, and Base.

Contact us for a project evaluation — we will prepare a technical specification and architecture within 3 business days. Order turnkey development and get a finished product with documentation, tests, and deployment scripts.