Rivo：我為 Kuchipudi 舞蹈老師打造 AI 費用管理工具｜Hacktoberfest Week 2

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

The Story Behind Rivo: My Mam, Her Students, and a Birthday Gift

I'm an engineering student, and Kuchipudi is a big part of my life.

My dance teacher, teaches over 60 students. Like many independent dance teachers across India, she manages her academy while teaching classes, coordinating batches, communicating with parents, and keeping track of monthly fees.

And that's where I noticed a problem.

Every month, parents pay their children's dance fees through UPI apps such as Google Pay, PhonePe, and Paytm. Then they send payment screenshots and messages into the respective WhatsApp groups.

Sounds simple, right?

Except there are 60–70 students, multiple batches, different payment dates, missed months, and parents who sometimes pay for two siblings in a single transaction.

Imagine receiving a ₹3,000 payment for two siblings whose monthly fees are ₹1,500 each. The money might have arrived in one transaction, but the teacher still needs to account for two separate students and their respective fee obligations.

Now multiply that across dozens of students.

Someone has to open the screenshots, identify the student, understand which month the payment belongs to, check the amount, update the records, and remember who still owes money.

And a screenshot isn't proof that the money actually reached the bank account.

I kept thinking about how much time and energy this repetitive work could take away from teaching and dancing.

I wanted to build something that would make Mam's life easier. In fact, I initially imagined building it as a birthday gift for her.

Not another app that asks teachers to change their entire workflow. Not another complicated accounting dashboard that requires hours of manual data entry.

I wanted to build something that could do the routine work for her.

That idea became Rivo.

What I Built

Rivo is an AI-powered fee reconciliation and financial bookkeeping platform for independent dance teachers, music academies, tuition centres, and other small educational businesses.

Its goal is simple: turn messy payment evidence into organised fee records while keeping the teacher in control of the money.

Instead of manually reading every WhatsApp message and maintaining a notebook, a teacher can use Rivo to organise payment claims, identify students, reconcile transactions against bank statements, allocate fees, and see who still has outstanding dues.

The product is designed around a crucial distinction:

An AI model can extract payment details. It cannot declare that money has reached the bank.

Rivo separates the process into three stages:

1. Claimed payment: A parent sends a screenshot or message claiming to have paid.
2. Matched payment: The claimed transaction reference and amount match a transaction in an official bank statement.
3. Verified payment: The matched bank transaction is confirmed and allocated to the relevant student's fee obligation.

This distinction is especially important for financial software. An old screenshot, a forwarded receipt, or an AI-generated extraction should never be enough to mark a student's fees as paid.

Who would pay for it?

Rivo is designed for small academies that cannot justify expensive enterprise accounting software but still need reliable financial records.

My initial pricing hypothesis is ₹499–₹999 per month, depending on the features and academy size.

For a teacher managing dozens of students, the value isn't simply a prettier spreadsheet. It's fewer hours spent on repetitive bookkeeping, fewer missed fee obligations, easier sibling allocations, and better visibility into actual collections.

The long-term goal is to make the teacher's involvement minimal: routine reconciliation should be automated, with manual attention reserved for ambiguous or exceptional cases.

Demo

• 🌐 Live application: https://rivo-app-ss62.onrender.com/
• 💻 Source code: https://github.com/SK-Sathyavada-008/rivo

Try the interactive demo

The application includes a Phone Simulator that demonstrates a realistic WhatsApp-style workflow with simulated dance academy batch groups.

Click the Phone Simulator button in the navbar to explore the simulated parent messages and payment receipts.

You can also try the demo login:

• Email: teacher@naatyavedam.com
• Password: naatyavedam123

The simulator demonstrates the intended ingestion and extraction workflow; it does not connect to or read anyone's actual WhatsApp account.

How I Built It

Rivo is built as a TypeScript monorepo with a React frontend, an Express backend, MongoDB Atlas, and an open-weight AI model.

1. Open-weight AI with Google's Gemma

At the heart of Rivo is Google's Gemma 2 9B Instruct (gemma-2-9b-it), accessed through Groq's inference service.

Payment messages are rarely clean or consistent. A parent might write:

• "Paid 3000 for Keerthana and Roopa October fee 🙏"
• "Sent Rs 1500 for Alekhya UTR 428901248910"
• "Fee paid for both children."

These messages contain useful information, but they aren't structured financial records.

Gemma helps transform unstructured payment messages into structured fields that the application can validate:

• student_names
• claimed_amount
• claimed_transaction_reference
• confidence
• is_untrusted_candidate

For example, a message mentioning two students and ₹3,000 can be converted into a candidate record containing both names and the claimed amount.

However, the model's output remains untrusted. It does not directly update a student's verified payment status.

What happens when the AI endpoint fails?

A small academy shouldn't lose its workflow just because an external inference endpoint is temporarily unavailable.

Rivo includes a deterministic fallback extractor, extractFieldsWithRules, which recognises common Indian currency formats such as ₹, Rs. and /-, along with 12-digit UPI transaction references.

This fallback handles basic extraction without depending on the AI endpoint. Complex or ambiguous messages can still require further review.

The combination of open-weight AI and deterministic validation makes the system more resilient than an implementation that depends entirely on a single model response.

2. The sibling fee-splitting problem

This is one of the most important business rules in Rivo.

Suppose two siblings, Keerthana and Roopa, each owe ₹1,500 for October. Their parent sends a single ₹3,000 payment.

The bank statement contains one transaction, but the academy needs two separate fee allocations.

Rivo's allocation engine uses the relevant student, family, and fee-obligation records to distribute the matched transaction across the appropriate outstanding obligations.

The result is one bank transaction linked to two distinct allocations:

• Keerthana: ₹1,500
• Roopa: ₹1,500

The system must also account for situations such as outstanding fees from previous months, payments covering multiple months, and amounts that do not match the expected obligations.

These cases require explicit business rules rather than asking an AI model to make financial decisions on its own.

3. MongoDB Atlas and financial data integrity

Rivo uses MongoDB Atlas with Mongoose to manage the application's financial records.

The backend includes models for:

• Student
• FeeObligation
• PaymentEvidence
• PaymentTransaction
• PaymentAllocation
• AuditEvent

Every tenant-owned database operation is scoped to the authenticated teacher, helping prevent one academy from accessing another academy's records.

The reconciliation workflow also includes transaction deduplication, unique-index protections for transaction references, and audit logging.

This matters because uploading the same bank statement twice should not create duplicate collections or inflate the academy's revenue.

A financial ledger needs more than an AI model that usually gets the answer right. It needs predictable behaviour when the same evidence arrives twice, the data is incomplete, or something goes wrong.

4. React, Express, and Render

The frontend uses React 19, Vite, Tailwind CSS, Lucide icons, and Recharts for financial dashboards.

The backend uses Express and serves the compiled frontend from the same deployed web service.

Rivo is hosted on Render as a unified application, with the Express API and React single-page application served through one service.

This simplifies deployment and avoids many cross-origin cookie issues associated with maintaining separate frontend and backend origins.

5. Observability with Sentry

Financial reconciliation failures should not disappear silently.

Rivo includes Sentry integration for monitoring application exceptions and troubleshooting failures in the reconciliation workflow.

The objective is to make it easier to identify problems such as malformed bank CSV files, failed AI extraction requests, and unexpected reconciliation errors.

Production monitoring must also be configured carefully so that sensitive payment information and student data are not unnecessarily captured in telemetry.

Why Open Innovation Matters

The Hacktoberfest Week 2 prompt asks an important question: what does open innovation make possible that a closed approach might not?

For Rivo, the answer comes down to cost, adaptability, and control.

1. Making the economics work for small businesses

An independent dance teacher may collect modest monthly fees from dozens of students. A costly AI workflow can quickly make the product commercially impractical.

Gemma gives Rivo an open-weight model that can be evaluated, adapted, and served through different compatible inference setups.

Using an inference provider such as Groq makes experimentation accessible without requiring me to maintain dedicated GPU infrastructure.

The goal is to keep the AI component affordable enough that the subscription price makes sense for the teacher.

2. Building for a specialised problem

A generic chatbot can extract an amount from a sentence. Rivo needs to understand the relationship between a student, a family, a fee obligation, a claimed payment, and an actual bank transaction.

The model handles language interpretation, while deterministic application logic enforces the academy's financial rules.

Because Gemma's weights are available, the model can also be evaluated against real-world message patterns and potentially adapted for the language and payment conventions used by Indian educators.

The model is replaceable; the financial rules remain explicit and testable.

3. Privacy is an architectural responsibility

Payment evidence can contain names, transaction references, phone numbers, and other sensitive information.

Open-weight AI creates more flexibility over where and how inference runs, including the possibility of moving inference to a controlled or local environment.

However, using an open-weight model through a hosted provider does not automatically make the application private. That depends on the provider's data policies, configuration, and the application's handling of sensitive information.

Rivo's architecture aims to minimise unnecessary exposure, isolate each teacher's records, and keep payment verification separate from model predictions.

4. Graceful failure instead of total dependence

If an external model endpoint becomes unavailable, the deterministic extraction fallback can still handle supported currency patterns and transaction references.

This does not mean the entire application works offline. It means that a basic part of the extraction pipeline does not have to stop simply because the AI service is unavailable.

For a small business, that distinction matters.

Open innovation isn't just about using a model whose weights are available. It's about retaining the freedom to inspect, adapt, replace, and improve the technology as the product grows.

The Person I Want to Build This For

My Mam is the reason this project exists.

As a Kuchipudi student, I get to see the teaching side of a dance academy, but building Rivo made me think about everything that happens outside the classroom.

The preparation, the coordination, the parent messages, the fee tracking, and the administrative work all take time away from what a dance teacher actually wants to do: teach, practise, and help students grow.

I originally imagined this project as a birthday gift for Mam. I wanted to use what I was learning as an engineering student to solve a problem in a world I already knew and cared about.

That personal connection shaped the product's priorities.

I don't want Mam to learn complicated accounting software. I don't want her to abandon the UPI apps parents already use. And I don't want her to spend every month manually entering information that a system should be able to organise for her.

I want her to open Rivo and understand the state of her academy's fees without spending hours piecing together WhatsApp messages.

The real success of Rivo would be measured not by how much AI it uses, but by how much repetitive work it removes from a teacher's life.

My First User: From Personal Problem to Potential Customer

My first intended user is my own dance teacher.

She represents exactly the kind of person I want Rivo to serve: an independent educator who manages a growing student base without a dedicated accounting team.

The problem is concrete, the workflow is familiar, and the potential value is measurable in time saved and fewer reconciliation mistakes.

My initial pricing hypothesis is ₹499 per month, with the possibility of higher tiers for larger academies.

The next milestone is to put the application in Mam's hands, observe how it fits her actual monthly fee workflow, and measure whether it reduces her manual work without introducing new complexity.

One feature I particularly want to explore is one-click fee receipt generation, so a teacher can respond to parents with a clear payment status without repeatedly composing individual messages.

I am not claiming that Mam has already adopted or paid for Rivo. Her day-to-day workflow inspired the project, and validating it with her is the next important step.

If Rivo can save her hours every month, I will have achieved something more meaningful than building another portfolio project.

What's Next?

The current application establishes the core workflow, but there is more to do before Rivo can become a dependable tool for real academies.

My priorities are:

• Real-world validation: Test the workflow with Mam and identify where it fails to match actual academy operations.
• Less manual work: Reduce the teacher's involvement in routine processing while preserving control over ambiguous cases.
• Better reconciliation: Handle multiple-month payments, partial payments, sibling allocations, duplicate uploads, and unmatched transactions reliably.
• Clearer parent communication: Explore generating payment receipts and outstanding-fee reminders.
• Privacy and reliability: Strengthen data protection, auditability, and monitoring before expanding to more academies.

I want to grow Rivo based on what teachers actually need, rather than adding AI features simply because they sound impressive.

Prize Categories

Rivo is being submitted for the following partner categories, based on the technologies used in the project:

• 🏆 Best Use of Render — $200: Hosting the full-stack application as a unified web service.
• 🏆 Best Use of Gemma — $200: Using Google's open-weight Gemma model for structured extraction from unstructured payment messages.
• 🏆 Best Use of MongoDB Atlas — $100: Storing tenant-scoped student, fee, transaction, allocation, and audit records.
• 🏆 Best Use of Sentry Agent Tracing — $100: Monitoring application and reconciliation errors, with further scope to demonstrate detailed traces and agent execution.

Final Thoughts

Rivo started with a problem I could see in the life of someone who matters to me.

It has become an opportunity to combine engineering, open-weight AI, financial integrity, and a small-business use case that I genuinely care about.

There is something exciting about being able to take a frustrating monthly routine and ask, "Could I build something that makes this easier?"

That is what I want open-source AI to enable: not just bigger models or more impressive demos, but useful tools that solve specific problems for real people.

And if this little project eventually gives my Mam more time to teach Kuchipudi instead of tracking payment screenshots, it will have accomplished exactly what I hoped for when I started building it.

Built with ❤️ for my Mam, Indian dance gurus, independent educators, and the Hacktoberfest 2026 Open-Source AI Challenge.

Try Rivo | Explore the source code on GitHub

Team
@veerrr