Inspiration:
Businesses need to make payments constantly, but managing those payments safely is still fragmented. A payment request might begin in a conversation, pass through spreadsheets or approval messages, and eventually reach a payment provider. This creates gaps between what was requested, what was authorised and what was actually paid.
We wanted to explore a different approach: what if businesses could interact with their payment workflows naturally, while retaining the controls and accountability expected of financial software?
That idea became Pactra.
What it does:
Pactra is an AI-assisted payment governance workspace that turns natural-language payment requests into governed transaction workflows.
Users can interact with an AI assistant to initiate payment requests. Instead of allowing the AI to execute financial actions independently, Pactra routes requests through a backend that validates them against spending policies, approval requirements and transaction controls.
Its core capabilities include:
- AI-assisted payments: Google Gemini interprets natural-language requests and invokes application tools.
- Spending policies: Transactions are evaluated against configurable limits and vendor restrictions.
- Human approvals: Requests that exceed approval thresholds are routed for human authorisation.
- PayPal integration: Governed payment workflows connect to PayPal Sandbox.
- Financial visibility: Transaction lifecycle information, ledger records and audit evidence help users understand what happened at each stage.
How we built it:
Pactra combines Google Gemini function calling with a backend-controlled transaction architecture.
The frontend is built with React and TypeScript. The backend uses Python and FastAPI, with PostgreSQL for persistent data. A dedicated worker handles PayPal payment submission.
Gemini acts as the natural-language interface. It can interpret requests and invoke approved application tools, but it does not control financial policy or independently authorise payments. The backend remains responsible for validation, policy evaluation, approval enforcement and execution.
We also built an instant public demo so judges can explore the governance workflows without registration. This demo uses a deterministic assistant and isolated demo data. The authenticated application provides the Gemini-powered assistant.
Challenges we faced:
One of the hardest architectural decisions was ensuring that AI convenience never came at the expense of financial control.
A conversational interface can make payments feel simple, but financial systems need deterministic rules, clear authorisation boundaries and reliable records. We had to ensure that AI requests could not bypass backend policy checks, that approval requirements were enforced independently, and that provider responses were not confused with successful individual payouts.
We also focused on separating payment submission from final transaction outcomes so that the application could accurately represent each stage of the payment lifecycle.
What we learned:
We learned that the most useful role for AI in financial workflows is not necessarily to replace existing controls, but to make those controls easier to interact with.
Pactra explores a model where natural-language interaction and traditional financial governance work together: AI improves accessibility, while deterministic backend systems retain authority over money movement.
What's next:
Pactra is currently demonstrated using PayPal Sandbox. Our next direction is to expand its governance capabilities, strengthen multi-user approval workflows and explore the requirements for production payment infrastructure.
Important: This project is a sandbox demonstration. No real money is transferred.
Built With
- ai
- fastapi
- generative-ai
- google-gemini
- paypal
- postgresql
- python
- react
- rest-api
- typescript
- vercel