Your First Ethereum Smart Contract, Step by Step

For a week, Ethereum has lived in diagrams and analogies: smart contracts, wallets, gas, dApps, Layer 2s. Today's Day 9 piece is different. It’s about you actually deploying a tiny smart contract on a real test network—without needing to know Solidity.

Before we start clicking around, a few quick definitions so we’re on the same page:

Testnet: A practice version of a blockchain that copies how mainnet works but uses separate, worthless tokens. It’s a sandbox where you can break things without losing real money.​

Testnet ETH (fake money): Ether that only exists on the testnet. It has no real‑world value and is used purely to pay gas fees while testing.​

Faucet: A website that sends you small amounts of this fake testnet ETH for free, usually after you paste your wallet address and solve a captcha or log in

1. The character: a curious Web3 beginner

This chapter is for someone who understands the words—Ethereum, smart contract, wallet—but hasn’t yet touched the thing in practice. Maybe you write, do DevRel, or hang around crypto Twitter, but deployments still feel like magic.

The goal today isn’t to turn you into a Solidity developer. It’s simply to go from “I’ve read about smart contracts” to “I’ve deployed and clicked on one myself once.”

2. The problem: theory without a feel for reality

You can read a dozen explainers about gas, transactions, and wallets and still not have the muscle memory. Until you’ve:

• Switched your wallet to a testnet and seen a real gas fee (even if it’s fake money).
• Clicked “Deploy” and waited for a transaction to land in a block.
• Pressed a button that changes on‑chain state, then another that just reads it.

Without that, the language stays abstract, and it’s hard to empathise with new users in docs, onboarding, or support.

3. The guide: a tiny “on‑chain notepad”

Instead of jumping into a complex DeFi or NFT contract, you’ll use a minimal example called SimpleStorage.

Under the hood, it does one thing:

• Stores a single number on‑chain.
• Lets anyone change it.
• Lets anyone read it.

Think of it as an on‑chain notepad with just one box, labelled “Number”. That’s enough to feel what a smart contract deployment and interaction look like end to end.

4. The plan: three clear steps

High‑level, the journey looks like this:

1. Prepare your tools

   • MetaMask wallet on the Sepolia Ethereum test network.
   • A small amount of SepoliaETH from a faucet (play money for gas).
   • The Remix IDE open in your browser.

2. Deploy the SimpleStorage contract

   • Paste the contract into Remix.
   • Compile it.
   • Deploy it to Sepolia via MetaMask.

3. Use it once

   • Call store(42) to save a number.
   • Call retrieve() to read it back and see 42 come out.

The rest of this article simply fills in those three steps with screenshots and plain language.

Step 1 – MetaMask, Sepolia, and test ETH

First, you need a wallet and some testnet fuel.

• MetaMask as your wallet
  • Install the MetaMask browser extension and create a new wallet if you haven’t already.
  • This gives you an Ethereum address—your “account number” on-chain.

• Switch to Sepolia testnet
  • In MetaMask, enable test networks in Settings and select Sepolia.

Image credit: MetaMask

• Remember: A testnet is a safe copy of Ethereum that uses free play money instead of real ETH.

  • Get free Sepolia ETH from a faucet

• Use a public Sepolia faucet (such as the Google Cloud or Infura faucet) that doesn’t require mainnet balance.

• Paste your MetaMask address (Go to MetaMask, click receive and copy the wallet address), request once, and wait until you see a small non‑zero SepoliaETH balance in MetaMask.

Once you can see Sepolia + a test ETH balance, you’re ready to actually deploy something.

Step 2 – Writing the SimpleStorage contract in Remix

Remix is a browser‑based Ethereum IDE. It gives you a code editor, compiler, and deployment panel in one place.

• Open https://remix.ethereum.org in the same browser where MetaMask is installed.

In Remix:

• In the file explorer, create a new file called SimpleStorage.sol.
• Paste in this tiny contract:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private storedNumber;

    function store(uint256 _num) public {
        storedNumber = _num;
    }

    function retrieve() public view returns (uint256) {
        return storedNumber;
    }
}

In plain language, this contract:

• Declares a box called storedNumber that can hold one whole number.
• Exposes a store function that anyone can call to change the number (this costs gas).
• Exposes a retrieve function that anyone can call to read the number (this is a free read).

You don’t have to understand Solidity syntax yet; just recognise that this is “one variable + one write button + one read button”.

Step 3 – Compiling and deploying to Sepolia

Now you turn this blueprint into a live contract on the testnet.

• Compile

  • Click the Solidity compiler icon in Remix.
  • Make sure the compiler version is a 0.8.x that matches the pragma line (for example, 0.8.30).
  • Click Compile SimpleStorage.sol and wait for the green checkmark.

• Connect Remix to MetaMask

  • Go to the Deploy & Run tab.
  • In Environment, choose Injected Provider – MetaMask.
  • Approve the connection in MetaMask and confirm the network is Sepolia.

• Deploy

  • In the Contract dropdown, pick SimpleStorage.
  • Leave gas settings on default and click Deploy (or “Deploy & Verify” if you see that).
  • MetaMask pops up with a transaction showing a gas fee in SepoliaETH. Confirm it.

A few seconds later, Remix shows SimpleStorage under Deployed Contracts, and block explorers like Blockscout or Routescan can see your contract at its own address.

Step 4 – Storing and retrieving a value

This is the moment where it clicks.

• In Remix, under Deployed Contracts, expand your SimpleStorage instance.
• In the store input, type 42 and click store.
  • MetaMask pops up again—this is another state‑changing transaction that costs gas. Confirm it.
• After that transaction mines, click retrieve.
  • Remix runs a read‑only call and shows you something like 0:uint256: 42.

You’ve just:

• Told a smart contract on Sepolia, “Remember the number 42.”
• Paid gas (in test ETH) to make that change part of the chain’s history.
• Asked the contract, “What number are you storing?” and seen it answer.

The difference between store and retrieve is the difference between writing to the global ledger and reading from it.

5. The call to action: repeat the story for yourself

At this point, you’ve done more than many people who talk about Web3 all day:

• You funded a testnet wallet.
• You compiled and deployed a real contract using Remix.
• You changed and read on‑chain state with your own clicks.

If you want to deepen it slightly, try:

• Calling store(7), then retrieve() again and noticing the value change.
• Looking up your contract address on a Sepolia block explorer and showing someone, “This is my contract.”

For this 60‑day journey, that’s enough. The point is not to master Solidity yet; it’s to make sure that when you explain smart contracts, wallets, and gas to others, you’re speaking from one small lived experience—not just from slides and analogies.