BuyBound

AI-powered autonomous shopping that hunts price drops and buys through PayPal, protected by a deterministic Guardian,with SHA-256 checkout verification,fail closed payment security and end to end DLP.

Comment

BuyBound: Never Miss a Drop Again.

Inspiration

The idea for BuyBound actually came from my own experience of trying to buy limited-edition Nike sneakers.

I used to keep checking different stores for price drops and good deals, hoping to get the shoes at the right price. PayPal Honey was helpful because it sent price alerts, but there was one problem. Most of the good deals used to come at odd hours, and quite often, I would be asleep when the notification arrived.

By the time I woke up and checked my phone, the deal was usually gone or the product was already out of stock.

I always felt there should be a better way to handle this. What if I could simply tell an agent which product I wanted, set my target price and spending limit, and let it keep checking for me? If the price dropped while I was sleeping, it should be able to complete the purchase without me having to wake up and do everything manually.

With AI agents becoming more capable, I finally felt this was something I could build. That is how BuyBound started.

What it does

BuyBound is an autonomous shopping agent that monitors products across multiple retailers, tracks price drops and can automatically purchase products through PayPal when the conditions set by the user are met.

Users can create shopping watches using a product URL, product name or even a natural-language prompt. They can set a target price, maximum spending limit and other purchase conditions. BuyBound then keeps monitoring the product in the background.

But I didn't want to build something that simply lets an AI find a product and purchase it on its own.

That brings us to Guardian, the most important part of BuyBound.

Guardian is a deterministic financial authorization and security engine that independently checks every purchase before it reaches PayPal. It verifies the exact product, SKU and variant, merchant trust, price limits, spending budgets, subscription risks and transaction integrity.

Based on these checks, Guardian returns one of three decisions: ALLOW, HOLD or BLOCK.

Only transactions that pass the required checks can proceed to the backend PayPal payment adapter.

Apart from autonomous purchases, BuyBound also supports direct PayPal checkout, multi-store price comparison, transaction tracking, verified receipts and an emergency global kill switch.

How I Built It

One of the main things I wanted to get right was the separation between AI and financial authority.

The AI can help find the right product and identify a good deal, but it cannot authorize a payment or decide how much money can be spent. That responsibility belongs entirely to the backend Guardian engine.

The technology stack used for the project includes:

  • Backend: Java 21, Spring Boot 3, Spring Security and Hibernate.
  • Frontend: React, TypeScript, Tailwind CSS and AG Grid.
  • Database: PostgreSQL 16 with Flyway migrations.
  • Product Discovery: Channel3 Commerce API for multi-retailer product discovery.
  • Payments: PayPal REST APIs, Orders v2, Vault v3 and Webhooks.
  • Infrastructure: Docker, Docker Compose and Render.

Security Implementation

Since BuyBound can make purchases without the user being present, security was something I had to take very seriously. I spent a considerable amount of time reviewing the architecture and fixing potential security gaps before submission.

Some of the security mechanisms implemented include:

  • Deterministic Guardian: Server-side purchase authorization with spending limits, seller reputation checks, exact product verification and fail-closed decisions.
  • Atomic Spend Reservations: PostgreSQL transactions and row-level locking to prevent multiple background workers from exceeding the user's spending limits.
  • SHA-256 Transaction Verification: Cryptographic evidence hashing to bind merchant, product, variant, price and timestamp details to the evaluated checkout.
  • PayPal Webhook Security: Cryptographic signature verification and transmission-time checks to prevent forged and replayed webhook events.
  • Data Loss Prevention (DLP): Sensitive data redaction, PayPal Vault token masking, restricted PII storage and secure API key handling.
  • SSRF Protection: External URL validation and DNS resolution checks to prevent requests to private or restricted network addresses.
  • Session Isolation: Independent user sessions to prevent one user's activity from interfering with another user's session.
  • Rate Limiting and Security Headers: Token-bucket rate limiting on sensitive API endpoints and OWASP security headers.
  • Global Kill Switch: An emergency mechanism to revoke active purchasing mandates and prevent subsequent payment execution.

Another important part of this design is that the AI agent cannot override these controls, even if it encounters manipulated product descriptions or malicious instructions.

Challenges and What I Learned

The biggest challenge was not making an AI model find products or identify discounts. It was making sure that the system could actually act on that information without creating financial or security risks.

Some of the challenges I worked through were:

  1. Separating AI from payment authority: Designing Guardian as an independent policy engine instead of trusting the AI model to make financial decisions.
  2. Preventing duplicate purchases: Handling concurrent background workers, database transactions, payment retries and uncertain payment responses.
  3. Handling PayPal's asynchronous workflows: Understanding webhook verification, replay protection and payment reconciliation instead of assuming every payment request immediately returns a final result.
  4. Protecting user information: Making sure sensitive tokens, personal information and API keys were not exposed through frontend storage, API responses or application logs.
  5. Making the agent genuinely autonomous: Implementing background polling so that users do not need to keep the application open or manually check for price drops.

Working on BuyBound taught me that building an AI agent that can take real-world actions is very different from building a chatbot. The AI model is only one part of the system. The real challenge is everything around it: security, authorization, payment integrations, database consistency and handling unexpected situations.

I also learned how important it is to think about failure scenarios before they happen, especially when a system is allowed to spend money.

What's Next?

I see BuyBound as a step towards making agentic commerce more practical. Instead of constantly checking prices, comparing stores and manually completing purchases, users should be able to delegate these repetitive tasks to an agent while still having complete control over their money.

The original idea came from something as simple as missing sneaker deals while sleeping. But while building it, I realised that the bigger problem was not just finding a good deal. It was figuring out how to let an AI agent actually make a purchase safely.

I wanted to build something that lets me sleep without worrying about missing a good deal, but also without worrying about what an AI might buy with my money. That's exactly what I wanted BuyBound to solve.

Built With

Share this project:

Updates

Submission history