PayRescue

Front Page
Calender
List Of Legal Generated notices
Proof of Paypal integration perectly executed
Automated/Manual Gmail reminder page

Inspiration

We have known this problem for as long as we can remember , Our family runs small businesses and with time we became well aware of THE LITTLE DIARY that is in the drawer of the shop.

A lot of small businesses face situations where customers delay payments, miss installments, or sometimes even refuse to pay. Most of these businesses still manage their invoices on Excel sheets, keep payment records manually, and have to constantly remind buyers about pending amounts.

We noticed that there are already many platforms that help businesses accept payments, but very few actually help them when the payment is delayed or stuck. And people need to either call the people themselves to remind them or have a person call them which delays the task at hand.

That's where the idea PayRescue AI came in.

We wanted to build something that doesn't just process payments, but also helps sellers manage pending payments, follow up with buyers, and keep their important documents organized in case a dispute happens.

Our idea was simple: What if businesses had one platform that could help them manage everything from raising an invoice to recovering the payment?

What it does

PayRescue AI is a full-stack payment recovery platform that helps sellers manage their invoices, track pending payments, and handle recovery related tasks from one place.

Instead of switching between Excel sheets, emails, and different payment applications, sellers can manage most of their payment-related activities through a single dashboard.

Here's what we built:

Seller Dashboard: Shows the total outstanding amount, overdue invoices, upcoming payments, and other important details.
Buyer and Invoice Management: Sellers can add buyers, create invoices, and keep track of their transactions.
Installment Tracking: Sellers can divide payments into installments and monitor which payments are completed or overdue.
AI-Assisted Reminders: The platform helps generate payment reminder messages depending on the invoice and pending amount. It can use an AI API when configured, or generate template-based reminders.
PayPal Integration: We added PayPal Sandbox API support for creating and capturing payments. There is also a demo payment mode for testing without actual transactions.
Dispute Management: If a buyer doesn't pay, sellers can maintain a record of the issue and organize relevant transaction details.
Evidence Vault: Important documents like purchase orders, transport receipts, and other transaction evidence can be uploaded and stored.
Duplicate Payment Protection: We implemented idempotent payment handling so the same payment event doesn't update the invoice balance multiple times.

The main thing that makes PayRescue different is that it focuses on what happens after a payment gets delayed, instead of focusing only on receiving payments.

How we built it

We built PayRescue AI as a full-stack web application using technologies that were suitable for both development and local deployment.

For the frontend, we used React.js with Vite, along with JavaScript, HTML, and CSS. React helped us create the dashboard, invoice forms, buyer management screens, and other interactive parts of the application.

For the backend, we used Node.js and Express.js. We created REST APIs to handle invoices, buyer information, payments, installments, reminders, and dispute records.

We chose SQLite as our database because we wanted something lightweight that could work locally without needing to set up a separate database server.

For payments, we implemented support for PayPal Sandbox REST APIs, including order creation and payment capture. We also built a local demo payment workflow so we could test the recovery features without depending on PayPal every time.

We added optional OpenAI API integration for generating payment reminders and assisting with recovery-related documentation. When an API key isn't configured, the application can still generate reminders using predefined templates.

We also used SHA-256 hashing for uploaded evidence files and implemented idempotency checks for payment processing.

Finally, we used Docker and Docker Compose to containerize the application.

One thing we specifically wanted was that someone should be able to download the project, configure the environment variables, run Docker, and start using the application without installing a lot of extra things.

Challenges we ran into

Building PayRescue AI wasn't as straightforward as we initially thought. One of our biggest challenges was handling payment transactions correctly.

For example, what happens if the same payment request or notification is received twice? We obviously didn't want the invoice balance to get updated two times for a single payment. So we had to work on idempotency and transaction validation to make the payment handling more reliable.

Another challenge was PayPal webhook integration.

Initially, we thought connecting PayPal would be pretty simple, but then we realized that PayPal webhooks require a publicly accessible HTTPS endpoint. Since we were running everything locally, this became a problem.

We handled this by keeping webhook integration optional and creating a demo payment mode that works without it.

We also faced some issues while setting up Docker. At one point, the React application wasn't compiling because of a JSX syntax error, and later the Docker container was restarting because of startup configuration issues.

Debugging these errors took some effort, but it helped us understand how Docker actually builds and runs an application.

Another challenge was figuring out how much of the recovery process should be automated. Since payment disputes can involve sensitive financial and legal information, we decided that the system should assist users with documentation instead of making legal decisions automatically.

Accomplishments that we're proud of

The thing we're most proud of is that we managed to bring different parts of the payment recovery process into one application.

Initially, the idea was mainly about tracking unpaid invoices. But as we started working on it, we realized that payment recovery involves much more than just sending reminders.

We ended up building a platform where sellers can manage buyers, generate invoices, track installments, record payments, upload evidence, and maintain dispute-related information.

Some accomplishments we're particularly happy with are:

Building a working full-stack application using React, Express, and SQLite.
Creating a dashboard that helps sellers understand their outstanding payments.
Implementing payment idempotency to reduce the risk of duplicate ledger updates.
Adding support for PayPal Sandbox payments.
Developing an evidence management system with file integrity checks.
Creating AI-assisted and template-based payment reminder workflows.
Running the application locally using Docker without needing a cloud database.

We also liked that we could simulate payments and overdue scenarios without having to use real money.

For us, turning an idea into something that actually runs and can be demonstrated was probably the biggest achievement.

What we learned

This project taught us quite a lot about how financial applications actually work behind the scenes.

Before starting, we mainly thought that integrating a payment API would be the difficult part. But while building the application, we realized that keeping payment records consistent and handling different transaction scenarios is just as important.

We learned more about REST API development, frontend-backend communication, database management, and transaction handling.

Working with Docker also helped us understand containerization better. We faced multiple errors during the build and startup process, and fixing them helped us become more comfortable with debugging applications.

We also got a better understanding of how PayPal Sandbox works, especially the difference between creating an order, capturing a payment, and receiving webhook notifications.

Another important thing we learned was that adding AI to a project only makes sense when it solves an actual problem.

Instead of simply adding a chatbot, we tried to use AI where it could be useful, like helping sellers draft reminders and organize recovery-related information.

Overall, this project helped us connect the technical concepts we learn in college with a problem that businesses face in real life.

What's next for PayRescue

We have built the initial version of PayRescue AI, but there are still many things we want to improve.

The first thing we want to add is automatic email and SMS reminders.

Right now, the application can generate reminders, but we want sellers to be able to send them directly to buyers and schedule follow-ups automatically.

We also want to make the AI features more useful.

For example, in future versions, the system could analyze a buyer's previous payment behavior and identify which invoices might have a higher chance of becoming overdue.

Another feature we want to work on is AI-based document analysis. Instead of manually entering every detail, sellers could upload invoices, purchase orders, and transport receipts, and the system could extract the relevant information.

We also plan to improve the PayPal integration by thoroughly testing webhooks, refunds, and payment reconciliation.

For disputes, we want to develop a better system that can prepare organized evidence files and draft documents for review by legal professionals.

Eventually, we would like to deploy PayRescue AI on the cloud so multiple businesses can access it securely without running the application locally.

Our long-term goal is to make PayRescue a platform that helps small businesses spend less time chasing payments and more time actually growing their business.

Because making a sale is important, but getting paid for it is what really matters.

Built With

Updates

Shubhi Gupta started this project — Nov 12, 2026 04:17 AM EST

Leave feedback in the comments!