EBEduardo Belluti LogoLinkedIn

Building BikeReg on Base Sepolia: Wallets, Faucets, Networks, and the Reality of Web3 Development

BikeReg started as a simple experiment: build a registration app that runs onchain instead of using a traditional backend. The goal was not to ship a production dapp, but to understand the real workflow required to deploy smart contracts, connect wallets, fund accounts, and interact with a blockchain network.

You can explore the live project at bikereg.vercel.app.

The Mission: Learn the Full Web3 Flow

Most tutorials show how to write a contract, but skip the infrastructure needed to actually run it. BikeReg was built to understand the entire lifecycle of a Web3 application.

  • Connect a wallet
  • Deploy a contract
  • Send transactions
  • Pay gas fees
  • Verify on explorer
  • Run on a real network

The objective was clarity, not scale. Every step needed to be visible and understood.

The Core Architecture

A Web3 app requires multiple systems working together. Unlike a normal web app, there is no single backend server. Instead, the flow looks like this:

  • Wallet signs the transaction
  • RPC sends the request
  • Network validates the transaction
  • Contract executes logic
  • Explorer confirms the result

If any part of this chain is missing, deployment fails.

Tech Stack

BikeReg uses a modern frontend + EVM stack.

  • Next.js
  • React
  • Tailwind / ShadCN UI
  • Solidity
  • Hardhat / Foundry
  • MetaMask wallet
  • Base Sepolia testnet
  • Alchemy / Base RPC

Wallet, Network, and Contract Relationship

The wallet is the identity in Web3. It signs every transaction and pays for gas. The network is the blockchain where the transaction runs. The contract is the code stored onchain.

When deploying, the wallet sends a transaction to the network, and the network stores the contract permanently.

  • Wallet = signer
  • Network = execution environment
  • Contract = onchain logic

This relationship is simple conceptually, but strict in practice. If the wallet is not funded, the contract cannot deploy.

Why Use a Testnet Instead of Mainnet

Deploying to mainnet requires real ETH and real gas fees. During development this is unnecessary and risky, so testnets exist to simulate production behavior without real cost.

  • Mainnet uses real money
  • Testnet uses free tokens
  • Both behave the same

BikeReg uses Base Sepolia, a test network compatible with the Base L2 ecosystem.

Why Base Sepolia

Several testnets exist, but Base Sepolia was chosen because it is fast, cheap, and supported by modern tooling.

  • EVM compatible
  • Works with Coinbase / Base stack
  • Supported by Alchemy
  • Safe for deployment testing

This made it ideal for learning the deployment workflow without risking real funds.

Why the Wallet Needed Funding

Every transaction requires gas. Even on testnet, gas must be paid using the network token. If the wallet balance is zero, the network rejects the transaction.

This is why deployment failed at first — the deployer wallet had no Base Sepolia ETH.

What a Faucet Does

A faucet is a service that sends free test tokens to a wallet. These tokens have no real value, but allow developers to deploy contracts and test transactions.

  • Copy wallet address
  • Paste into faucet
  • Receive test ETH
  • Use ETH to pay gas

Faucets often require wallet history or verification to prevent abuse, which is why new wallets sometimes cannot receive funds immediately.

Deployment Flow Used in BikeReg

  • Create wallet
  • Add Base Sepolia network
  • Fund wallet using faucet
  • Check balance
  • Run deploy script
  • Verify on explorer

Once the wallet had test ETH, the deployment succeeded without changing any code.

Lessons Learned

Building BikeReg made it clear that Web3 development is less about UI and more about infrastructure. Wallets, RPC providers, networks, and funding must all be configured correctly before a single contract can run.

  • Wallet = identity and ownership
  • Gas is always required
  • Testnets are essential
  • Faucets are part of the workflow
  • Deployment depends on balance

Understanding this flow was the real goal of the project.

Closing Thoughts

BikeReg started as a small prototype but became a practical exercise in understanding how blockchain applications actually run. The relationship between wallet, faucet, network, and contract is simple in theory, but very strict in practice.

Exploring this workflow on Base Sepolia made it possible to learn the full stack safely, without spending real funds, and without hiding the complexity behind abstractions.

Explore the project at bikereg.vercel.app.