Web3 development bridges traditional web applications to blockchain — wallets, smart contracts, token standards, and decentralized protocols. The 2026 stack: ethers.js (most downloaded, 70% Solidity dev usage), viem (TypeScript-native, 35KB bundle, 39% adoption), wagmi (React hooks abstraction, 33% adoption). Critical note: Web3.js was officially archived March 4, 2025 — all new projects should migrate to ethers.js or viem. WalletConnect v2 handles cross-platform wallet connectivity. Web3 developers grew 40% YoY to 28,000 active in Q1 2025, with 3,500+ live dApps on Ethereum and Solana combined.
Web3 development in 2026: ethers.js leads at 70% Solidity dev adoption, viem is TypeScript-native at 35KB (39% adoption), wagmi provides React hooks abstraction (33%). Web3.js archived March 4, 2025 — do not use for new projects. WalletConnect v2 handles cross-platform wallet connectivity. For dApps, DeFi interfaces, NFT marketplaces, and token dashboards, the ethers.js/viem + wagmi + RainbowKit stack covers 90% of requirements.
ethers.js Adoption
Solidity Developer Survey 2025viem Adoption
Solidity Developer Survey 2025Active Web3 Devs
Web3 developer count Q1 2025 (+40% YoY)Web3.js Status
Web3.js GitHub, March 4, 2025ethers.js v6 (70% Solidity developer adoption) provides the most mature, battle-tested Ethereum interaction library with comprehensive TypeScript support
viem's TypeScript-native design with 35KB bundle (40% smaller than ethers.js) and strict ABI-derived types catches interface errors at compile time, not at runtime
wagmi's React hooks (33% adoption) abstract contract reads, writes, wallet state, and transaction lifecycle into composable hooks reducing boilerplate by 60%+
WalletConnect v2 provides universal wallet connectivity — MetaMask, Coinbase Wallet, Rainbow, Ledger, and 300+ wallets through a single integration
RainbowKit provides a polished wallet connection UI covering all major wallets with customizable themes — eliminates weeks of wallet UI development
Web3 developer ecosystem grew 40% YoY to 28,000 active developers Q1 2025 — talent availability is improving across all blockchain stacks
EIP-1193 provider standard means wallet integration code works across MetaMask, Phantom (EVM mode), and all WalletConnect-compatible wallets uniformly
The Merge (2022) and L2 ecosystem maturity mean Web3 UX is now viable for mainstream users — sub-$0.01 L2 fees make transaction-heavy apps economically practical
Web3 development is appropriate for any team building user-facing applications that connect to blockchain — DeFi trading interfaces, NFT collection minting sites, DAO governance dashboards, token holders dashboards, and crypto wallet interfaces. The frontend library layer (ethers.js/viem/wagmi) is language-agnostic relative to which chain you're targeting: Ethereum, Arbitrum, Base, Optimism, and all EVM-compatible chains use the same library set. Solana uses @solana/web3.js, a different library from the archived Web3.js.

Swap interfaces, lending dashboards, yield farming UIs, and liquidity management portals use wagmi hooks to read protocol state, handle multi-step transactions, and manage user wallet connections with real-time balance updates.
NFT collection minting pages, marketplace interfaces, and portfolio viewers use ethers.js/viem to interact with ERC-721/1155 contracts, Seaport marketplace protocol, and IPFS metadata — plus wallet connection via RainbowKit.
Governance portals display proposals, voting status, and treasury analytics by reading Governor contract state via wagmi hooks — allowing token holders to vote from their wallets without leaving the application.
Token holder dashboards, vesting schedule viewers, and multi-chain portfolio trackers read on-chain state across Ethereum and L2s using ethers.js multicall patterns to batch RPC requests efficiently.
Applications adding Web3 wallet authentication (Sign-In With Ethereum, ERC-4337 smart wallets) alongside or replacing traditional email/password login — WalletConnect v2 + wagmi handles the full connection and signature flow.
Multi-chain dApps switching between Ethereum mainnet, Arbitrum, Base, and Optimism use wagmi's chain switching, viem's chain configuration, and bridge protocol integrations (Across Protocol, LayerZero) to provide unified UX.
We believe in honest communication. Here are scenarios where alternative solutions might be more appropriate:
Applications with no blockchain integration — standard web development stacks are simpler and more appropriate when decentralization provides no user benefit
Solana applications — @solana/web3.js v2 (Solana's SDK) is architecturally different from ethers.js/viem and requires Solana-specific development patterns
Backend-only smart contract interaction without user wallets — server-side scripts using ethers.js with a private key signer are simpler than full dApp architecture
Projects expecting sub-100ms UX without RPC optimization — public RPC endpoints introduce latency; dedicated Alchemy/Infura/QuickNode nodes are required for production performance
We're here to help you find the right solution. Let's have an honest conversation about your specific needs and determine if Web3 is the right fit for your business.
DEX aggregator interface built with viem + wagmi — reads liquidity data from Uniswap V3/V4 pools via multicall, displays real-time quotes, handles approval + swap as sequential transactions, and shows gas estimates before submission. Slippage protection and deadline parameters prevent front-running losses.
Example: viem + wagmi DEX interface: Uniswap V3/V4 multicall reads, approval+swap transactions, slippage protection
NFT collection launch site uses RainbowKit for wallet connection, ethers.js for ERC-721 contract interaction, and IPFS for metadata display. Allowlist verification via Merkle proof, public mint phase, and live mint counter — optimistic UI shows mint status before on-chain confirmation.
Example: RainbowKit + ethers.js NFT mint: Merkle allowlist, public mint, IPFS metadata, optimistic UI updates
Governance dashboard built with wagmi + viem reads Governor contract state — active proposals, voting deadlines, quorum progress, and delegate balances. Token holders connect wallets, cast votes, and delegate voting power in-app. Snapshot integration displays off-chain polls alongside on-chain proposals.
Example: wagmi Governor portal: proposals, on-chain voting, delegation, Snapshot integration — multi-wallet support via WalletConnect
Wallet portfolio tracker reads token balances and NFT holdings across Ethereum, Arbitrum, Base, and Optimism simultaneously using viem's multicall with chain-specific configurations — aggregated portfolio value with live price feeds from Chainlink and CoinGecko.
Example: viem multicall: Ethereum + 3 L2s token/NFT balances aggregated in parallel, Chainlink price feeds
B2C application replaces email/password with Sign-In With Ethereum authentication — users sign a nonce message with their wallet, server verifies the signature, issues a JWT. WalletConnect v2 enables mobile wallet users to authenticate without browser extension.
Example: SIWE: wallet signature → server JWT verification → session authentication, WalletConnect mobile support
Team and investor token vesting portal reads vesting contract state via wagmi — displays each beneficiary's vested amount, claimable tokens, and cliff/end dates. Claim button sends transaction; ethers.js formats token amounts with correct decimals across ERC-20 tokens.
Example: wagmi vesting portal: per-beneficiary schedules, claimable amounts, ERC-20 decimal formatting, transaction status
Every technology has its strengths and limitations. Here's an honest assessment to help you make an informed decision.
viem generates TypeScript types directly from contract ABIs — calling a contract function with wrong parameter types is a compile error, not a runtime failure. This eliminates entire categories of bugs common in less type-safe Ethereum SDKs.
wagmi's React hooks (useReadContract, useWriteContract, useWatchContractEvent, useAccount, useBalance) abstract wallet state management, transaction lifecycle, and block subscription into clean, composable hooks that reduce dApp component code by 60%+.
WalletConnect v2 connects 300+ wallets — MetaMask, Coinbase Wallet, Rainbow, Ledger hardware, mobile wallets — through a single integration with QR code and deep link pairing. Users aren't required to have a specific browser extension.
ethers.js is battle-tested across thousands of production dApps — deeply documented, with extensive community examples, Stack Overflow answers, and tutorial coverage. When something breaks, the solution is findable.
Arbitrum, Base, and Optimism transactions below $0.01 make transaction-heavy dApp UX economically viable in 2026. The barrier that killed most Web3 consumer apps in 2021-2022 is largely resolved for EVM L2 deployments.
RainbowKit provides a production-ready wallet connection modal with multi-wallet support, chain switching UI, and transaction confirmation flows — eliminating weeks of wallet UX development and providing a consistent, polished first impression.
Public RPC endpoints (Cloudflare, Alchemy public, Infura free) rate-limit and experience downtime. Production dApps that rely on public RPCs fail under load or during network congestion.
We configure production dApps with dedicated RPC providers (Alchemy, Infura, QuickNode) with fallback providers and automatic retry logic. For high-stakes trading interfaces, we implement multiple parallel RPC providers and route to the fastest responding one.
Multi-step transactions (approve + swap, approve + stake + claim) and wallet confirmation popups create UX friction for non-crypto-native users. Each transaction requires a separate wallet signature and on-chain confirmation wait.
We design optimistic UI patterns that show expected outcomes immediately while awaiting confirmation, implement ERC-4337 session keys to batch approvals for power users, and use permit2 (Uniswap) to eliminate separate approval transactions for supported tokens.
Applications operating across multiple chains (Ethereum + 3 L2s) must handle chain switching, bridging state, and per-chain RPC management simultaneously — significantly more complex than single-chain applications.
We use wagmi's multi-chain configuration with viem's chain registry, implement explicit chain-switching UX rather than silent fallbacks, and use cross-chain indexers (Alchemy, The Graph) to provide unified data access across chains.
User-controlled wallets mean there's no 'forgot password' — lost private keys mean permanent asset loss. Web3 applications can't recover user funds when wallets are compromised.
We implement ERC-4337 smart wallets with social recovery for consumer applications where key management complexity would exclude mainstream users. For financial applications, we provide clear key security guidance and recommend hardware wallet usage for large holdings.
Every technology has its place. Here's how Web3 compares to other popular options to help you make the right choice.
Ethereum and Web3 frontend libraries (ethers.js/viem/wagmi) are used together — Ethereum provides the smart contracts, ethers.js/viem provides the JavaScript interface to them. Choose Ethereum (vs Solana) for the chain; choose viem (vs ethers.js) for the frontend SDK. Both decisions are independent.
Choose @solana/web3.js + Anchor client + Wallet Adapter when building on Solana. Choose ethers.js/viem + wagmi + WalletConnect when building on Ethereum or EVM L2s. The library choice follows the chain choice — they're both frontend SDKs for their respective ecosystems.
Use IPFS alongside ethers.js/viem/wagmi for NFT metadata and large asset storage. The Web3 frontend layer handles blockchain interaction; IPFS handles decentralized off-chain storage. They're both needed in a complete NFT or content-heavy Web3 application.
We've built DeFi interfaces handling millions in daily volume, NFT mint sites processing thousands of transactions in minutes, and DAO governance portals used by token communities. We write Web3 frontends with the 2026 standard stack — viem + wagmi + RainbowKit — not deprecated Web3.js. We know how to handle RPC rate limits under load, design multi-step transaction UX that doesn't frustrate users, and implement cross-chain state management that doesn't introduce data consistency bugs. Our Web3 frontends are production-grade: error handling, loading states, and transaction status are first-class citizens, not afterthoughts.
We build DeFi frontends with viem + wagmi — swap interfaces, lending dashboards, yield farming portals, and liquidity management UIs with real-time contract state, transaction simulation, and gas estimation.
We develop NFT collection mint sites and marketplace interfaces with RainbowKit wallet connection, ERC-721/1155 contract interaction, IPFS metadata display, and Seaport/Blur marketplace integration.
We implement WalletConnect v2 + wagmi for multi-wallet support covering 300+ wallets, EIP-1193 provider handling, chain switching UX, and Sign-In With Ethereum authentication flows.
We generate type-safe TypeScript clients from contract ABIs using viem + wagmi — useReadContract, useWriteContract, and useWatchContractEvent hooks with automatic TypeScript inference for all contract parameters and return values.
We build multi-chain applications across Ethereum, Arbitrum, Base, and Optimism with wagmi's chain configuration, chain switching UX, per-chain contract addresses, and cross-chain bridge integrations.
We configure production RPC infrastructure with Alchemy or Infura primary providers, fallback provider chains, multicall optimization to batch on-chain reads, and caching layers for public data that doesn't change per-block.
Have questions? We've got answers. Here are the most common questions we receive about Web3.
Web3.js (the Ethereum library at web3js.org) was officially archived on March 4, 2025. Do not use it for new projects. The standard replacements: viem (TypeScript-native, 35KB, strict ABI-derived types — recommended for new projects in 2026), ethers.js v6 (most widely used, 70% of Solidity devs, comprehensive ecosystem). wagmi is the React hooks layer that can use either underneath. For existing Web3.js projects, migration to ethers.js is lower-risk (more similar API); migration to viem provides stronger TypeScript safety.
wagmi is a React hooks library for Ethereum that abstracts wallet management, contract reads/writes, and transaction lifecycle into composable hooks. Without wagmi: manually manage wallet connection state, poll for balance updates, track transaction confirmations, handle chain switching events. With wagmi: useAccount() for wallet state, useReadContract() for contract reads (auto-caches, refetches on block), useWriteContract() for transactions with built-in pending/success/error states, useWatchContractEvent() for real-time events. wagmi uses either ethers.js or viem underneath — your choice.
ethers.js v6: mature, 70% adoption, comprehensive documentation, works everywhere. Slightly larger bundle. viem: TypeScript-native (strict ABI-derived types catch errors at compile time), 35KB bundle (40% smaller than ethers.js), modern API design inspired by ethers.js but with stricter safety. viem is increasingly the default for new TypeScript-first projects; ethers.js remains valid for projects prioritizing ecosystem compatibility and documentation depth. Both work with wagmi as the React layer on top.
WalletConnect v2 is a protocol that connects dApp frontends to crypto wallets across devices — browser extension wallets (MetaMask), mobile wallets (Rainbow, Trust Wallet), and hardware wallets (Ledger). The dApp displays a QR code or deep link; the wallet scans it and establishes an encrypted WebSocket session. WalletConnect v2 uses a relay server for message routing — dApp and wallet communicate without direct network connectivity. wagmi's createConfig with WalletConnect connector handles the integration with one package installation.
RainbowKit is a React library providing a polished wallet connection modal — it displays available wallets, handles WalletConnect QR codes, shows network switching UI, and provides customizable themes. It's built on top of wagmi + viem. Use it for: any consumer dApp where wallet UX quality matters, projects that don't want to build wallet connection UI from scratch, and applications targeting non-technical users who need clear wallet selection guidance. The customization options cover most brand requirements without forking.
Sign-In With Ethereum (EIP-4361) is a standard for wallet-based authentication — users sign a nonce message with their wallet, proving ownership of an Ethereum address. Implementation: (1) Frontend requests a nonce from your backend. (2) User signs a structured SIWE message with their wallet via wagmi's useSignMessage. (3) Backend verifies the signature using ethers.js or viem's verifyMessage. (4) Backend issues a session JWT tied to the verified Ethereum address. The siwe npm library handles message construction and verification according to the EIP-4361 standard.
Transaction lifecycle has three distinct states: (1) Submitted — transaction sent to mempool, not yet mined. (2) Confirmed — transaction included in a block. (3) Failed — transaction reverted on-chain. wagmi's useWriteContract provides isPending, isSuccess, isError, and the transaction hash for each state. For UX: show optimistic state immediately (assume success for most interactions), provide clear pending feedback with block explorer link, handle rejection gracefully (user can cancel in wallet), and display revert reasons from contract custom errors.
Don't use public RPCs in production — they rate-limit aggressively and experience downtime during high network usage. Production options: Alchemy (most popular, generous free tier, comprehensive API), Infura (Ethereum's original infrastructure, reliable), QuickNode (fastest raw performance), Drpc (decentralized, multi-provider aggregation). Configure primary + fallback providers in viem's createPublicClient with multiple transport fallbacks. Use Alchemy's Enhanced APIs for token balances, NFT data, and transaction simulation to reduce RPC call volume.
Multicall batches multiple read calls into one RPC request — instead of 10 separate eth_call requests, one call returns all 10 results. Wagmi uses multicall by default for useReadContracts. Use multicall when: displaying token balances for multiple tokens simultaneously, reading state from multiple contracts (DeFi protocol TVL across pools), or loading a list of NFT token URIs. Performance impact: reduces dashboard load time from 1-2 seconds (10 serial requests) to 100-200ms (one batched request).
We offer support covering: library updates as ethers.js, viem, wagmi, and RainbowKit release breaking-change versions, wallet compatibility updates as wallet providers change their APIs, RPC provider migrations, new contract integration as protocols expand, UI updates for new chain additions, and performance monitoring for RPC call patterns that create latency. We also provide rapid incident response if contract upgrades change ABIs that break the frontend.
Still have questions?
Contact UsExplore related technologies that work seamlessly together to build powerful solutions.

We ship Web3 frontends that handle the failure modes crypto users encounter in production: RPC timeouts, stuck transactions, wallet disconnects mid-flow, and chain switches at the wrong moment. Loading states, error messages, and transaction retry flows are designed from day one — not added as an afterthought. We've debugged MetaMask gas estimation failures, WalletConnect session drops, and multicall revert propagation at 11 PM before a launch. That experience is baked into how we build, not just how we test.