Inspiration

Imagine hiring a freelancer to clean a sales spreadsheet. The delivered file has the correct columns, the expected number of rows, and even the same total revenue as the original. Everything looks right.

But what if one customer order was silently replaced with another? What if a revenue value changed by just one cent?

Traditional file validation might approve the delivery, even though the actual business data is wrong.

That led to a question: What if payment could be connected to verifiable evidence that the agreed work was actually delivered?

I built Prooflane — Proof Before Payment to explore that idea.

Prooflane helps independent data freelancers, small analytics agencies, and their clients agree on measurable requirements, verify delivered work against its original source, and connect human-approved results to PayPal checkout.

What it does

Prooflane turns a freelance data handoff into a proof-before-payment workflow.

Instead of relying on vague promises or simply checking whether a file exists, it connects the entire process:

  1. Define the work with AI. A client enters a project brief and an agreed USD price. Google Gemini generates measurable acceptance checks and quotes the requirements behind them.

  2. Review and agree. A human reviews the proposed checks before accepting the scope. Ambiguous requirements trigger clarification rather than automatic approval.

  3. Verify the actual delivery. Prooflane checks the submitted CSV against the original source. It evaluates structure, unique identifiers, missing values, numeric limits, row counts, exact source records, and matching business values.

  4. Catch hidden mistakes. A delivery with a substituted order can pass ordinary structural checks and preserve the total revenue, but Prooflane detects the missing and unexpected records. It also catches a one-cent revenue discrepancy.

  5. Review corrections and approve. Prooflane previews evidence-backed corrections with before-and-after values. Applying or undoing corrections requires fresh verification. Payment remains blocked until the exact passing delivery is explicitly approved.

  6. Connect approval to PayPal. PayPal Orders v2 creates a sandbox checkout for the approved work. A versioned evidence manifest connects the project requirements, source data, verified delivery, amount, and payment reference.

  7. Verify the receipt independently. An exported evidence file can be checked without the original application database. Optional authenticated PayPal readback verifies the transaction's reference, amount, and completed capture.

The result is a clearer answer to two important questions:

Did the freelancer deliver what was agreed? And what exact approved work was the payment associated with?

How I built it

I deliberately chose a lightweight architecture that is easy to inspect, run, and reproduce.

The application uses Python 3.11+, SQLite, HTML, CSS, and JavaScript, without requiring a runtime framework, hosted database, or paid deployment.

Google Gemini: turning requirements into checks

Gemini generates structured acceptance plans from natural-language project briefs.

However, AI-generated checks are not automatically trusted. The Python backend validates the supported check types, quoted requirements, numeric bounds, and output structure.

If the requirements are unclear, the application requests clarification. Gemini cannot change the price, approve a delivery, or authorize payment.

The AI interprets the agreement; deterministic code evaluates the data; a human makes the approval decision.

Raw CSV records remain local rather than being sent to Gemini.

PayPal: connecting payment to approved evidence

PayPal is integrated into the actual approval and checkout process.

Using PayPal Orders v2 Sandbox, Prooflane creates orders for approved work and stores a reference to the frozen evidence manifest in the payment's custom_id.

The application validates the exact amount and currency, checks the order reference, handles pending and cancelled states, and reconciles completed captures.

Stable request identifiers and readback checks help prevent duplicate captures or incorrect payment confirmation after interrupted requests.

SHA-256: verifying the exact approved result

Prooflane creates a versioned SHA-256 evidence manifest covering the agreement, source snapshot, delivery, and payment amount.

The independent verifier checks that the files and evidence still match. When authorized sandbox credentials are available, it also verifies the actual payment through PayPal.

An unsigned local evidence file is never treated as independent proof that a payment occurred.

Challenges I faced

1. Making AI-generated requirements reliable

Getting valid structured JSON from an AI model was not enough. Some early Gemini responses omitted important numeric boundaries or returned incomplete interpretations.

I added stricter validation, exact requirement quotations, conservative handling of unsupported language, and mandatory human review.

The biggest lesson was that valid AI output is not necessarily a correct agreement.

2. Detecting incorrect data that looks correct

A spreadsheet can have valid columns, unique identifiers, and matching totals while containing the wrong records.

I implemented source-key reconciliation and per-record decimal comparisons to detect substitutions and small numeric changes that basic CSV checks miss.

3. Making payment confirmation trustworthy

A payment request can time out, remain pending, be cancelled, or return incomplete data.

I addressed these situations with frozen approval evidence, stable payment request identifiers, strict order/capture validation, and authenticated readback.

The application does not mark a payment successful merely because an order was created or a browser returned from checkout.

4. Keeping everything reproducible and free

I wanted judges to experience the product without deploying infrastructure or setting up paid services.

Prooflane therefore includes a complete local demonstration using example CSVs, a clearly labelled sample AI plan, and simulated payments. Real Gemini and PayPal sandbox modes can be configured separately.

Accomplishments

On 11 November 2026, the project recorded a fresh end-to-end acceptance test using real Gemini output and a completed USD 1.00 PayPal sandbox capture.

The workflow successfully:

  • Generated and reviewed seven acceptance checks.
  • Rejected substituted records and changed revenue values.
  • Applied a source-backed correction and required re-verification.
  • Recorded explicit approval of the verified delivery.
  • Completed a PayPal sandbox capture.
  • Independently confirmed the completed transaction, amount, and matching evidence manifest.

The latest local verification reports 34 passing Python tests, passing JavaScript controller checks, and browser walkthroughs in Chrome, Edge, and Chromium.

The project is publicly available under the MIT license, and its default demonstration can run locally with Python alone.

What I learned

Building Prooflane reinforced three ideas:

AI should clarify decisions, not silently make them. Human review is essential when requirements can affect payment.

A file hash becomes useful when it is connected to an understandable agreement. Proving that a file has not changed is different from proving that the work satisfies the agreed requirements.

Payment confirmation needs independent evidence. A local success message and a provider-confirmed transaction are not interchangeable.

Connecting these three ideas was the most valuable part of developing Prooflane.

What's next

Prooflane is currently a localhost, single-operator prototype using synthetic data and PayPal sandbox payments. It is not an escrow service and does not process live payments.

The next steps are to test the workflow with actual freelancers and clients, introduce securely authenticated buyer and seller roles, support additional delivery formats, and expand verified payment reconciliation for a future hosted product.

The long-term goal is to make verifiable delivery evidence a normal part of digital freelance payments.

Try Prooflane

Prooflane can be run locally with Python 3.11 or later:

git clone https://github.com/AaryaMody1301/Prooflane.git
cd Prooflane
python app.py

Open http://127.0.0.1:8787 and follow the repository's demonstration instructions.

The default mode requires no API keys. It uses sample AI and simulated payments, clearly distinguished from the separately verified real Gemini and PayPal sandbox integration.

Source code: https://github.com/AaryaMody1301/Prooflane

Detailed judge instructions: https://github.com/AaryaMody1301/Prooflane/blob/codex/hackathon-submission-2026-11-11/submission/JUDGE_GUIDE.md

Tools and technologies

Python, SQLite, JavaScript, HTML, CSS, Google Gemini API, PayPal Orders v2 Sandbox, REST APIs, JSON, SHA-256, GitHub Actions, Playwright, and FFmpeg for demonstration recording.

OpenAI Codex assisted development, testing, documentation, and submission preparation. The application does not depend on Codex or OpenAI APIs at runtime.

Built With

Share this project:

Updates

Submission history