Setting Up a Community Grants Committee

A grants committee is a specialized working group within a DAO responsible for evaluating, approving, and disbursing funds from the community treasury to external projects and contributors. Its primary function is to operationalize the DAO's funding strategy, moving from broad treasury proposals to actionable decisions. Unlike a general governance body that votes on high-level protocol parameters, a grants committee handles the granular review of grant applications, due diligence, and milestone-based payouts. Setting one up involves defining its mandate, composition, and operational processes to ensure it acts as a trusted steward of community resources.

The first step is to draft a clear committee charter ratified by DAO-wide vote. This charter should explicitly define the committee's scope: the total budget under its control, the types of projects eligible for funding (e.g., developer tools, research, content creation), and any geographical or thematic focus areas. It must also establish the committee's legal structure, if any, and its accountability mechanisms. For example, the Uniswap Grants Program operates under a publicly available framework that outlines its mission, grant tiers, and review criteria, providing transparency for applicants and the broader community.

Next, determine the committee's composition and selection process. A balanced committee typically includes 5-7 members with diverse expertise in areas like smart contract development, product design, economics, and community management. Members can be elected by token holders, appointed by existing stewards, or a hybrid model. It's critical to define term limits (e.g., 1 year) and a clear code of conduct to manage conflicts of interest. Many DAOs use sybil-resistant voting platforms like Snapshot for elections or leverage proof-of-personhood systems like BrightID to ensure unique, legitimate participants in the selection process.

With the team in place, establish the operational workflow. This includes the application portal (often using platforms like Questbook or Gitcoin Grants), a structured review rubric, and a transparent voting mechanism for the committee itself. Decisions should be recorded on-chain where possible, using tools like Safe{Wallet} for multisig treasury management and Tally or Agave for proposal voting. The process should mandate public deliberation on forums like Discourse or Commonwealth, with final votes and rationale documented for community audit. Setting clear expectations for reporting and milestone-based payments is essential for grantee accountability.

Finally, implement reporting and iteration cycles. The committee should publish regular transparency reports detailing funds disbursed, key metrics on funded projects, and retrospective analyses. This builds trust and allows the DAO to refine its funding strategy. The charter should include a sunset clause or a periodic review process (e.g., every 12 months) where the DAO re-evaluates the committee's performance, budget, and existence. This ensures the structure remains aligned with the DAO's evolving needs and can be adapted or dissolved through community governance if necessary.

The core prerequisite is a clear, documented mission and scope. This charter must define the committee's purpose, the types of projects it will fund (e.g., protocol development, research, community growth), and any thematic or technical focus areas. A well-defined scope prevents mission creep and sets clear expectations for both committee members and applicants. This document should also outline the grant lifecycle, from application and review to disbursement and reporting. Without this foundational clarity, decision-making becomes inconsistent and resource allocation inefficient.

You must secure a dedicated, multi-sig controlled treasury before launching. This involves deciding on the funding source (e.g., a DAO treasury allocation, protocol fees) and the initial grant pool size. The treasury should be held in a secure, transparent wallet, typically a Gnosis Safe or similar multi-signature wallet, with clear rules for replenishment. Establishing the treasury's token denomination (e.g., native token, stablecoins) and the process for converting funds is also critical. This ensures the committee has the liquidity to execute its decisions without operational delays.

Assembling the right committee members is the most critical human requirement. Aim for a diverse group of 5-9 individuals with complementary skills: deep technical experts, active community builders, seasoned DAO contributors, and potentially subject-matter specialists. Each member should have a proven track record of contribution and alignment with the protocol's long-term vision. Clearly define roles such as Chair, Facilitator, and Treasurer, and establish term limits and a code of conduct to manage conflicts of interest and ensure accountability from the outset.

Finally, you need the operational infrastructure to manage the process. This includes a public-facing portal for applications (using tools like Gitcoin Grants Stack, Questbook, or a custom-built solution), a dedicated communication channel for committee deliberations (e.g., a private forum or Discord channel), and a transparent tracking system for proposals (often a public notion.so or GitHub repository). Setting up these tools in advance creates a professional, efficient workflow and builds trust through transparency, allowing the committee to focus on evaluating merit rather than administrative overhead.

A grants committee is a multi-signature group responsible for evaluating proposals, allocating funds, and ensuring the treasury serves the community's goals. Its composition directly impacts decision quality and perceived legitimacy. Key design choices include committee size, member qualifications, and the selection mechanism. For most DAOs, a committee of 5-9 members balances diversity of thought with operational efficiency, preventing both gridlock and centralization.

Member qualifications should be explicitly defined to attract the right candidates. Common criteria include: - Proven expertise in the protocol's domain (e.g., DeFi, NFTs, infrastructure) - Active, positive contribution history within the community - Alignment with the DAO's long-term vision and treasury goals - Availability to review proposals and participate in meetings. Transparency in these requirements sets clear expectations and helps the community assess candidates.

The selection mechanism is critical for establishing trust. Common models include: 1. Community Vote: Full token-holder vote on nominated candidates. This is highly democratic but can favor popularity over expertise. 2. Council Appointment: A core team or existing council appoints members, which is efficient but less decentralized. 3. Hybrid Model: A skilled panel (e.g., existing contributors) creates a shortlist, which is then ratified by a community vote. This balances meritocracy with broad consent.

For on-chain implementation, consider using Sybil-resistant voting platforms like Snapshot for community votes, with results executed via a multi-sig wallet (e.g., Safe) or a governance module like OpenZeppelin's Governor. The committee's authority should be codified in a smart contract that requires a predefined threshold of signatures (e.g., 3 of 5) to execute a payment, ensuring no single point of failure.

Define clear terms and rotation schedules from the start. Staggered 6-12 month terms with a limit on consecutive terms prevent stagnation and encourage fresh perspectives. Document all rules—size, qualifications, selection process, term length, and removal procedures—in a publicly accessible Grants Committee Charter. This charter becomes the single source of truth, fostering accountability and transparency for all stakeholders.

The committee's mandate is its foundational governance document. It should explicitly define the committee's scope, including the types of projects eligible for funding (e.g., protocol development, research, community initiatives), the total budget authority per period, and the quorum and voting thresholds required for proposal approval. This document is typically ratified as a Snapshot proposal or an on-chain vote using the community's primary governance token, such as UNI or AAVE, establishing its legitimacy.

With the mandate ratified, the next step is to codify its rules into an on-chain workflow. This involves deploying or configuring a smart contract system to manage the grant lifecycle. A common approach is to use a multisig wallet (like Safe) controlled by committee members to hold and disburse funds. Proposals can be submitted via platforms like Snapshot or directly through a custom interface, with voting executed on-chain using tools like OpenZeppelin Governor. The key is to ensure every step—submission, review, voting, and payout—has a transparent, auditable on-chain record.

For technical implementation, consider a modular setup. A Governor contract manages proposal creation and voting. A separate Treasury contract, controlled by the Governor's timelock, holds the grant funds. Upon successful vote execution, the Governor automatically schedules a transaction to the Treasury to release funds to the grantee's address. This separation of concerns enhances security. Tools like Tally or Boardroom can provide a user-friendly interface for community members to view and interact with these on-chain proposals.

A critical technical detail is configuring the voting parameters. This includes setting the votingDelay (time between proposal submission and voting start), votingPeriod (duration of the vote), and proposalThreshold (minimum token weight needed to submit a proposal). For a grants committee, a longer votingPeriod (e.g., 5-7 days) allows for thorough deliberation. The quorum, defined as a percentage of the total token supply that must participate for a vote to be valid, should be set to prevent low-turnout decisions.

Finally, establish clear off-chain processes that complement the on-chain workflow. This includes a public forum (e.g., Discourse) for proposal discussion, a template for grant applications, and defined review periods for committee evaluation. The on-chain vote should be the final, binding step that is preceded by transparent community debate. Documenting this full process—from forum post to on-chain execution—in the committee's public repository completes a robust, trustworthy grants framework.

A Conflict of Interest (COI) Policy is a formal document that defines what constitutes a conflict, outlines disclosure requirements, and establishes procedures for recusal. For a grants committee, common conflicts include: a member applying for a grant, having a financial stake in an applicant's project, a close personal relationship with an applicant, or serving in a governance role for a competing protocol. The policy must be publicly accessible, often in the DAO's governance repository or documentation hub, to ensure transparency.

The core of the policy is the disclosure and recusal process. All committee members should be required to submit a standing disclosure of potential conflicts (e.g., other governance roles, investments) and must proactively declare any new conflict as soon as an application is received. When a conflict is identified, the standard procedure is recusal: the conflicted member must leave the discussion, cannot access confidential application materials, and abstains from voting. Many DAOs use tools like Snapshot with weighted voting or Tally to formally record these abstentions on-chain.

For technical implementation, consider embedding these rules into your governance infrastructure. A smart contract for grant distribution can include checks, though social enforcement is primary. More effectively, use a tool like Clarity or a custom dashboard that flags applications where a committee member's Ethereum address appears as a contributor or beneficiary. Document all recusals in public meeting notes or a dedicated transparency log. This creates an immutable record that the community can audit.

Managing perceived conflicts is as important as managing actual ones. The policy should address indirect conflicts, such as a member's employer applying for a grant, or a situation where the entire committee might be biased (e.g., a grant for a tool the committee itself built). For edge cases, establish an escalation path to the broader DAO council or implement a community veto mechanism where a high-quorum vote can overturn a committee decision suspected of being compromised.

Finally, the policy must be a living document. Schedule an annual review to update it based on new conflict scenarios that emerge. Incorporate feedback from the community and past grant recipients. A well-maintained COI policy is not about preventing collaboration but about ensuring that all grant evaluations are conducted objectively and transparently, which is fundamental to sustaining long-term trust in the DAO's treasury management.

A community grants committee requires a secure and transparent on-chain voting mechanism. The core smart contract is typically a governor contract that manages proposal creation, voting, and execution. Popular frameworks include OpenZeppelin Governor, Compound's Governor Bravo, or Tally's custom implementations. This contract defines key parameters: the voting token (e.g., your community's ERC-20 or ERC-721), proposal thresholds, voting delay, voting period, and quorum requirements. For example, you might set a 48-hour voting delay, a 7-day voting period, and a quorum of 5% of the total token supply.

The proposal lifecycle is automated by the smart contract. A proposer submits a transaction that funds a specific grant recipient address. Voters then cast their votes, with weight determined by their token balance. After the voting period ends, the proposal is queued and can be executed if it meets the success criteria (e.g., majority for and quorum met). It's critical to implement timelocks on the treasury contract. A timelock introduces a mandatory delay between a proposal's approval and its execution, providing a final safety window for the community to react to malicious proposals.

Off-chain tooling is essential for a smooth user experience. Platforms like Snapshot or Tally provide front-end interfaces for proposal discussion and gasless voting (signature-based). You must integrate your governor contract's address and voting token into these platforms. For on-chain execution, a multisig wallet (like Safe) is often used as the executor or treasury guardian. This adds a layer of human oversight, requiring multiple committee members to sign the transaction that finally disburses funds, even after an on-chain vote passes.

Here is a simplified example of initializing an OpenZeppelin Governor contract, demonstrating key parameters:

solidityCopy
// Example using OZ Governor
MyGovernor governor = new MyGovernor(
    votingToken,          // ERC20Votes token address
    "Community Grants DAO", // Name
    48 hours,             // Voting delay (blocks)
    7 days,               // Voting period (blocks)
    50000e18,             // Proposal threshold (e.g., 50,000 tokens)
    5                     // Quorum numerator (e.g., 5%)
);
// Set the timelock controller as the executor
governor.setTimelock(timelockControllerAddress);

The final integration step connects all components. The Timelock Controller is set as the governor's executor. The Treasury Safe is owned by the Timelock Controller. This creates a secure flow: 1) Proposal passes on Snapshot/Tally, 2) Proposal is executed on-chain, sending a transaction to the Timelock, 3) After the delay, anyone can trigger the Timelock to execute the transaction on the Safe, releasing funds. Regular security practices apply: audit all contracts, use verified proxies for upgradeability, and establish clear emergency procedures documented in the committee's operating agreement.

A grants committee operates with community funds and trust, making accountability non-negotiable. Without it, programs lose legitimacy and can become targets for governance attacks. Effective accountability is built on two pillars: internal oversight for the committee's own operations and external reporting to the broader community. This framework ensures funds are used as intended and allows for continuous program improvement based on measurable results.

Define specific, measurable Key Performance Indicators (KPIs) for both the committee and its grantees. For the committee, track metrics like proposal review time, grant approval rate, and treasury runway. For funded projects, require deliverables tied to smart contract deployments, user growth metrics, or protocol integration milestones. Avoid vague goals like "increase awareness"; instead, specify targets such as "achieve $1M in Total Value Locked (TVL)" or "complete a security audit from a firm like Code4rena." These metrics form the basis of all reporting.

Implement a regular reporting cadence. Grantees should submit progress reports on a quarterly or milestone basis, detailing work completed, funds used, and challenges faced. The committee should then compile these into a transparency report published for the community. This report should be hosted on a dedicated page, like a GitHub repository or a section of the project's forum, and include: a summary of funds disbursed, status updates on all active grants, and performance data against the established KPIs.

Use on-chain tools to automate and verify reporting where possible. For grant disbursement, consider using vesting contracts (e.g., via Sablier or Superfluid) that release funds upon milestone completion verified by an oracle or multisig. Treasury activity should be visible through explorers like Etherscan for Ethereum or Solscan for Solana. This creates an immutable, verifiable record that complements narrative reports.

Finally, establish a clear process for handling underperformance. The accountability framework must define what happens if a grantee misses a key milestone or a KPI. Options include pausing further disbursements, initiating a recovery of funds (if legally and technically possible), or working with the grantee to revise the project scope. Having this process documented before issues arise protects the treasury and demonstrates responsible stewardship to the community.

Launching the committee is the beginning, not the end. The first grant cycle will be a learning experience. Use the initial proposals to stress-test your application form, review rubric, and payment processes. Track key metrics like application volume, review time, and community feedback. Be prepared to iterate on your framework based on this real-world data. Transparency is critical; publish a retrospective report detailing the funds distributed, projects funded, and lessons learned. This builds trust and informs future applicants.

To ensure long-term sustainability, establish a clear process for committee renewal and treasury management. Many DAOs implement staggered terms for committee members to maintain institutional knowledge. Define a recurring schedule for topping up the grants treasury from the community treasury, often through a dedicated budget proposal. Consider tools like Sablier or Superfluid for streaming grant payments upon milestone completion, which reduces administrative overhead and aligns incentives. Regularly review and update your grant focus areas to reflect the ecosystem's evolving needs.

The committee's role can expand beyond disbursing funds. Consider developing additional support structures for grantees, such as providing mentorship, technical advisory, or promotional support. This 'grantee success' program can significantly increase the impact of the funding. Furthermore, the committee can act as a signal for the broader community, identifying high-potential early-stage projects that may later seek larger investments. Document all processes and decisions in a public handbook to ensure operational resilience as committee membership changes over time.