Rob's Rules of Order on the Blockchain

Most on-chain voting tools are too simplistic for real organizations.

A basic wallet poll can tell you how many people voted yes or no, but it does not reflect how serious groups actually make decisions. In the real world, someone introduces a motion, another member seconds it, the chair opens the floor for voting, members vote yes, no, or abstain, and the result is formally finalized.

That gap was the inspiration for this project.

I wanted to build a governance tool that feels closer to how real organizations already operate, while still preserving the transparency and auditability of blockchain systems. For Fort Worth DAO and other North Texas organizations, this kind of structure matters. If communities are going to coordinate grants, initiatives, working groups, and real economic activity, the governance layer needs to be understandable, enforceable, and public.

What it does

Rob's Rules on the Blockchain is a parliamentary voting system deployed on Ethereum Sepolia.

Instead of a raw yes-or-no poll, it supports a more structured process:

• a member creates a proposal
• another member seconds the motion
• the chair opens voting
• eligible members vote yes, no, or abstain
• the proposal is finalized on-chain
• anyone can verify the result through the app and the blockchain

The project includes:

• a voter portal
• a chair dashboard
• a proposal verification page
• a live smart contract on Sepolia

How we built it

The project was built as a full-stack web3 application with:

• Solidity for the voting contract
• Hardhat for compilation, deployment, and testing
• Next.js 16 and TypeScript for the frontend
• MetaMask for wallet interaction
• Ethereum Sepolia for live on-chain execution
• Vercel for deployment

The smart contract models a Robert's Rules style flow by handling proposal creation, seconding, voting windows, vote tallies, and proposal finalization. The frontend separates the experience into three clear surfaces: a landing page, a voter portal, and a chair dashboard, plus a verification page for inspecting results.

Challenges we ran into

The hardest challenge was staying honest about scope.

There is always a temptation in hackathon projects to overclaim what exists, especially in web3. I chose to focus on a smaller system that actually works end to end instead of stuffing in half-finished features that would make the demo less credible.

Another challenge was translating a parliamentary process into a clean smart contract flow. Robert's Rules is designed for human organizations, not blockchains, so a big part of the work was deciding which parts of the process mattered most for a practical demo and how to represent them clearly on-chain.

The frontend also had to make governance legible. If a judge cannot understand what state a proposal is in, the product fails, even if the contract works perfectly.

What we learned

This project reinforced that good governance software is not just about contracts. It is also about clarity, process design, and trust.

We learned that blockchain is strongest when it is used for transparent recordkeeping and verifiable outcomes, but the user experience still has to match how humans naturally make decisions. We also learned that a smaller, truthful prototype is stronger than a more ambitious but unstable demo.

What's next

Next steps include:

• expanding proposal and amendment handling
• improving role and eligibility controls
• refining the verification experience
• exploring more advanced governance workflows for real-world organizations

The long-term goal is to make structured, auditable governance easier for communities and organizations coordinating real work.

Built With

• ethereum-sepolia
• hardhat
• metamask
• next.js-16
• react
• solidity
• typescript
• vercel