---
title: Step-by-Step Guide: Deploy Your First Solidity Smart Contract on the Polygon Testnet
siteUrl: https://logzly.com/chaincraft
author: chaincraft (ChainCraft)
date: 2026-06-16T15:22:09.575398
tags: [blockchain, solidity, polygon]
url: https://logzly.com/chaincraft/step-by-step-guide-deploy-your-first-solidity-smart-contract-on-the-polygon-testnet
---


**Disclosure: We are reader supported, and earn affiliate commissions when you buy through us.**


If you’ve been watching the buzz around Polygon for a while, you’ve probably wondered why everyone keeps talking about “testnets.” The short answer: they’re the safe playground where you can break things without losing real money. In this post I’ll walk you through deploying a simple Solidity contract on Polygon’s Mumbai testnet, from setting up the tools to seeing your contract live. No fluff, just the steps that actually work.

## Why Use a Testnet First?

Think of a testnet like a sandbox for kids. You can build a castle, knock it down, and start over without any real‑world consequences. Polygon’s testnet (called Mumbai) gives you free test MATIC, so you can experiment with gas fees, wallet interactions, and contract upgrades without spending a dime. It’s also the place most tutorials expect you to start, such as our guide on [deploying an ERC‑20 token on Polygon](/chaincraft/deploy-your-first-erc20-token-on-polygon-with-hardhat-a-complete-developer-guide), so you’ll find plenty of community help.

## Prerequisites

Before we dive in, make sure you have these basics covered:

1. **Node.js (v14 or later)** – needed for the development tools.  
2. **npm or yarn** – package manager of your choice.  
3. **MetaMask** – a browser wallet that can connect to Mumbai.  
4. **A text editor** – VS Code works great, but any editor will do.  

If any of these sound unfamiliar, pause and get them set up first. The rest of the guide assumes they’re ready.

## 1. Set Up Your Project Folder

Open a terminal and run:

```
mkdir my-polygon-contract
cd my-polygon-contract
npm init -y
```

This creates a new folder and a basic `package.json`. Next, install Hardhat, a popular Ethereum development environment that works perfectly with Polygon.

```
npm install --save-dev hardhat
npx hardhat
```

When Hardhat asks what you want to do, choose **Create a basic sample project**. It will scaffold a few files, including a sample contract called `Greeter.sol`.

## 2. Install Polygon‑Specific Packages

Hardhat needs a plugin to talk to Polygon networks. Install the following:

```
npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-etherscan
```

Now edit `hardhat.config.js` to add the Mumbai network. Replace the existing content with:

```javascript
require("@nomiclabs/hardhat-ethers");
require("@nomiclabs/hardhat-etherscan");

module.exports = {
  solidity: "0.8.19",
  networks: {
    mumbai: {
      url: "https://rpc-mumbai.maticvigil.com",
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    // PolygonScan API key – you can get one for free at polygonscan.com
    apiKey: process.env.POLYGONSCAN_API_KEY
  }
};
```

Two environment variables are referenced: `PRIVATE_KEY` and `POLYGONSCAN_API_KEY`. We’ll set those next.

## 3. Get Test MATIC and a Private Key

1. Open MetaMask, click the network dropdown, and select **Add Network**. Fill in the Mumbai details (you can find them on the official Polygon docs).  
2. Once you’re on Mumbai, go to the faucet at https://faucet.polygon.technology/. Paste your wallet address and request some test MATIC.  
3. Export your private key from MetaMask (Settings → Security & Privacy → Export Private Key). **Never share this key**; it’s only for the testnet.  

Create a `.env` file in your project root:

```
PRIVATE_KEY=your_private_key_without_0x_prefix
POLYGONSCAN_API_KEY=your_polygonscan_api_key
```

Make sure to add `.env` to `.gitignore` so you don’t accidentally commit it.

## 4. Write a Simple Contract

Delete the sample `Greeter.sol` and create a new file `SimpleStorage.sol` in `contracts/`:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract SimpleStorage {
    uint256 public storedValue;

    event ValueChanged(uint256 newValue);

    function set(uint256 _value) public {
        storedValue = _value;
        emit ValueChanged(_value);
    }

    function get() public view returns (uint256) {
        return storedValue;
    }
}
```

This contract lets anyone store a number and read it back. It also emits an event whenever the value changes—handy for front‑end apps.

## 5. Create a Deployment Script

In the `scripts/` folder, replace `sample-script.js` with `deploy.js`:

```javascript
async function main() {
  const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
  console.log("Deploying SimpleStorage...");
  const simpleStorage = await SimpleStorage.deploy();
  await simpleStorage.deployed();
  console.log("SimpleStorage deployed to:", simpleStorage.address);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });
```

## 6. Deploy to Mumbai

Run the deployment command:

```
npx hardhat run scripts/deploy.js --network mumbai
```

You should see output like:

```
Deploying SimpleStorage...
SimpleStorage deployed to: 0xAbc123... (your contract address)
```

If you get a “insufficient funds” error, double‑check that your test MATIC arrived and that the private key in `.env` matches the wallet you funded.

## 7. Verify the Contract on PolygonScan

Verification makes the source code visible on PolygonScan, which is useful for debugging and for anyone who wants to read your contract. Run:

```
npx hardhat verify --network mumbai <contract_address>
```

Replace `<contract_address>` with the address printed in the previous step. If everything is set up correctly, PolygonScan will show your Solidity code within a few minutes.

## 8. Interact with the Contract

You can test the contract directly from the Hardhat console:

```
npx hardhat console --network mumbai
```

Inside the console:

```javascript
const addr = "0xAbc123..."; // your contract address
const SimpleStorage = await ethers.getContractAt("SimpleStorage", addr);
await SimpleStorage.set(42);
let val = await SimpleStorage.get();
console.log(val.toString()); // should print 42
```

Alternatively, open PolygonScan, paste your contract address, and use the **Read Contract** and **Write Contract** tabs. You’ll need to connect MetaMask to sign the transaction.

## 9. What’s Next?

Now that you have a working contract on Mumbai, you can:

* Hook it up to a React front‑end using ethers.js.  
* Add [access control](https://www.amazon.com/s?k=access+control&tag=organizationtip101-20) (e.g., only the owner can set the value).  
* Deploy the same contract to Polygon’s mainnet once you’re comfortable.  

If you want a deeper dive, check out our walkthrough on building a [full‑stack decentralized application with Hardhat, React, and WalletConnect](/chaincraft/how-to-build-a-fullstack-decentralized-application-with-hardhat-react-and-walletconnect). Remember, the testnet is a learning space. Break things, ask questions, and when you’re ready, move to mainnet with confidence.

#hashtags