I built ProofPact to make “done” something a client and freelancer can check
A locked scope, a CSV that misses 17 records, and a delivery receipt backed by browser evidence. How I built ProofPact on AWS for First Commit, including the Bedrock quota failure and working Modal fallback.
“Can you add one more thing?” is an easy message to send. Working out whether that thing was promised in the first place can take much longer.
I built ProofPact for the First Commit hackathon because a project needs a shared boundary before delivery. A client needs to know what they will receive. A freelancer needs to know where the agreed work ends. Both need a way to check the result without reconstructing the deal from weeks of messages.
ProofPact connects a versioned agreement to evidence from the delivered application. I built it solo, with Codex for implementation and testing, and the AWS Core plugin for working with AWS resources.
Start with an observable definition of done
A client and freelancer have separate accounts and private briefs. Each can give their advocate requirements, budget or price constraints, timing and notes. Private limits stay separate from the shared proposals.
The agreement records deliverables, acceptance criteria, price, deadline, revision window and the client who approves delivery. Both people must approve the same content hash before the agreement locks. An agent can propose a compromise, but it cannot approve for either person.
A request for another feature becomes a proposed amendment. The existing agreement continues to define delivery until both participants accept the new version. This was one of the most useful pieces of feedback I received while building: a missing promised feature and a new request need different treatment.
Revision requests refer to the agreed criteria. The window starts with the first delivery, and resubmitting does not restart it. Its expiry never automatically accepts work or releases money.
The demo catches a bug that looks finished
The demo project is an admin portal with login, analytics, CSV export and OTP verification. Its export button works. It downloads a file. But the first delivery exports only 10 of the expected 27 records because it stops at the current page.
ProofPact opens the delivered fixture in a real Chromium browser, exercises the flow and checks the downloaded CSV. The criterion fails with the record count attached. Submitting the repaired fixture produces all 27 records. The mobile visual check still needs a person to review the screenshot.
Once the required checks and human review pass, the project can produce a shareable receipt tied to the approved agreement version. That receipt records the result of those checks; it does not claim that every possible defect has been ruled out.
The synthetic demo is available without an account. The landing-page walkthrough is illustrative; the workspace performs the actual checks. Custom acceptance criteria currently use human review rather than pretending to have a universal automated evaluator.
Where AWS runs the product
AWS Lambda runs the containerized Next.js interface and FastAPI backend through Lambda Web Adapter. A function URL makes the demo accessible to judges without a separate account or setup step.
Amazon Cognito handles participant accounts, email verification and password authentication. The application enforces a fixed client or freelancer role and pact membership. Its opaque session cookie is HttpOnly, and real accounts cannot use the demo's role switcher. Email ownership verification is not legal identity verification.
DynamoDB stores project state, agreement versions, approvals, sessions and A2A tasks. Conditional writes detect competing updates so an old view cannot silently replace a newer agreement state.
Private S3 stores screenshots and file evidence. Evidence access goes through application authorization. Public receipts expose a reduced view rather than opening the evidence bucket to everyone.
CodeBuild builds the container, ECR stores it, and CloudFormation defines the deployment. The Lambda release uses an immutable image digest. Secrets Manager stores the Modal credentials used by the inference adapter; CloudWatch provides runtime logs.
What fought back
My first Bedrock invocation hit a daily-token quota error. I kept the Bedrock adapter, but switched the working advocate inference path to Modal. Modal runs bounded negotiation, and the application validates its structured proposal before showing it to the participants. A separate sample mode is labelled explicitly so a provider failure never becomes a fake successful AI run.
The distinction mattered more than having an uninterrupted demo. A model returning text is not evidence that it respected private constraints or produced an agreement the application should accept.
I also added an A2A 1.0 JSON-RPC interface. External agents receive short-lived access scoped to a pact and role. They can request permitted negotiation and delivery work and retrieve persistent tasks. Approval, receipt publication and payment authority remain outside those agent permissions. A real Modal negotiation through this A2A path was validated, along with key rotation, replay handling and revocation.
What helped, and what I would improve
The AWS Core plugin made it easier to work with AWS resources from the same place I was building the application. I could inspect deployment state and documentation while making concrete infrastructure changes, rather than describe an architecture that had never run.
CloudFormation and ECR made the deployed version identifiable. DynamoDB's conditional writes fit the agreement's need to reject stale updates. Cognito gave me an account service without storing passwords in the application. Private S3 suited the split between participant evidence and a shareable receipt.
The Bedrock quota failure was the biggest interruption. A clearer preflight showing the usable model, region and remaining quota would have helped before wiring the full negotiation flow. Packaging Chromium together with the web application also made container size and cold-start behavior part of the deployment work. I would separate long-running verification from request handling in a production version.
What is verified, and what is next
The backend has 55 passing tests covering agreement integrity, role isolation, A2A permissions, invitation membership, payment guards and revision behavior. Hosted tests with temporary Cognito accounts verified login, invitation acceptance, private-brief separation, fixed roles and logout. Those accounts were removed afterward. A signup and password-recovery inbox round trip still needs testing.
Razorpay Route integration is test-only and disabled while provider access is pending. ProofPact does not currently hold customer funds or offer live escrow. I would finish provider validation, disputes and operational controls before adding real money to this workflow.
Try the no-signup demo: https://kys3pqjxvy4fbljl7xqp2zzssu0pxmxo.lambda-url.us-east-1.on.aws/workspace?demo=1
Thanks to WeMakeDevs, Kunal Kushwaha and AWS for First Commit.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article