-
-
Landing page: SevaSphere helps donors give with clarity, to verified NGOs, with impact they can follow.
-
Authorization: Before the agent can act, the donor reads and confirms exactly what it may do. It can be paused or revoked at any time.
-
AI matching and allocation: Scored matches with reasons, then a code-calculated split with all safety checks shown before any money moves.
-
Agent activity: Every step of the LangGraph workflow is recorded with its timing and result.
-
Wallet and PayPal: A simulated INR wallet, plus a separate PayPal Sandbox checkout in USD.
-
PayPal payment: The server creates and captures the order and verifies the amount and currency itself.
-
Paypal Payment accepted
-
Donations table: A real AG Grid table with server-side sorting, filtering and paging, and CSV export.
-
Schedule: A real Bryntum Scheduler timeline. A calendar event never moves money; every run re-checks authorization first.
-
NGO donations: Each NGO sees only its own donations, with anonymous donors never identified, and can sort, filter and export them.
-
NGO impact report: Impact is labelled “Reported by NGO” until it has been reviewed.
-
NGO analytics: NGOs see donation trends and cause breakdowns, and anonymous donors are never identified.
-
Admin verification: Admins review documents before an NGO can receive donations.
-
Admin audit or agent monitor: Admins can see the audit log and every AI workflow run step by step.
-
Architecture: React, Express and PostgreSQL, with Gemini limited to text and PayPal kept separate from the INR wallet.
Inspiration
Most of us have given to a cause and then wondered: did it actually reach anyone? We tap "donate," get a thank-you email, and never find out where the money went, or whether the organization was even real. People who want to give more often hold back for exactly that reason. They don't trust what happens after the click.
Generous people deserve to know where their money went, and honest NGOs deserve a way to prove it.
SevaSphere began with one question: what if a donor could set the rules once, and an AI agent could give within those rules, only to verified organizations, with every decision explained and traceable?
What it does
SevaSphere is a donation platform with three portals sharing one database.
Donors pick causes, a monthly budget and limits per NGO. Before the agent can do anything, the donor reads the exact text of what it may do and confirms it. They can pause or revoke that at any time. The agent then matches NGOs, explains each match, previews the split and donates. Recurring gifts can be scheduled, but every run re-checks authorization, wallet balance, budget and NGO status before any money moves.
NGOs build a profile, upload verification documents, see donation analytics, and publish impact reports with evidence. Anonymous donors are never identified to them.
Admins verify NGOs by reviewing their documents, review impact reports and evidence, manage users, handle payouts and enquiries, watch every AI workflow run step by step, and see an audit log of important actions.
One rule shaped everything: the AI never touches money. Gemini helps interpret what the donor wants and writes the reasons. Eligibility, scoring and amounts come from plain, tested code, and a donation is saved in a single database transaction. If anything looks wrong, nothing is spent.
I also kept claims separate from proof. An impact report is labelled "Reported by NGO" until an admin reviews it, and "Independently verified" only if the admin confirms it.
The role of PayPal: PayPal handles checkout. A donor can pay in USD through the PayPal Orders API (Sandbox). My server creates the order, captures it, and checks the amount and currency itself before recording success, so the browser can never fake a payment. Repeated requests are safe, and cancelled, failed and pending payments each show their own state. I kept this separate from the simulated INR wallet on purpose. I never claim PayPal handles INR, and I never convert currencies silently.
How I built it
- The agent: Gemini through LangChain.js, with a LangGraph.js workflow: understand the request, match NGOs, check eligibility, allocate, validate authorization, execute, explain. Every step is saved with its timing and result, so donors and admins can see exactly what happened.
- Money: integer paise only, an append-only wallet ledger, row locking and idempotency keys, so a double click or a retry can't donate twice.
- Tables, powered by AG Grid: every table (donations, wallet ledger, allocations, payouts, users, payments, audit logs, agent runs) is a real AG Grid Community grid. I used its infinite row model so sorting, filtering and paging happen on the server. That keeps big tables fast and means each role only sees its own data. CSV export is built in.
- Scheduling, powered by Bryntum: recurring and one-time gifts appear on a real Bryntum Scheduler timeline. The database stays the source of truth, and a calendar event never moves money by itself.
- Hosting on Render: the API runs on Render, with PostgreSQL behind it.
- The rest: React, Vite, Tailwind, Node.js, Express, PostgreSQL, Prisma, Zod and Recharts.
Challenges I ran into
- Keeping AI away from money. It's tempting to let the model "just decide." I chose the opposite, and spent my time on deterministic allocation, validation and tests.
- Double-click and concurrency bugs. My own tests caught two identical requests racing, where the second came back before the first had finished. I fixed it and kept the test.
- PayPal in the real world. My first sandbox payments came back "pending review" instead of completed. Rather than hide that, the app now shows PayPal's real status and reason.
- Trust in impact data. Deciding how to show NGO-reported claims versus checked ones took more thought than any chart.
- Deploying. Getting migrations, the database and the build settings right on Render took several failed deploys.
Accomplishments that I am proud of
- An agent that explains every choice and can't spend beyond what the donor authorized, backed by 46 automated tests covering concurrency, authorization, role isolation and payment flows.
- A complete money trail: every rupee is traceable from wallet to donation to NGO payout.
- A real working loop across all three roles: donors give, NGOs report, admins verify.
- Honest labelling everywhere: simulated wallet, sandbox payments, and NGO-reported versus verified impact.
What I learned
Trust is something you design, not a label you add at the end. The most valuable things I built weren't the AI parts. They were the limits, the audit trail and the tests that prove the agent can't go beyond what the donor allowed. I also learned how much a fast, clear data grid and a readable timeline change how reliable a product feels.
What's next for SevaSphere
Real-money payments with proper KYC, independent on-the-ground verification of impact, updates from NGOs back to donors, and a managed job queue for the scheduler at scale.
Honest notes: the INR wallet is simulated, PayPal runs in Sandbox, Bryntum is used under its trial package, and the demo NGOs and photos are illustrative seed data.
Built With
- ag-grid
- bryntum
- express.js
- gemini
- langchain
- langgraph
- node.js
- paypal
- paypal-orders-api
- postgresql
- prisma
- react
- recharts
- render
- tailwindcss
- vite
- zod