My submission for the Hacktoberfest Weekend Challenge — Build for a Friend.
I didn't have to think very hard about who I wanted to build for.
My dad.
He runs a wholesale business, and like many small business owners, a lot of his work happens inside Excel.
Invoices. Customers. Payment history. Outstanding amounts.
The data is there.
But there's one question that still requires a lot of manual work:
“Who should I call first?”
That's the problem I decided to solve this weekend.
This wasn't a problem I discovered while brainstorming a hackathon idea.
I'd seen it at home.
My dad would go through his spreadsheet, look at outstanding invoices, remember which customers usually paid late, check how much they owed, and then decide who needed a follow-up.
None of this is particularly complicated individually.
But when you're dealing with a lot of customers and invoices, it becomes repetitive.
And the frustrating part is that the information needed to make the decision already exists in the spreadsheet.
I kept thinking:
Could we just make the computer do the first pass?
Not make the decision for him.
Just help him decide where to start.
So I built Collection Radar.
Collection Radar is a local AI tool that takes an existing wholesale invoice spreadsheet and turns it into a collection priority list.
The workflow is intentionally simple:
Upload Excel → Learn from history → Predict risk → Prioritize invoices
For historical invoices, the model can learn from information such as:
Then, for current outstanding invoices, it estimates the likelihood of late payment.
The result is grouped into:
🔴 High Risk
🟠 Medium Risk
🟢 Low Risk
But I didn't want to stop at a probability score.
Imagine the model gives me:
Invoice A: 80% chance of being late
Invoice B: 65% chance of being late
At first glance, Invoice A seems like the obvious one to call.
But what if:
The business impact is very different.
So Collection Radar also calculates potential cash exposure:
Potential Exposure
= Late Payment Probability × Invoice Amount
Now the system isn't simply asking:
“Which invoice is risky?”
It's asking:
“Which risky invoice could have the biggest impact on cash flow?”
That's much closer to the decision my dad actually needs to make.
This project gave me an excuse to experiment with TabPFN, a model designed specifically for tabular data.
And this problem is almost entirely tabular.
There's no need to build a complicated chatbot around the data.
The input is structured:
Customer
Invoice Amount
Payment History
Credit Period
Outstanding Amount
...
And the thing we're trying to predict is also straightforward:
Paid Late = Yes / No
TabPFN learns patterns from the historical data and uses them to score current invoices.
One thing I deliberately didn't want to do was claim that TabPFN is automatically better than every other model.
That's something I want to measure.
For the next version, I'll benchmark TabPFN vs XGBoost using the same dataset and compare metrics such as ROC-AUC, F1, accuracy and runtime.
If XGBoost performs better, that's the result.
The point is to build something useful, not force the technology to win.
This is probably the most important product decision I made.
We're dealing with real business information.
Invoices contain financial data, customer information, payment behaviour and other details that shouldn't casually be sent to external services.
So I wanted Collection Radar to run locally.
The idea is:
The invoice data doesn't need to be sent to a cloud AI service for inference.
For a small business, I think that matters.
You shouldn't need an enterprise infrastructure team just to experiment with AI on your own spreadsheet.
That's why the UI is deliberately simple.
Upload the spreadsheet.
Map the columns.
Run the model.
Get the priority list.
The technology is behind the scenes.
The output should be understandable in a few seconds.
The current version is intentionally small:
Excel / CSV
│
▼
Data Preparation
│
▼
Local TabPFN
│
▼
Risk Probability
│
▼
Cash Exposure Calculation
│
▼
Collection Priority
The application is built with:
I've also kept the UI and ML logic reasonably separated so the interface can evolve without having to rebuild the model pipeline.
The biggest lesson from this project wasn't actually about machine learning.
It was about starting with a person instead of starting with technology.
Before this challenge, I would often approach projects by asking:
“What can I build with this new AI tool?”
This time I started with:
“What does someone I care about struggle with?”
That led me somewhere much more interesting.
My dad didn't ask for TabPFN.
He didn't ask for an AI assistant.
He didn't ask for a risk model.
He had a spreadsheet and a repetitive problem.
I chose the technology after understanding the problem.
That changed the way I built the project.
The most personal part of this project is also the simplest.
I'd known about this problem for a while.
I'd watched my dad work with spreadsheets and manually decide which customers needed attention.
At some point I thought:
There has to be a better way to do this.
And then, like a lot of side-project ideas, it stayed in my head.
Until this challenge.
The Build for a Friend theme gave me the push to finally turn that idea into something real.
It's still a prototype.
It's not going to magically solve collections tomorrow.
But now I can actually put it in front of my dad and ask:
“Would this make your work easier?”
And I think that's a much better test than asking whether a demo looks impressive.
This is V1.
There are a few things I want to add next.
Compare:
TabPFN vs XGBoost
on the same historical data.
I'll measure:
Eventually I'd like to add:
And eventually, instead of only showing invoice-level risk, I'd like to show something like:
Customer F
Outstanding: ₹4.8L
Invoices: 7
Average Payment: 47 days
Late Payments: 5/9
Current Risk: 🔴 HIGH
That starts turning Collection Radar from a prediction tool into an actual collection assistant.
The project is open source.
GitHub:
https://github.com/aryan7412/invoice-py.git
I'd genuinely love feedback from people who run small businesses or work with accounts receivable:
What would you want an AI assistant to tell you when you open your invoice spreadsheet?
Because that's ultimately what I'm trying to build.
Not an AI demo.
Not another dashboard.
Just something that can look at a messy spreadsheet and say:
Built for my dad. ❤️