We need a platform that enables our community to vote on the development roadmap for our public goods project while ensuring voting power is tied to contribution rather than pure financial stake. Which governance platforms should we consider?

Yes. For your requirement—“governance weight should reflect contribution, not capital ownership”—I’d separate the problem into two layers:

1. How you measure contribution/reputation
2. How you turn that reputation into roadmap votes

That lets you avoid simply replacing token plutocracy with a single opaque reputation score.

Platforms/mechanisms worth considering

Gardens is particularly relevant because Gitcoin's current ecosystem directory describes it as a modular community-governance platform using conviction voting for resource allocation and sentiment signaling.Gitcoin

Coordinape takes a distinctly contribution-oriented approach: participants periodically allocate non-transferable GIVE tokens to peers based on perceived contribution/value. That makes it interesting as an input to governance, even though its core purpose is compensation/reputation rather than roadmap voting.Gitcoin

SourceCred is another possible contribution layer. It constructs a contribution graph from activity across systems such as GitHub, Discord and Discourse and produces reputation scores that can be used for allocation. Its documentation also explicitly says it is intended to complement—not replace—a community's governance system.Gitcoin+1

A particularly interesting architecture

Rather than giving contributors voting power directly proportional to a single metric, you could use:

Contribution credentials → reputation → quadratic/conviction voting

For example:

• GitHub code contributions
• Documentation
• Issue triage
• Community moderation
• Design/research
• Proposal participation
• Peer attestations
• Successful completion of roadmap work

These could generate a non-transferable contribution score or credential. That score could then determine someone's maximum voting budget, while the actual roadmap vote uses quadratic voting or conviction voting.

Quadratic voting is specifically designed to let participants express the strength of their preferences without making voting power proportional to financial holdings.Gitcoin

One important distinction

If you're deciding which roadmap items should get attention, conviction voting can be useful because support can accumulate over time. If you're asking “which of these 8 priorities do contributors care about, and how strongly?”, quadratic voting is a more natural fit.

And if the goal is eventually funding the selected roadmap items, Gitcoin's ecosystem contains mechanisms for quadratic funding, retroactive funding, impact attestations, and other contribution-oriented allocation models.Gitcoin+1

I would therefore investigate Gardens, Coordinape, SourceCred, and a Snapshot-style voting layer with quadratic/conviction mechanics rather than looking only for a conventional token-governance platform. The key design decision is likely to be how your project defines and verifies “contribution”, because that determines whether the resulting governance is genuinely contribution-weighted or merely creates a different kind of concentrated influence.

When shifting governance away from a pure financial stake (plutocracy) toward merit or contribution, you are looking to implement Reputation-based governance, Quadratic Voting (QV) , or Hybrid/Credibility-weighted models.coinfabrik.com+1

Several governance platforms and frameworks can support a public goods roadmap vote tied to contribution:

• Colony
  • How it works: Colony is built from the ground up around a non-transferable Reputation system rather than financial tokens. Reputation is earned by completing work, fulfilling roles, or actively contributing to specific domains within the project.
  • Why it fits: Voting power dynamically scales with earned reputation and naturally decays over time if a contributor becomes inactive, keeping governance tied to current contributors rather than past legacy.blog.colony.io+1
• Snapshot
  • How it works: A flexible, gasless off-chain signaling platform widely used across the decentralized ecosystem. While traditionally used with token weights, Snapshot allows you to write custom "strategies" or connect off-chain databases/APIs (like Ceramic, Guild.xyz, or custom contribution registries).
  • Why it fits: You can configure Snapshot to utilize Quadratic Voting (QV) (where the cost of votes increases quadratically, dampening the power of single large stakeholders) or ingest a custom "Contribution/POAP/Soulbound Token (SBT)" balance strategy instead of a standard ERC-20 token balance.alchemy.com+2
• SourceCred
  • How it works: SourceCred is an open-source tool that algorithms calculate a "cred" score for community members based on tracked contributions (such as GitHub commits, pull requests, forum engagement, or Discord participation).
  • Why it fits: It doesn't host the vote itself, but it generates the quantitative meritocratic data/scores. You can export these SourceCred scores into voting engines like Snapshot to weight your roadmap polls precisely by recent, verifiable community work.
• Optimism-style Citizens' House / RetroPGF Frameworks
  • How it works: Modeled after bicameral governance (like Optimism), you can split decision-making or create a dedicated "Citizens' Assembly" or contributor council whose membership is granted via attestation of contribution (e.g., via EAS - Ethereum Attestation Service ) rather than coin ownership.
  • Why it fits: Grants explicit roadmap curation power to active builders, researchers, and maintainers of your public good.a16zcrypto.com

Recommendation on Approach

1. If you want an all-in-one onchain framework where contribution directly mints and burns voting weight automatically, explore Colony.
2. If you prefer an off-chain, customizable voting interface where you can plug in custom contribution metrics, GitHub activity, or Quadratic Voting rules, use Snapshot paired with a custom verification strategy.blog.colony.io+2

When shifting governance away from a pure financial stake (one-token-one-vote) toward contribution-based or reputation-based power, you need tools that track activity, time commitment, peer recognition, or verifiable contributions rather than capital wealth.

Several governance frameworks and platforms are well-suited for public goods and contribution-based roadmaps:

1. Gardens (by 1Hive)

• How it works: Gardens is a bottom-up coordination stack specifically engineered for decentralized communities and public goods. It relies heavily on Conviction Voting rather than traditional discrete, time-boxed ballot votes.1hive.org+1
• Why it fits contribution over capital: In Conviction Voting, members continuously stream their voting preference to specific roadmap items or proposals. Your voting power isn't a static snapshot of how many tokens you hold; rather, it is time-weighted. The longer a contributor directs their personal "signal" or non-transferable reputation tokens toward a roadmap initiative, the stronger their voice grows. It rewards active, sustained alignment over a quick, heavy financial takeover.cryptoaltruists.com
• Best used for: Continuous roadmap prioritization and dynamic resource allocation.gitcoin.co

2. Snapshot (Using Custom Strategies / Delegation)

• How it works: Snapshot is the industry standard for off-chain, gasless signaling and governance. While most projects use simple ERC-20 token balances, Snapshot supports custom, programmable voting strategies.docs.snapshot.box
• Why it fits contribution over capital: You can write or implement custom Snapshot strategies that calculate voting power based on:
  • Non-transferable Soulbound Tokens (SBTs) or contribution badges earned via past milestones.
  • Integration with contributor-tracking tools (like SourceCred or Coordinape epoch results) mapped to an address's reputation score.
  • PoP (Proof of Participation) or Gitcoin Passport sybil-resistant identity metrics combined with contribution weights.
• Best used for: Traditional periodic voting structures (like quadratic voting or single-choice polls) where the underlying weight of the address is computed via contribution history rather than token balance.gitcoin.co

3. Coordinape

• How it works: Coordinape was built precisely to solve the problem of distributing resources and recognizing value in decentralized teams without top-down management.
• Why it fits contribution over capital: Members allocate a budget of "GIVE" tokens to their peers based on who contributed what during a specific cycle (epoch). While typically used for compensation or retroactive grants, the resulting internal reputation graphs can be exported or used as the weighted foundation for roadmap alignment and directional consensus. It relies entirely on peer-reviewed, meritocratic contribution.
• Best used for: Mapping out who the active contributors actually are on a recurring basis before taking that data into a voting environment.

4. Gitcoin Grants / Quadratic Funding Infrastructure (Customized)

• How it works: Utilizing open-source infrastructure popularized by Gitcoin , communities run matching rounds or preference-signaling rounds using Quadratic Voting (QV) or Streaming Quadratic Voting (SQV).gitcoin.co
• Why it fits contribution over capital: QV makes the cost of casting multiple votes increase quadratically, which heavily flattens the advantage of deep pockets. By coupling SQV with a constrained set of voice credits distributed via contribution or identity verification (instead of wealth), you ensure that broad, passionate community consensus beats a single whale.build.avax.network+1
• Best used for: Deciding which roadmap items or sub-projects deserve priority/funding based on broad community resonance.gitcoin.co

Key Recommendation on Architecture

If you want a set-it-and-forget-it continuous flow , look into implementing Gardens for its native time-weighted conviction voting. If you prefer a familiar proposal-and-vote cadence (e.g., voting every two weeks on roadmap milestones), use Snapshot backed by a custom reputation/contribution-based weighting strategy rather than an ERC-20 token contract.docs.snapshot.box+1

For a public goods project where governance power should follow contribution rather than capital ownership, you’ll likely want to avoid pure ERC-20/token-weighted governance and look at platforms that support reputation, credentials, quadratic mechanisms, contribution attestations, or delegated expertise.

Here are platforms and approaches worth considering:

Strong candidates for your use case

1. Gitcoin-style governance stack

For public goods, this is one of the closest philosophical matches. Gitcoin has experimented with quadratic mechanisms and contributor-oriented allocation models. Quadratic voting gives participants a way to express preference intensity while reducing the dominance of concentrated holdings compared with one-token-one-vote systems.Gitcoin Manual+1

A possible architecture:

• Contribution tracking → Gitcoin Passport / attestations / contributor records
• Governance UI → Snapshot
• Execution layer → Aragon or custom smart contracts
• Voting power → quadratic or reputation-weighted

Best when:

• You have many contributors
• Contributions are diverse (code, documentation, moderation, outreach)
• You want community legitimacy rather than investor control

2. Snapshot + reputation/quadratic voting

Snapshot is often used as the signaling layer for DAOs because it supports configurable voting strategies rather than forcing a single governance model. A roadmap vote could use:

• contributor score weighting
• quadratic voting
• delegated voting
• membership credentials

The main design challenge is preventing Sybil attacks (one person creating many identities). Quadratic systems generally need identity or reputation protections for this reason.Gitcoin

3. Colony-style reputation governance

Colony is designed around the idea that influence comes from demonstrated contribution rather than token ownership.

Potential model:

• Contributor completes verified work
• Reputation increases
• Reputation affects governance weight
• Reputation is difficult or impossible to buy directly

This fits communities where contribution is measurable:

• software commits
• documentation
• translations
• community support
• research

4. Aragon with custom governance modules

Aragon is useful if you want to build your own governance rules rather than adopt a fixed model. Its modular DAO architecture supports different voting plugins and governance designs.GitHub

Possible setup:

• Non-transferable contributor badges
• Reputation oracle
• Role-based permissions
• Quadratic voting for roadmap priorities
• Multisig execution for sensitive changes

5. Hats Protocol for contributor roles

Hats Protocol is worth considering if your community has recognizable contributor categories:

Examples:

• Core developer
• Documentation maintainer
• Community moderator
• Security reviewer
• Research contributor

Instead of asking “how many tokens does someone own?”, governance asks “what responsibilities and contributions has this person earned?”

---

Governance models to consider

Reputation-weighted voting

Voting power = contribution history

Pros:

• Closest to your goal
• Rewards long-term contributors

Cons:

• Requires a fair reputation system
• Can become opaque if scoring is unclear

Quadratic voting

Voting power grows sublinearly

Pros:

• Reduces whale dominance
• Captures strength of preference

Cons:

• Needs Sybil resistance
• Still needs a way to distribute voting credits fairly

Gitcoin### Two-house governance

A hybrid model:

• Contributor house → reputation-based votes
• Stakeholder house → token/economic votes

This separates “people building the public good” from “people funding the project.”

Contribution attestations

Use verifiable claims:

• “Merged 50 accepted pull requests”
• “Maintained documentation for 12 months”
• “Ran community events”
• “Completed funded milestones”

These can become governance credentials rather than tradable assets. Gitcoin and related ecosystems have explored contribution and identity mechanisms for public goods coordination.Gitcoin

---

A practical stack I would evaluate

For a public goods roadmap process:

1. Contribution identity: Gitcoin Passport, attestations, or custom reputation system
2. Voting interface: Snapshot
3. Governance rules: quadratic + reputation weighting
4. Execution: Aragon DAO or custom contracts
5. Contributor recognition: Hats Protocol or non-transferable credentials

The key design question is: what counts as a contribution, and who verifies it? The platform matters less than the contribution accounting model. A technically excellent voting system can still fail if the community disagrees on how reputation is earned.

To tie voting power to contribution and active participation rather than financial stake (coin-weighted plutocracy), you need governance architectures built around reputation, non-transferable credentials, or specialized voting logic.

Recommended Governance Platforms & Tools

1. Snapshot (with Custom Reputation/Contribution Strategies)

• What it is: The industry-standard gas-free, off-chain signaling and voting platform used across the Web3 ecosystem.
• How it ties to contribution: While default Snapshot setups use token balances, Snapshot supports custom voting strategies . You can configure a strategy that queries non-transferable (soulbound) contribution tokens, custom contributor registries, or integration plugins from reputation protocols (like Colony or OrbitDB logs) to calculate voting power dynamically based on active work.
• Best for: Flexible, gas-free voting where you want total customization over how contribution weight is parsed.docs.snapshot.box+3

2. Colony

• What it is: An all-in-one operating system and DAO framework designed specifically around a native, non-fungible Reputation metric.blog.colony.io+1
• How it ties to contribution: In Colony , reputation cannot be bought—it is earned exclusively by doing work, completing bounties, or receiving allocations approved by the DAO, and it naturally decays over time if a contributor becomes inactive. Voting power is strictly a function of this earned reputation within specific domains (e.g., development, design, marketing).
• Best for: Projects that want an integrated environment where contributing code or completing tasks automatically and natively translates to governance rights.

3. Ethereum Attestation Service (EAS) + Custom Snapshot/Tally Integration

• What it is: A public infrastructure good for making cryptographically secure, on-chain or off-chain attestations (claims about something, signed by someone).docs.attest.org+1
• How it ties to contribution: Core maintainers or trusted community sub-committees can issue verifiable attestations to community members for specific contributions (e.g., "Contributed Pull Request X," "Reviewed 5 docs," "Active core builder in Q2"). These attestations can then be indexed as a custom voting weight strategy on execution layers or snapshot setups.
• Best for: Maximum modularity and creating a portable, transparent record of merit that isn’t locked into a single proprietary DAO framework.

4. SourceCred

• What it is: A sophisticated software tool designed to dynamically measure and reward value creation in open-source communities.
• How it ties to contribution: SourceCred automatically parses platforms you already use (like GitHub commits, issues, and forum engagement) via a transparent algorithm, assigning a numerical "Cred" score to individual contributors based on how the community defines value. This Cred score can be directly piped into your governance structure to weight roadmap votes.
• Best for: Open-source public goods heavily coordinated through GitHub and Discourse/Discord.alchemy.com+1

Strategic Design Patterns to Implement

• Soulbound Tokens (SBTs) / Membership NFTs: Issue non-transferable credentials to active contributors. Program your governance vote to recognize 1 token/SBT = 1 vote (One Person, One Vote), completely bypassing financial weight.
• Quadratic Voting (QV): If financial tokens or baseline reputation scores are still used, layer Quadratic Voting over it. QV makes the cost of casting additional votes scale quadratically (cost = votes²), heavily blunting the power of heavy stakeholders and empowering broad community consensus.youtube.com+4
• Metrics-Based / Retroactive Voting: For public goods roadmaps, consider separating the who from the what by allowing the community to vote on quantitative impact metrics (e.g., user growth, developer adoption) rather than subjective feature requests, calculating allocation algorithmically.gitcoin.co+1

Yes. For a public-goods project where influence should follow contribution rather than capital, I’d look beyond conventional token-weighted DAO platforms. The key distinction is whether the platform lets you make contribution/reputation the eligibility or voting-weight mechanism, rather than merely putting a nicer interface on 1-token-1-vote governance.

Platforms worth considering

1. Gitcoin / Allo

Probably the closest conceptual match if your project is explicitly a public good.

Gitcoin has experimented extensively with quadratic voting and other mechanisms intended to prevent wealthy participants from simply dominating governance. Its Allo Protocol lets communities define eligibility criteria and allocation mechanisms, including quadratic mechanisms, rather than prescribing one governance model.Gitcoin+1

The important caveat: Gitcoin's current core DAO voting is still token-based, so adopting Gitcoin wholesale doesn't automatically give you contribution-weighted governance.Gitcoin Manual

Interesting architecture: use contribution attestations/reputation to determine voting credits, then use quadratic voting for roadmap decisions.

2. Hats Protocol

I'd put Hats near the top of your shortlist if you want voting power to correspond to recognized roles and contributions.

Hats lets communities create role-based structures, so you can distinguish, for example:

• Core developer
• Documentation contributor
• Community organizer
• Research contributor
• Long-term maintainer
• Project steward

That makes it possible to construct governance around earned roles rather than financial ownership. Hats' own governance model, for example, discusses membership based on evidence of meaningful contributions and community endorsement.Hats Finance

The tradeoff is that Hats is more of a governance/identity/permissions primitive than a polished roadmap-voting product.

3. Gardens

Gardens is particularly interesting if you want governance to incorporate conviction over time rather than simply asking everyone to cast a binary vote.

Its current model supports fixed, token-weighted, quadratic and capped voting systems, with proposals accumulating conviction until a threshold is reached.Gitcoin

You could potentially combine that with a contribution-derived governance token or credential.

Best for: a community where "people who consistently demonstrate commitment" should have more influence than passive members.

4. Snapshot + a contribution/reputation layer

This is probably the most practical custom architecture.

Snapshot gives you the voting interface and proposal workflow, while you make the actual voting weight come from something other than token ownership—for example:

voting credits = GitHub contributions + accepted proposals + documentation contributions + community service + peer attestations You can then use quadratic voting so that even highly active contributors can't completely dominate a particular decision.

Gitcoin itself describes quadratic voting as a mechanism where participants receive equal voice-credit budgets and increasing influence on one issue becomes progressively more expensive.Gitcoin

This approach gives you substantially more design freedom than adopting a conventional DAO platform.

5. CharmVerse

I'd investigate CharmVerse if you want governance and contributor operations in the same environment rather than just a voting mechanism.

It's particularly worth evaluating if your roadmap process involves proposals, working groups, contributor roles, tasks and funding—not merely "vote A vs. B."

What I'd recommend for your use case

I'd actually avoid making the governance primitive "contribution tokens." That can recreate many of the problems of financial token governance.

Instead, consider a three-layer model:

1. Contribution identity

Measure verifiable contributions:

• Code merged
• Issues resolved
• Documentation
• Research
• Community support
• Governance participation
• Successful project milestones

2. Reputation / voting credits

Convert those contributions into a bounded, preferably non-transferable reputation score.

3. Roadmap voting

Use quadratic or capped voting, rather than simple weighted voting.

For example:

Alice has 100 contribution credits and Bob has 20. Alice shouldn't necessarily have 5× the ability to determine every roadmap decision. Quadratic voting can let both express strong preferences while limiting the ability of one highly productive contributor to overwhelm everyone else.

My shortlist

If I were evaluating this for a real project, I'd prototype these three first:

1. Hats + Snapshot — best for a genuinely contribution/role-based governance model.
2. Gitcoin/Allo — best if the project also needs public-goods funding and quadratic allocation.
3. Snapshot + custom contribution reputation — best if you want maximum control over your governance rules.

The crucial question isn't really which voting platform? It's how you want to measure contribution. Once that is defined, the platform choice becomes much easier.

Use quadratic or capped voting, rather than simple weighted voting.

For example:

Alice has 100 contribution credits and Bob has 20. Alice shouldn't necessarily have 5× the ability to determine every roadmap decision. Quadratic voting can let both express strong preferences while limiting the ability of one highly productive contributor to overwhelm everyone else.

My shortlist

If I were evaluating this for a real project, I'd prototype these three first:

1. Hats + Snapshot — best for a genuinely contribution/role-based governance model.
2. Gitcoin/Allo — best if the project also needs public-goods funding and quadratic allocation.
3. Snapshot + custom contribution reputation — best if you want maximum control over your governance rules.

The crucial question isn't really which voting platform? It's how you want to measure contribution. Once that is defined, the platform choice becomes much easier.

You can then use quadratic voting so that even highly active contributors can't completely dominate a particular decision.

Gitcoin itself describes quadratic voting as a mechanism where participants receive equal voice-credit budgets and increasing influence on one issue becomes progressively more expensive.Gitcoin

This approach gives you substantially more design freedom than adopting a conventional DAO platform.

5. CharmVerse

I'd investigate CharmVerse if you want governance and contributor operations in the same environment rather than just a voting mechanism.

It's particularly worth evaluating if your roadmap process involves proposals, working groups, contributor roles, tasks and funding—not merely "vote A vs. B."

What I'd recommend for your use case

I'd actually avoid making the governance primitive "contribution tokens." That can recreate many of the problems of financial token governance.

Instead, consider a three-layer model:

1. Contribution identity

Measure verifiable contributions:

• Code merged
• Issues resolved
• Documentation
• Research
• Community support
• Governance participation
• Successful project milestones

2. Reputation / voting credits

To tie voting power to active contribution and reputation rather than financial speculation or "whale" token-weighting, you need governance architectures built around non-transferable credentials, customized scoring plugins, or identity-bound metrics.altrady.com+1

Several platforms and architectural frameworks can accommodate a contribution-weighted roadmap process:

1. Snapshot (with Custom Contribution/Reputation Strategies)

• How it works: Snapshot is the industry-standard, gas-free off-chain signaling tool. While most default spaces use basic token-weighting (1 token = 1 vote), Snapshot supports custom and modular voting strategies.binance.com+4
• Tying power to contribution: You can write or implement a custom Snapshot strategy that calculates voting power using non-transferable elements—such as a designated Soulbound Token (SBT) contract, Gitcoin Passport scores, or a custom ERC-20/NFT registry that mints "contribution points" or "cred" based on merged GitHub pull requests, community moderation, or completed bounties.
• Best for: High flexibility, gas-free voting experience for users, and seamless integration with existing community tools (like Discord and Discourse).binance.com+2

2. SourceCred (Integrated with Snapshot or Forums)

• How it works: SourceCred is an open-source tool that automatically tracks and measures value creation (contributions) in a community. It maps out a project’s digital footprint (GitHub commits, forum engagement, Discord activity) and algorithmically assigns a "Cred" score to individual participants.gitcoin.co+1
• Tying power to contribution: Cred is explicitly non-transferable (it cannot be bought or sold). You can use a participant's rolling Cred score as the foundational weight for their voting power on roadmap proposals.
• Best for: Open-source software projects and public goods where code contributions, documentation, and forum discussions are the primary currencies of value.gitcoin.co+1

3. Aragon OSx (Modular Plugin Framework)

• How it works: Aragon OSx is a modular, secure DAO framework that allows you to build custom governance logic using plugins.binance.com+1
• Tying power to contribution: Instead of forcing a standard financial token model, Aragon allows you to deploy custom governance configurations where voting weight is governed by a dynamic registry, membership NFTs, or a reputation contract updated continuously as members deliver work and complete milestones.
• Best for: Projects that need a robust, fully on-chain legal/treasury structure coupled with specialized, non-financial governance rules.binance.com+1

4. Optimism Collective-Style Citizens' House / Bicameral Models

• How it works: If you want a structured institutional approach, you can model your governance after a bicameral system. For example, separate token-holder governance from a "Citizens' House" or a dedicated working group whose voting rights are dictated entirely by soulbound citizenship badges earned through active contribution, tenure, or peer endorsement.
• Tying power to contribution: The citizen/contributor cohort exclusively votes on retroactive funding, milestones, and roadmap prioritization, completely bypassing financial stakeholders for product direction.

Key Design Recommendations for Your Setup

1. Define "Contribution": Decide whether your contribution metric is algorithmic (e.g., automated tracking of GitHub PRs and forum posts via SourceCred) or social/curated (e.g., a committee or peer-reviewed "Contributor Soulbound Token" issued monthly).
2. Use Off-Chain Signaling First: Run your roadmap votes off-chain via Snapshot using a custom reputation strategy. This saves your contributors from paying expensive transaction fees just to vote on project direction, keeping the barrier to entry low for active community builders.
3. Prevent Sybil Attacks: Because you are moving away from financial stakes, ensure you pair your contribution platform with an identity verifier (like Gitcoin Passport or World ID) to prevent bad actors from spinning up hundreds of fake contributor addresses.binance.com+2

Yes. For a public-goods project where governance weight should reflect contribution rather than capital, I’d avoid default token-weighted DAO platforms and focus on systems that can use reputation, contribution credentials, quadratic mechanisms, or non-transferable voting power.

Platforms worth considering

1. Aragon — strongest customizable option

Aragon's modular governance architecture lets you build around different voting primitives rather than locking yourself into a single model. Its ecosystem supports councils, token voting, and custom plugins, and Aragon's older DAO templates explicitly included reputation-weighted voting using non-transferable tokens.Aragon+1

For your use case, I'd design something like:

contribution → reputation credential → voting power rather than:

capital → transferable token → voting power That makes Aragon particularly interesting if you're willing to implement some custom governance logic.

aragon.org

2. Gitcoin — best conceptual fit for public goods

Gitcoin is probably the most relevant ecosystem to study. Its Grants program uses quadratic funding, where the number of contributors matters more than the amount contributed, explicitly attempting to give broad community support more influence than large individual financial contributions.Gitcoin Support+1

It has also experimented with quadratic voting, reputation/personhood mechanisms, and community governance. Gitcoin's Passport work was specifically aimed at enabling mechanisms such as quadratic voting while resisting Sybil attacks.Gitcoin Governance

The caveat: Gitcoin Grants isn't really a drop-in roadmap governance platform. I'd look at its mechanisms as building blocks rather than simply adopting Grants wholesale.

grants.gitcoin.co

3. Coordinape — excellent contribution/reputation layer

Coordinape is particularly interesting if your definition of "contribution" is peer-recognized work rather than dollars donated.

Its Gift Circles let contributors recognize one another's contributions, producing an onchain work/reputation history.Gitcoin

You could potentially use that reputation as an input into roadmap voting:

work/contribution → peer recognition → reputation → governance weight

This is much closer to what you're describing than conventional DAO token voting.

coordinape.com

4. Snapshot — good voting interface, but the mechanism matters

Snapshot is worth considering if you mainly need a polished proposal → discussion → vote workflow. The important part is that you don't have to equate voting power with financial stake: you can build/use a custom voting strategy based on credentials or reputation.

I'd treat Snapshot as the voting layer, not necessarily the contribution-accounting layer.

5. Agora — powerful, but more token-oriented

Agora has a sophisticated governance stack with delegation, proposal modules, voting periods, and onchain execution. Its standard architecture, however, tracks token balances and delegate voting power.Agora+1

So I'd choose it if you're comfortable building a custom contribution/reputation token or voting module. I wouldn't choose it simply because you want contribution-weighted governance out of the box.

agora.xyz

What I'd recommend for your project

If the goal is specifically "the people who have contributed meaningful work should have more influence over the roadmap", I'd shortlist:

1. Aragon + non-transferable reputation — best if you want a full DAO/governance system.
2. Coordinape + Snapshot/custom voting — best if peer-recognized contribution is central.
3. Gitcoin-style quadratic voting + contribution credentials — best if you want broad participation and to prevent wealthy participants from dominating.
4. Agora — best if you anticipate sophisticated onchain governance and have engineering resources.

One important design issue is Sybil resistance. Simply replacing a token with "contribution points" doesn't solve the problem if someone can create 100 identities and manufacture contribution history. Gitcoin explicitly identifies Sybil/collusion attacks as a vulnerability of quadratic mechanisms.Gitcoin Support

For a public-goods roadmap, I'd therefore consider a hybrid model:

Contribution reputation × quadratic/diminishing returns × Sybil resistance That gives genuine contributors meaningful influence without creating a plutocracy—and without making the person who accumulates the most points automatically control the project.

rather than:

capital → transferable token → voting power That makes Aragon particularly interesting if you're willing to implement some custom governance logic.

aragon.org

2. Gitcoin — best conceptual fit for public goods

Gitcoin is probably the most relevant ecosystem to study. Its Grants program uses quadratic funding, where the number of contributors matters more than the amount contributed, explicitly attempting to give broad community support more influence than large individual financial contributions.Gitcoin Support+1

It has also experimented with quadratic voting, reputation/personhood mechanisms, and community governance. Gitcoin's Passport work was specifically aimed at enabling mechanisms such as quadratic voting while resisting Sybil attacks.Gitcoin Governance

The caveat: Gitcoin Grants isn't really a drop-in roadmap governance platform. I'd look at its mechanisms as building blocks rather than simply adopting Grants wholesale.

grants.gitcoin.co

3. Coordinape — excellent contribution/reputation layer

Coordinape is particularly interesting if your definition of "contribution" is peer-recognized work rather than dollars donated.

Its Gift Circles let contributors recognize one another's contributions, producing an onchain work/reputation history.Gitcoin

You could potentially use that reputation as an input into roadmap voting:

work/contribution → peer recognition → reputation → governance weight

This is much closer to what you're describing than conventional DAO token voting.

coordinape.com

4. Snapshot — good voting interface, but the mechanism matters

Snapshot is worth considering if you mainly need a polished proposal → discussion → vote workflow. The important part is that you don't have to equate voting power with financial stake: you can build/use a custom voting strategy based on credentials or reputation.

I'd treat Snapshot as the voting layer, not necessarily the contribution-accounting layer.

5. Agora — powerful, but more token-oriented

Agora has a sophisticated governance stack with delegation, proposal modules, voting periods, and onchain execution. Its standard architecture, however, tracks token balances and delegate voting power.

So I'd choose it if you're comfortable building a custom contribution/reputation token or voting module. I wouldn't choose it simply because you want contribution-weighted governance out of the box.