Inspiration

When freelancers and clients work together, there's always a big trust problem.

Freelancers fear that the client will keep asking for extra work, the milestones will keep dragging on, and after promising payment, the client will just ghost them. At the same time, clients are worried they’ll get broken or half-done work, and end up losing both their money and their time.

Traditional platforms like Upwork or Fiverr don't really fix this. When a dispute happens, an all-or-nothing fight starts, and support reps take weeks reading chat logs without actually understanding the technical work.

We asked ourselves: what if payments were tied directly to real, automated proof of work?

That’s why we built VeriPay. It tracks everything in one single platform — from the contract and the work being done, all the way to verified PayPal payments.


What it does

VeriPay handles the full lifecycle of a freelance project so neither side gets burned:

1. Turning Agreements into Clear Checklists

Either the client or the freelancer pastes their raw project agreement (SOW). Our AI reads it and breaks it down into clear milestones, exact acceptance criteria, and dollar amounts. Both sides have to review and sign it. If anyone tries to change the scope later, both parties must re-approve. No one can sneak in extra requirements.

2. Upfront Escrow with PayPal

Before the freelancer writes a single line of code, the client locks the milestone money in escrow using PayPal Sandbox authorizations.

  • The freelancer gets proof that the money is real and reserved, so they know they won't get ghosted.
  • The client keeps their money safe because it isn't actually captured until the work is verified and approved.

3. Automated Browser Testing (Kernel Agent)

When the freelancer finishes a website or web app, they submit the live link. Instead of relying on promises, VeriPay sends an autonomous Kernel browser agent to visit the live site. It actually clicks buttons, types in search bars, tests filters, adds items to the cart, and checks checkout flows. It grabs real screenshots and console logs as proof.

4. The Freelancer Shield

If the first submission has bugs, only the freelancer sees the failure report. The client doesn't see it yet. This gives the freelancer a safe, private chance to fix defects without embarrassing themselves or hurting their reputation with the client. Once the fixes pass, the verified report goes to the client.

5. AI Chatbot & Stopping Scope Creep

Inside the project chat, our AI project manager helps keep things friendly and on track. If a client suddenly asks for free extra work mid-milestone (like "Hey, can you also build an admin dashboard for this?"), the AI politely steps in, references the signed SOW, and explains that this is outside the current milestone. It then automatically creates a separate paid change request so the current milestone payment doesn't get held hostage.

6. Human Expert Panel for Gray Areas

AI shouldn't judge everything. For subjective feedback or design disagreements, VeriPay brings in an independent 3-person expert panel. They cast sealed blind votes, and a 2/3 majority quorum decides fairly: $$Q = \frac{\sum_{i=1}^{N} v_i}{N} \ge \frac{2}{3}$$

7. Fair Partial Releases (Never All-or-Nothing)

If a milestone has 5 requirements and 4 are working perfectly, the client shouldn't withhold 100% of the money. VeriPay calculates a fair proportional payout: $$\text{Release Amount} = \text{Milestone Escrow} \times \left( \frac{\text{Verified Tasks}}{\text{Total Tasks}} \right)$$ The verified 80% gets released immediately to the freelancer’s PayPal account via Payouts, and only the remaining 20% waits for the final fix.


How we built it

  • PayPal Sandbox & SDK: Handles all the money flows—holding funds in escrow with Authorizations, capturing the funds once verified, and sending direct Payouts to the freelancer.
  • APIMatic Context Plugin: Guided our setup with @paypal/paypal-server-sdk. It caught a huge bug where the default SDK timeout was 0 (which would freeze payment calls forever) and retries were off. It helped us set clean 30s timeouts and keep retries strictly on read calls so we never accidentally double-charge anyone.
  • Kernel Cloud Browser Agent: A headless browser that navigates live freelancer deliverables to click, test forms, and collect real DOM evidence.
  • AG Grid & AG Charts: Powers our financial ledgers, audit trails, and interactive milestone funding breakdowns with quick cell inspectors for deep transaction IDs.
  • Bryntum Gantt: Visual project board where work tasks literally cannot start until the funding block is locked in escrow first.
  • Groq AI (Llama & GPT models): Powers the SOW contract parsing, dispute mediation, and the in-app chat manager.
  • Render: Hosts our live full-stack app in the cloud with auto-deployments.

Challenges we ran into

  1. AI Hallucinations vs. Real Evidence: AI models can sometimes guess wrong or make things up. We made a hard rule: real browser evidence always beats AI opinions. If the browser agent proved the cart and filters worked on the live site, the milestone passes regardless of subjective complaints.
  2. Avoiding Double Charges: In payment code, if a network hiccup happens and you blindly retry a payment capture, you could charge the client twice or pay the freelancer twice. We had to ensure retries only happen on safe read checks.
  3. Cloud Port Binding: Express defaults to local network binding, which worked fine on our laptops but broke when deploying to cloud containers. We fixed our startup scripts to automatically detect production environments and bind properly.

Accomplishments that we're proud of

  • Equal Protection for Both Sides: Clients get proof that deliverables actually work before money leaves, and freelancers get guaranteed payments without fear of getting ghosted.
  • Killing Scope Creep: The AI chatbot catches out-of-scope demands immediately and turns them into paid change orders instead of free unpaid labor.
  • No More All-or-Nothing Hostage Situations: Freelancers get paid proportionally for what's already completed and working.
  • A Fully Working End-to-End System: From uploading a contract, funding escrow on PayPal, running browser checks, to releasing instant payouts.

What we learned

  • Never trust default SDK settings blindly: Tools like the APIMatic Context Plugin showed us that generic AI guesses about SDKs are often outdated. Checking real SDK contracts saved us tons of debugging time.
  • Proof kills arguments: When both parties have video-like browser logs, screenshots, and exact test results right in front of them, 90% of freelance arguments simply disappear.

What's next for VeriPay

  1. Plug into Upwork, Fiverr, and Contra: We want to offer VeriPay as an embeddable verification and dispute widget so existing platforms can resolve payment disputes in minutes instead of weeks.
  2. Build a Full Autonomous Freelance Marketplace: Expand VeriPay into a standalone platform where clients and freelancers can agree on contracts, verify work, and get paid with super low platform fees.
  3. GitHub PR and Figma Verification: Automatically test code directly from GitHub Pull Requests and compare live builds with Figma design files.

Built With

  • ag-charts
  • ag-grid
  • ai-agents
  • apimatic
  • automated-testing
  • browser-automation
  • bryntum
  • computer-use
  • escrow
  • express.js
  • fintech
  • groq
  • kernel
  • multimodal-ai
  • node.js
  • openapi
  • payments
  • paypal
  • playwright
  • react
  • render
  • smart-contracts
  • tailwindcss
  • typescript
  • vite
Share this project:

Updates

Submission history