DEV Community

Abdullah Sheikh
Abdullah Sheikh

Posted on

How to Build a Blockchain-Based Voting System: A Beginner’s Step‑by‑Step Guide

#blockchain #votingsystem #tutorial #devops

Create a secure, transparent voting app on a blockchain from scratch—even if you’ve never coded one before

Before We Start: What You'll Walk Away With

By the end of this guide you’ll be able to spin up a working blockchain voting system from zero to a demo you can show to friends.

First you’ll grasp the three building blocks that keep a voting app honest: the ledger that records each ballot, the smart contract that enforces one‑vote‑per‑person rules, and the front‑end that lets voters cast their choice.

Think of it like setting up a kitchen: you need the fridge (the blockchain) to store ingredients, the recipe (the contract) to tell you what to mix, and the stove (the UI) to actually cook the meal.

  • Install a local test network, write and deploy a simple voting contract, and hook it up to a minimal web page.

  • Run through a full voting cycle—register, vote, tally—just like ordering food, confirming the order, and receiving the receipt.

  • Apply basic hardening steps and get pointers to services that can take your prototype to a production‑grade deployment.

  • Test network setup: Use ganache-cli or Hardhat to simulate Ethereum on your laptop.

  • Smart contract basics: Write a Solidity contract that tracks voter eligibility and vote counts.

  • Front‑end glue: Connect the contract with web3.js or ethers.js to build a simple HTML form.

Security isn’t an afterthought; you’ll learn to lock down private keys, validate inputs, and avoid common pitfalls like replay attacks.

When the tutorial is over you’ll have a sandboxed blockchain voting system you can experiment with, plus a roadmap for scaling it up when you’re ready to go live.

Ready to roll up your sleeves?

What Blockchain Voting Actually Is (No Jargon)

Blockchain voting records each ballot as an unchangeable transaction on a shared ledger, so anyone can see the tally but nobody can rewrite a vote after it’s been cast. The ledger lives on many computers at once, which means there’s no single point that can be hacked or corrupted without the whole network noticing.

Imagine a public Google Sheet that a whole town can edit. Each time you enter a vote, the sheet saves a new row instantly. Once saved, that row is locked—no one can change the number in that cell without every viewer seeing a red flag. That’s the essence of a blockchain voting system: every vote is a permanent entry, and the community of nodes acts as the “viewers” who keep the record honest.

The 3 Mistakes Everyone Makes With Blockchain Voting

Most first‑time attempts trip over the same three pitfalls.

  • Over‑engineering the consensus algorithm. You could spend weeks building a custom proof‑of‑stake, but a public testnet like Goerli already handles that. It’s like trying to bake sourdough from scratch when a ready‑made pizza dough works just fine.

  • Storing voter identities in plain text on‑chain. Putting names or IDs directly into a transaction is a privacy nightmare. Think of it as writing your home address on a postcard that anyone can read—once it’s out there, you can’t take it back.

  • Skipping proper gas‑limit testing. Deploying with a guess‑work limit leads to failed votes when the network spikes. It’s similar to packing a suitcase without checking the airline’s weight rules; you’ll end up paying extra or leaving items behind.

  • Tool tip: Use hardhat or truffle scripts to simulate gas usage before the live launch.

Cheat sheet:

  • Consensus: Stick to an existing testnet.
  • Privacy: Hash or encrypt IDs.
  • Gas: Run hardhat node --fork and monitor tx.gasUsed.

Avoid these missteps, and your blockchain voting system will stay functional, private, and scalable.

How to Build a Blockchain Voting System: Step‑by‑Step

Let’s get your blockchain voting system up and running, one concrete action after another.

  • Pick a blockchain. For a quick start, use the Ethereum Goerli testnet. Think of it like choosing a sandbox playground where you can experiment without spending real money.

Set up the toolchain. Install Node.js, then grab Hardhat and the MetaMask browser extension.

  • Run npm install --save-dev hardhat in a new folder.

  • Add the MetaMask extension and switch it to Goerli.

  • Write the smart contract. Create Ballot.sol with three functions: createBallot, addCandidate, and vote. The contract stores only encrypted votes, similar to how a restaurant records orders without exposing the recipe.

pragma solidity ^0.8.0;

contract Ballot {
    struct Candidate { string name; uint256 votes; }
    mapping(uint256 => Candidate) public candidates;
    mapping(address => bool) public hasVoted;
    uint256 public candidateCount;

    function addCandidate(string memory _name) public {
        candidates[candidateCount++] = Candidate(_name, 0);
    }

    function vote(uint256 _id, bytes32 _voteHash) public {
        require(!hasVoted[msg.sender], "Already voted");
        require(_id **Build a minimal front‑end.** Scaffold a React app and connect with `ethers.js`.
- Install `npm i ethers`.
- Use `window.ethereum.request({ method: 'eth_requestAccounts' })` to prompt MetaMask.

- **Test the voting flow.** Open two Chrome profiles, each with its own MetaMask account. Cast votes and watch the UI update, just as you’d check two separate receipts after ordering coffee.

- **Add basic privacy.** Hash voter IDs off‑chain (e.g., `keccak256(abi.encodePacked(voterId))`) and store only the hash on‑chain. This mirrors the way a hotel keeps a guest’s signature but not the full ID visible to everyone.

**Document everything.** Write a concise README that lists:
- **Prerequisites:** Node, Hardhat, MetaMask.
- **Deploy steps:** command line sequence.
- **How to run the front‑end:** `npm start`.

Future contributors will thank you when they need to scale the system.

Now you have a working prototype of a blockchain voting system—time to experiment further.

## A Real Example: Campus Student Council Election

Maya, the tech lead of her campus’ student council, decides to run a quick, transparent election using the blockchain voting system she just built.

- She creates the candidate list in `candidates.json` – “Alex”, “Jordan”, and “Sam”. Think of it like setting up a menu before ordering food.

- She deploys the smart contract to the Goerli testnet with `npx hardhat run scripts/deploy.js --network goerli`. Goerli works like Google Maps’ “preview mode” – safe to test without real money.

- In the React front‑end, Maya swaps the network ID to “goerli” and points the UI to the new contract address.

- She shares the app’s URL (`https://mycampus-vote.netlify.app`) on the campus Slack channel, adding a short note: “Vote here, your ballot is on the blockchain.”

- After the voting window closes, Maya opens Etherscan’s Goerli explorer, pastes the contract address, and clicks “View Transactions”. Each vote appears as a transaction receipt, just like receipts you get after buying coffee.

- **Verify quickly:** filter by the `VoteCast` event to see every ballot.

- **Show transparency:** copy the filtered Etherscan link and pin it in Slack so anyone can audit the tally.

- **Finalize count:** run the `getResults()` function in the contract UI; the numbers match the on‑chain receipts.

Maya’s simple run‑through proves that a blockchain voting system can be set up, shared, and verified without a PhD in cryptography.

## The Tools That Make This Easier

Think of building a blockchain voting system like assembling a DIY pizza: you need the right kitchen tools before the dough even hits the oven.

- **Hardhat (2025)** – Your local sandbox. It spins up a throw‑away Ethereum network, compiles contracts, and runs automated tests. It’s like a kitchen prep station where you can experiment without burning the real thing.

- **Remix IDE** – The browser‑based skillet for Solidity. Write, compile, and debug in seconds, then push the bytecode straight to Hardhat or a testnet. It feels like ordering a custom sandwich online and seeing the ingredients appear instantly.

- **MetaMask Flask** – A test‑net wallet that lets you add any RPC endpoint you like. Use it to simulate voter wallets, just as you would swap out a credit card for a prepaid gift card when testing purchases.

- **Vercel (free tier)** – Deploy your React front‑end with one click, and it automatically serves it over HTTPS. Think of it as a luggage‑locker that ships your suitcase (the UI) to any destination without extra fees.

- **The Graph (hosted service)** – Optional indexer for audit logs. It creates a searchable view of every vote, similar to how Google Maps tags every road so you can find the fastest route later.

Putting these pieces together means you spend less time hunting for missing bolts and more time polishing the voting experience.

## Quick Reference: Blockchain Voting Cheat Sheet

Grab a pen—here’s the whole process you can tick off in a single coffee break.

- Pick a testnet and treat it like a practice kitchen: **Goerli** lets you experiment without real money.

- Set up your tools the way you’d install a coffee maker: install `Node`, `Hardhat`, and add `MetaMask` to your browser.

- Write the ballot contract—think of it as a recipe: `createBallot()`, `vote()`, `tally()` are the ingredients.

Deploy with one command, just like sending an order:
Enter fullscreen mode Exit fullscreen mode


bash
npx hardhat run --network goerli scripts/deploy.js




- Build the UI the way you’d design a restaurant menu: React shows options, `ethers.js` passes the order. For example, *Alice* logs in, sees the candidate list, clicks “Vote”, and the transaction fires.

- Test like a blind taste test: use several MetaMask accounts, hash voter IDs before sending to keep anonymity.

- Push the front‑end to Vercel—think of it as moving from a kitchen counter to a storefront—then share the live link.

- Verify the contract on Etherscan, and hook The Graph for a transparent audit trail, just like checking receipts after dinner.

- **Choose platform → Goerli testnet** – safe sandbox for early runs.

- **Install Node, Hardhat, MetaMask** – your development toolkit.

- **Write Solidity ballot contract** – core logic for create, vote, tally.

- **Deploy with `npx hardhat run --network goerli`** – one‑click launch.

- **Build React UI + ethers.js** – user‑friendly front end.

- **Test with multiple accounts, hash voter IDs** – ensure privacy and correctness.

- **Deploy UI on Vercel, share link** – instant public access.

- **Verify on Etherscan, use The Graph for audit** – full transparency.

Follow this cheat sheet and your blockchain voting system will be ready to demo before the next lunch break.

## What to Do Next

Start by getting your hands dirty with the code you just read.

- **Fork the GitHub repo** and run the demo locally. It’s like ordering a sample dish before committing to a full‑course meal. Clone the repo, `npm install`, then `npm run dev`. If the vote UI pops up, you’re ready to experiment.

- **Add role‑based access control** using OpenZeppelin’s `AccessControl`. Think of it as giving each team member a different key on a shared locker. Install the package, extend your contract with `AccessControl`, and define roles such as `ADMIN_ROLE` and `VOTER_ROLE`. This step tightens security without rewriting the whole app.

- **Migrate to a production‑grade layer‑2** like Polygon zkEVM and plug in zero‑knowledge proofs for true voter anonymity. Imagine moving from a paper map to a GPS that hides your exact route. Deploy your contract to the zkEVM testnet, then integrate a ZK library (e.g., `snarkjs`) to generate proofs that a vote is valid without revealing the voter’s identity.

**Tools & tips:**

- GitHub fork button → quick copy.

- OpenZeppelin docs → ready‑made role templates.

- Polygon docs → one‑click deployment scripts.

What part of building a blockchain voting app are you most excited to tackle?

---

---

## About the Author

**[Abdullah Sheikh](https://abdullah-sheikh.com/)** is the Founder & CEO at [Exteed](https://exteed.com/), where he leads a team of skilled developers specializing in [Web2](https://abdullah-sheikh.com/) and [Web3 applications](https://abdullah-sheikh.com/), [Custom Smart Contracts](https://abdullah-sheikh.com/), and [Blockchain solutions](https://abdullah-sheikh.com/).

With 6+ years of experience, Abdullah has built [CRMs](https://abdullah-sheikh.com/), [Crypto Wallets](https://abdullah-sheikh.com/), [DeFi Exchanges](https://abdullah-sheikh.com/), [E-Commerce Stores](https://abdullah-sheikh.com/), [HIPAA Compliant EMR Systems](https://abdullah-sheikh.com/), and [AI-powered systems](https://abdullah-sheikh.com/) that drive business efficiency and innovation.

His expertise spans [Blockchain](https://abdullah-sheikh.com/), [Crypto & Tokenomics](https://abdullah-sheikh.com/), [Artificial Intelligence](https://abdullah-sheikh.com/), and [Web Applications](https://abdullah-sheikh.com/); building reliable and smooth web apps that fit the client’s goals and requirements.

📧 [info@abdullah-sheikh.com](mailto:info@abdullah-sheikh.com) · 🔗 [LinkedIn](https://www.linkedin.com/in/-abdullah-sheikh/) · 🌐 [abdullah-sheikh.com](https://abdullah-sheikh.com/)
Enter fullscreen mode Exit fullscreen mode

Top comments (0)