GrantProof

GrantProof checks grant proposals, agreements and reports against the funder's rules, cites the exact page behind every finding, and leaves every decision to your staff.

Comment

Inspiration

Grant compliance at a non-profit is mostly people reading long documents side by side: the funding call, the proposal, the contribution agreement, the results reports, the logic model and the budget. Staff check that they agree, clause by clause, every reporting cycle. A missed clause or a mismatched date can put funding at risk, and every hour spent cross-checking is an hour not spent finding the next grant. Smaller grants suffer most, because they cost almost as much to administer as large ones.

WaterAid Canada's Water Challenge (A6) asked us to build an AI assistant for exactly this. The challenge came with a fictional case, Water Care's Taps for Rights project funded by Global Affairs Canada (GAC), whose documents were deliberately seeded with errors and contradictions, plus 25 test questions. That set the bar for us: an AI tool here is only useful if staff can trust every line it shows them.

What it does

GrantProof is an evidence-first workspace for grant staff. It reads every document in a grant, flags what doesn't line up, and shows the exact page behind each flag.

  • Checks a proposal against the funding call. It tests the proposal against the call's rules (cost share, construction limits, claims with no supporting evidence, a full requirements checklist) and maps the funder's reviewer questions to the sections that answer them.
  • Answers questions across documents. Every answer quotes the page it relies on, shows its confidence, puts conflicting evidence side by side, and lists what's missing. When sources conflict, it names who should decide: the funder or your staff.
  • Helps you write. A proposal editor with the funder's template and a review desk that gives cited tips and ready-to-edit sentences. Facts the documents don't contain stay as [placeholders], so nothing is invented.
  • Takes you to the source. Every citation opens the original PDF at the cited page with the quote highlighted.
  • Keeps staff in control. Issues wait for a staff decision (confirm, correct, dismiss, escalate or request clarification), and a decision is flagged as stale if the evidence behind it changes. The AI drafts and flags; people approve.
  • Tracks deadlines. A reporting calendar turns the agreement's schedule into due dates around the case date.
  • Works on your own grants. Create a project, upload its PDFs, spreadsheets and CSVs, and ask grounded questions about them.

One example from the case: the agreement sets Water Care's minimum contribution at 9.5% of eligible costs, while the call requires at least 10%. GrantProof quotes both clauses, computes the 0.5-point gap in code, and flags it as a conflict for GAC to resolve. It does not declare a verdict.

How we built it

We built one shared engine with the proposal and compliance assistants as views on top of it, because the hardest questions span several documents at once.

  • Every page and cell is citable. PDFs are split into pages and spreadsheets into cells, each with a document ID, version and locator. A registry also records documents that are referenced but missing (such as GAC's General Terms and Conditions), so the tool says "not in the documents" instead of guessing.
  • Models for language, code for math, people for decisions. A language model (GPT-4.1 and GPT-4.1 mini through OpenRouter, tiered by task) extracts and drafts under a strict JSON schema. Python code does every date, sum, percentage and threshold. A verifier rejects any quote that doesn't appear word for word in the cited source, and rejected output gets one repair attempt before it is dropped with a visible reason.
  • Writing help has guardrails. A suggested sentence can't introduce a number that isn't in the cited sources or the draft, and it can't claim the applicant "meets" a requirement. That call belongs to staff and the funder.
  • Stack. Python 3.13 and FastAPI on the backend, with 200+ tests that run offline against a fake model. React 19, TypeScript, Vite and Tailwind on the frontend, with react-pdf (PDF.js) for highlighted citations and zod validating every API response.
  • Teamwork. Four parallel workstreams shared one finding and evidence contract, merged through small pull requests, and kept a running handoff log. We used AI coding assistants alongside the team.

Challenges we ran into

  • Making "zero hallucination" concrete. Models paraphrase quotes, join table rows, and attribute a proposal's copy of the call's wording to the call itself. We made code the judge: exact-quote checks, relabelling draft wording, and rejecting unsupported numbers.
  • Conflicts by design. The case documents disagree on reporting periods, contribution rates and due dates. The tool has to show both sides and name who decides, never pick a winner.
  • Missing documents. Key referenced documents aren't in the pack, so knowing when to say "this isn't here" mattered as much as answering.
  • Integration under time pressure. We merged a frontend and three backend workstreams built in parallel, including a mid-project repository restructure, without breaking each other's work.
  • Reliability. Long model calls sometimes failed or returned malformed JSON. Bounded context, timeouts, repair passes and clear error messages kept the app usable.

Accomplishments that we're proud of

  • Every finding links to a verified quote and opens the original page with it highlighted.
  • The model never does arithmetic. Every number comes from code.
  • Conflicts carry both sources and who should resolve them.
  • A writing assistant that helps you draft without inventing facts.

What we learned

  • Trust is the product. Often the most useful thing an AI tool can say is "these two documents disagree" or "that isn't in the documents."
  • Pairing model extraction with deterministic checks beats asking a model to "check compliance".
  • Agreeing on a shared data contract early saves a day of integration.
  • Depth beats breadth, which was the challenge's own advice.

What's next for GrantProof

  • Score it on the 25 test questions and publish how many it answers correctly with accurate citations.
  • A full requirements register. Every obligation from the agreement and its amendments, with computed and stated due dates side by side, feeding the calendar and alerts.
  • Evidence tracking. Link each requirement to the reports, approvals and records that satisfy it, and flag the gaps.
  • A pilot with WaterAid staff. Measure review time and how many known issues it catches, against staff's own checks.
  • Team features. Accounts, shared review history and audit-ready exports.
  • More funders. The engine is funder-agnostic, so new funders mean new rule sets, not a rewrite.

Built for The Water Challenge (WaterAid Canada × The AI Fellowship × SOON × TMU), Challenge A6. The Taps for Rights case is fictional training material, not real WaterAid activity.

Built With

  • chatgpt
  • fastapi
  • lucide
  • openpyxl
  • openrouter
  • pdf.js
  • playwright
  • pydantic
  • pypdf
  • pytest
  • python
  • react
  • react-pdf
  • tailwindcss
  • typescript
  • vercel
  • vite
  • zod
Share this project:

Updates