Case study · Civic technology
A voting tool that proves its own neutrality
- SvelteKit
- TypeScript
- PWA
- Cloudflare Pages
- Capacitor
- Playwright
- axe-core
✓ Verified Review“We built how2vote.au to be trusted by people who don't trust it. That meant deriving every match from the public record - the votes members of parliament actually cast - and making the method reproducible: a pure scoring engine with golden tests, a checksummed dataset, an open-source codebase, and an interface with no party colour anywhere. Neutrality you can check, not just take on faith.”
Propositions per session
Server-side scoring
Colour in the interface
Licence
The challenge
Voter tools are easy to distrust: recommendations often rest on self-reported positions, and colour or design can quietly signal a partisan lean. The goal was a tool whose neutrality and method a sceptical voter could verify for themselves - and that works on election day with no network connection.
What we built
A non-partisan comparison tool that derives every match from parties' recorded parliamentary votes, never ranks or recommends a preference, exposes its method end to end as open source, and runs entirely on-device as an offline-first progressive web app.
- Pure, deterministic scoring engine with golden methodology tests
- Data pipeline compiling a checksummed, ODbL-attributed dataset from They Vote For You
- Offline-first SvelteKit PWA, packaged unchanged as iOS and Android shells
- CI integrity gates: neutrality lint, deterministic-rebuild check, axe-core accessibility
- Open-source release under AGPL-3.0 with DCO sign-off
The stack
A TypeScript monorepo: a pure, dependency-free scoring engine with the specification's worked examples as immutable golden tests; a data pipeline compiling a deterministic, checksummed, ODbL-attributed dataset from They Vote For You; a SvelteKit (adapter-static) PWA on Cloudflare Pages; and Capacitor shells that package the identical build for iOS and Android.
The outcome
how2vote.au ships as a verifiable, offline-capable voter tool: every proposition links to the parliamentary divisions behind it, the scoring engine is public and reproducible, and the dataset is deterministic and checksummed. Because neutrality is enforced in CI rather than promised in copy - and the code is open for anyone to audit - the tool can be trusted by people who start out not trusting it.
Where it went next
The dataset refreshes from They Vote For You through an automated, PR-gated pipeline, and official ballots are ingested when nominations are declared - so the same engine and interface carry forward to each federal election without a rebuild.
This case study describes a live civic product designed and built by National Digital. Figures describe the shipped system and its published specification.
Key Takeaways
Engineering trust into a civic product
- Revealed preference beats self-reported position: matches derive from votes MPs actually cast.Critical
Parties are compared on divisions recorded in parliament and sourced from They Vote For You, with every proposition linking back to the divisions behind it. A sceptical user can follow any single match claim to the primary public record.
- The tool compares and the user decides - nothing is ranked and no preference is recommended.Critical
Candidates appear in official ballot order and the user authors their own voting plan. Declining to rank is what keeps the tool a reference rather than a recommendation engine, which is the difference between informing a vote and directing one.
- A guarantee enforced in CI is worth more than a guarantee written in a policy.Critical
A neutrality lint over the built CSS fails the build on any hue, a deterministic-rebuild check pins the dataset, and axe-core gates accessibility. Each promise a user has to take on faith is instead a test that must pass before release.
- On-device scoring removes the need to be trusted with the data at all.Important
With no account, no server-side scoring and share state confined to the URL fragment, there is no endpoint that could log answers. Privacy comes from the architecture rather than from a commitment about how collected data will be handled.
- Open source under AGPL-3.0 turns the method into something auditable and rebuildable.Important
Engine, data pipeline and application are all public. Anyone disputing a result can inspect the scoring rules, rebuild the checksummed dataset from source and confirm the output, which is a materially stronger claim than publishing a methodology summary.
how2vote.au is built for voters who start out sceptical. Every match comes from the parliamentary record rather than campaign claims, the method is open source and reproducible, and neutrality is enforced in CI rather than promised in copy.
Questions decision-makers ask about this build
Does how2vote.au tell you who to vote for?
How can a voting tool prove it is neutral rather than just claim it?
Why does the interface have no colour at all?
What happens to a user's answers?
Why build an election tool offline-first?
What stops the data going stale between elections?
What's next
Building something that must be trusted?
how2vote.au earns trust by construction: deterministic builds, CI-enforced guarantees and an auditable method. If your product carries the same burden of proof, see how we approach custom web applications and technology selection, part of our wider custom software development work.