Building a Zero-Knowledge Ballot Checker for Local Elections

Trust in elections breaks the second you can't check your own vote. Last month, auditing an open-source voting tool, my engineering team hit a wall. We needed voters to prove their ballots counted without letting anyone—not even root admins—link a vote to a person. Better database encryption didn't fix it. Zero-knowledge cryptography did.

Most civic tech uses centralized ledgers or simple hashes. A hash proves a record existed, but brute-force attacks expose the underlying data. Zero-knowledge proofs let a prover convince a verifier a statement is true without leaking anything else. For our voting app, the statement is straightforward. My ballot sits in the final tally and my token is valid, but my identity and candidate choice stay hidden.

We tested this with an arithmetic circuit in a mock verification loop. The workflow splits into two parts. First, the voter's local device generates a witness with secret inputs like their private key and candidate ID. The client runs a proving algorithm, spitting out a cryptographic proof file that acts as a math-backed guarantee. Second, the public bulletin board verifies that proof. If the math checks out, the system counts the vote without ever looking at the ballot itself.

Here is what the verification logic looks like in Node.js using a standard verification key. We pass the public inputs, like the election root hash and nullifiers, alongside the proof payload.

const { verify } = require('snarkjs');
const fs = require('fs');

async function verifyBallotProof() {
 const vKey = JSON.parse(fs.readFileSync('verification_key.json'));
 const proof = JSON.parse(fs.readFileSync('ballot_proof.json'));
 const publicSignals = JSON.parse(fs.readFileSync('public_signals.json'));

 const isValid = await verify(vKey, publicSignals, proof);

 if (isValid) {
 console.log('Ballot verified successfully without exposing voter identity.');
 } else {
 console.error('Verification failed. Invalid proof or tampered signal.');
 }
}

verifyBallotProof();

The math looks great on paper, but municipal deployments are brutal. Circuit compilation takes forever, low-end mobile browsers run out of memory generating proofs, and a botched trusted setup ceremony wrecks the whole security model. If we want cryptography to replace blind trust in election hardware, these circuits need to run smoothly on cheap phones.

Code alone won't fix institutional distrust. Still, verifiable systems give communities the tools to demand accountability. When citizens can mathematically prove their election works, transparency stops being a campaign slogan and becomes an engineering standard.