Governance Interface Design is Broken
300,000 token holders. 5% participation. The interface is the problem.
Uniswap has over 300,000 token holders. Their typical governance proposal gets participation from around 5-10% of voting power. Most of that is a handful of large delegates.
This isn’t apathy. It’s design failure.
We’ve spent years optimizing trading interfaces down to the millisecond. Swap UX is genuinely good now. But governance? We’re still showing people a wall of text, a date, and two buttons. Then we wonder why nobody votes.
The interfaces we’ve built for collective decision-making are so bad they’re effectively excluding most token holders from participation. And that has consequences beyond low voter turnout.
The Cognitive Load Problem
Open any major protocol’s governance page right now. Compound. Aave. Uniswap. Look at an active proposal.
What do you see? A title that’s often technical jargon. A wall of text that assumes deep context. Maybe some code. A vote button. That’s it.
Now put yourself in the shoes of someone who holds the token but isn’t a full-time DeFi participant. They want to be a responsible token holder. They open the governance page and see:
“Proposal 127: Adjust Risk Parameters for WBTC-E Collateral Factor and Liquidation Threshold with Updated Price Feed Oracle Integration”
Followed by 2,000 words of technical specification.
What are they supposed to do with this? They’d need to understand the current parameters, why they’re being changed, what the risks are of changing them, what the risks are of not changing them, and how this fits into broader protocol strategy.
That’s hours of research for a single proposal. Multiply by the 5-10 proposals per month an active protocol might have. It’s a part-time job.
So they don’t vote. Not because they don’t care. Because the interface has made participation require expertise they don’t have and time they can’t spend.
Information Hierarchy is Backwards
Current governance interfaces present information in exactly the wrong order.
They lead with the technical specification. The “what” in granular detail. This is the last thing most voters need to see first.
Here’s what voters actually need, in order:
The context. What problem is this solving? What’s the current state? Why does this need to change now?
The stakes. What happens if this passes? What happens if it doesn’t? What’s the risk profile in either direction?
The positions. Who supports this and why? Who opposes it and why? What do trusted delegates think?
The details. The actual specification, for those who want to verify.
Almost every governance interface inverts this hierarchy. They dump the specification first and make voters work backwards to understand why it matters.
The fix isn’t complicated. It’s just information design. Lead with a one-paragraph summary a non-expert can understand. Show the stakes clearly. Make delegate positions visible. Put the technical spec in an expandable section for those who want it.
Delegation is Broken Too
Delegation should solve the expertise problem. Don’t have time to research every proposal? Delegate your voting power to someone who does.
In theory this is elegant. In practice the delegation experience is terrible.
Finding a delegate requires manually researching individuals across Twitter, forums, and past voting records. There’s no standardized delegate profile. No easy way to compare delegates’ positions or track records. No clarity on what delegating actually means.
Most interfaces show you a list of addresses with voting power. Maybe ENS names if you’re lucky. That’s not enough information to make an informed delegation decision.
What delegation interfaces should have:
Delegate profiles with context. Who is this person or entity? What’s their background? What do they care about?
Voting history with rationale. How have they voted on past proposals? More importantly, why? Did their reasoning make sense?
Position statements. What’s their general philosophy on protocol governance? Where do they stand on recurring debates?
Alignment matching. Based on your past votes or stated preferences, which delegates align with how you’d likely vote?
Easy re-delegation. If your delegate starts voting against your interests, switching should take seconds.
Gitcoin has experimented with delegate statements. Some DAOs have built better delegate directories. But these are exceptions. Most delegation experiences are still “here’s a list of addresses, good luck.”
The Mobile Problem
Here’s a stat that should concern every protocol: the vast majority of governance participation happens on desktop.
That’s not because token holders prefer desktop. It’s because governance interfaces are barely functional on mobile. Tiny text. Horizontal scrolling. Proposal pages that require pinch-zooming to read.
Meanwhile, trading interfaces are mobile-first. You can swap tokens perfectly well on your phone. But voting on how those tokens’ protocol is governed? Good luck.
This matters because mobile-only users are effectively disenfranchised. They hold tokens. They technically have voting rights. But the interface excludes them from practical participation.
Mobile governance should be designed as a first-class experience:
Scannable proposal cards instead of text walls. Title, summary, stakes, deadline, your delegate’s position.
One-tap voting for straightforward proposals. If your trusted delegate has already voted, following their lead should be frictionless.
Push notifications for proposals that match your interests or require attention. Most people don’t check governance pages proactively.
Quick context without leaving the app. Enough information to vote confidently without opening a browser.
Snapshot has made progress here. Their mobile experience is better than most. But it’s still not good enough to drive participation from casual token holders.
The Timing Problem
Most proposals have voting windows of a few days to a week. In the context of how people actually use apps, that’s both too long and too short.
Too long because it creates procrastination. “I’ll look at this later” becomes never.
Too short because if you miss the window, you’re locked out entirely. No partial participation. No late votes. You either catch it in time or you don’t.
Better approaches:
Voting windows that match user behavior. Weekend proposals get different timing than weekday proposals. Major decisions get longer windows with staged reminders.
Temperature checks before formal votes. Let people signal their position early, even if they haven’t done full research yet. This surfaces community sentiment and flags controversial proposals.
Notification cadence that doesn’t spam but doesn’t forget. A reminder when a proposal goes live. Another when you’re 24 hours from deadline. Not ten messages cluttering your notifications.
What Good Governance UX Could Look Like
Imagine opening a governance app and seeing:
Your participation score. How active you’ve been. How your votes compared to outcomes.
A personalized feed of proposals. Filtered by relevance to your holdings and interests. Sorted by deadline urgency.
Each proposal as a card. Clear summary at the top. Visual indicator of controversy level. Your delegate’s position if you’ve delegated. Estimated impact in terms you understand.
One tap to follow your delegate. Two taps to vote independently. Expandable detail for those who want to dig deeper.
Delegate recommendations based on your voting history. Easy comparison of delegate positions on current proposals.
Mobile-first. Push notifications. The whole experience designed around how people actually behave with apps.
None of this is technically difficult. It’s just not prioritized.
The Participation Incentive Question
Some protocols have tried token incentives for voting. Small rewards for participation. This gooses the numbers but doesn’t solve the underlying problem.
People voting just to claim rewards without understanding what they’re voting on is arguably worse than low participation. It’s the appearance of decentralization without the substance.
The better incentive is making governance feel meaningful. Show voters the impact of their participation. Connect proposal outcomes to protocol changes they can see. Make them feel like their vote mattered, not just that they completed a task for tokens.
Governance participation is a design problem, not an apathy problem.
We solved trading UX. We can solve this too. We just have to decide it matters.
Thank you :)
If your project needs design, brand, product, strategy, and leadership,
let’s talk, hi@dragoon [dot] xyz | Follow: 0xDragoon