The problem
Roommates and hostel-mates split rent, groceries, electricity, Wi-Fi and food bills every month, yet most groups still track it all in chat messages or notebooks. The arithmetic drifts, someone always feels they overpaid, and month-end reconciliation turns into an argument. Existing splitting apps fix the maths but demand accounts and a constant internet connection — a real barrier in hostels with patchy Wi-Fi — and they treat the actual repayment as somebody else's problem: the UPI reference that proves a payment happened lives in a different app and is forgotten within days. SplitBill takes the opposite approach. It is an offline-first Android app where a group of roommates records every shared bill on one device, watches live balances update after each entry, and gets a settle-up plan containing the fewest possible repayments. Money itself moves over any UPI app; SplitBill records the UPI transaction reference against each settlement, so the ledger stays complete, private and auditable without ever touching the network.
Roommate recording expenses and logging UPI repayments.
Follow the working sequence
How it works
- Roommates are added to a group (name and share identity), stored as Member records in the local Room database.
- Each shared bill is recorded with a description, amount, payer and split type — equal across selected members, or custom per-person amounts.
- The split engine derives every member's net balance: total paid minus total share owed, adjusted by all recorded settlements (balances always sum to zero).
- A greedy minimum-cash-flow algorithm pairs the largest creditor with the largest debtor, emitting the smallest possible list of repayments.
- Money moves over any UPI app outside SplitBill; the payer then records the settlement in the app with the UPI transaction reference.
- The ledger appends the settlement permanently, balances update instantly, and the settle-up plan shrinks until everyone is even.
Tech stack:
- Kotlin
- Android SDK (minSdk 24)
- Room · SQLite (on-device database)
- Material Components for Android
- Android Studio
- HTML · CSS · JavaScript (companion web demo)
- localStorage (web demo persistence)
- Git
| Parameter | Value |
|---|---|
| Platform | Android, minSdk 24 (Android 7.0), targetSdk 34 (design target) |
| Local database | Room (SQLite), on-device only — no server component |
| Network dependency | None — zero network calls by design |
| Split types | Equal across selected members; custom per-person shares |
| Balance arithmetic | Net = paid − share owed ± settlements; always sums to zero (exact) |
| Settle-up algorithm | Greedy minimum-cash-flow creditor–debtor pairing (design target: fewest transfers) |
| Members per group | Up to ~20 (design target; larger groups stay correct but lists grow long) |
| APK size | Approximately 8–15 MB (expected) |
| Demo | Single-file HTML app, runs from disk in any modern browser |
Project features
- [Offline-first ledger] Every member, expense and settlement is stored in an on-device database — the app works in airplane mode with zero network calls and no login.
- [Equal and custom splits] Split a bill equally across the group, or assign custom per-person shares for expenses not everyone took part in (the app validates that custom shares total the bill).
- [Live who-owes-whom balances] Net balance per member is recomputed after every entry as (total paid − total share owed) adjusted by settlements, so the group always sees the current truth.
- [Minimum-transfer settle-up plan] A greedy cash-flow engine pairs the largest creditor with the largest debtor repeatedly, reducing the whole history to the fewest repayments.
- [UPI settlement ledger] Each repayment is recorded with payer, receiver, amount, date and an optional UPI transaction reference, forming a permanent, dispute-proof record.
- [One-tap settlement recording] Every suggested repayment carries an Autofill button that pre-fills the settlement form — confirm the UPI reference and the debt clears instantly.
- [Private by design] No accounts, no servers, no analytics — the group's financial data never leaves the device it was entered on.
What is included
- Complete Android source code (Kotlin + Room) with setup instructions
- Debug APK installable on any Android 7.0+ phone
- Single-file web demo implementing the same split engine and screens
- Room database schema and data-model documentation
- Project report PDF (background, methodology, architecture, screens)
- PPT presentation for final review
- Viva Q&A preparation document (local-first design, split algorithm, Room vs SQLite, UPI tracking scope)
- Downloadable project abstract PDF
Limitations & prerequisites
- Single-device ledger: the base build keeps the group ledger on one phone — if that phone is lost without a backup, the data is gone. Export/backup is the recommended mitigation.
- UPI tracking is record-keeping, not payment processing: the app never moves money and cannot verify a UPI reference; it records exactly what the user enters.
- Custom shares must total the bill amount — the app blocks saving until they do, which is deliberate but means split-second entry needs care.
- Display rounds to whole rupees; paise-level splits are stored but shown rounded.
- No multi-user sync in the base build — one shared device holds the group ledger; cloud sync across phones is future scope.
- Designed for groups up to ~20 members; the maths stays correct beyond that but the settle-up list gets long.
Frequently Asked Questions
Does it really work without internet?
Yes — completely. Members, expenses, balances and settlements all live in the on-device Room database (localStorage in the web demo). There is no login screen, no API call and no sync step; airplane mode changes nothing.
How does the settle-up plan use the fewest transfers?
The engine computes each member's net balance, then repeatedly pairs the person owed the most with the person owing the most, clearing the smaller of the two amounts. This greedy minimum-cash-flow pairing is the standard way to minimise repayment count, and the plan is recomputed live after every entry.
Does the app itself process UPI payments?
No — and that is a deliberate scope decision. Money moves in the user's own UPI app; SplitBill records the payment with its UPI transaction reference, date and parties, so the ledger proves what happened without ever touching money.
Can splits be unequal?
Yes. Alongside equal splits, any expense can carry custom per-person shares — for example a dinner three of four roommates attended. The app validates that the custom shares add up to the bill total before saving.
What will I receive with the project?
The full Kotlin + Room Android source, a debug APK, the single-file web demo, database schema docs, project report, PPT, viva Q&A notes and the abstract PDF — everything needed to demonstrate, explain and defend the build.
Is this project suitable for a final-year project?
Yes — for Computer Engineering, IT and Android-focused programs. It demonstrates mobile UI design, local database modelling with Room, algorithm implementation (minimum cash flow), offline-first architecture and honest scope control around payments. Suitable for B.E./B.Tech final-year projects in Computer Engineering, Information Technology and Android app development.
Components & software requirements
- Kotlin
- Android SDK (minSdk 24)
- Room · SQLite (on-device database)
- Material Components for Android
- Android Studio
- HTML · CSS · JavaScript (companion web demo)
- localStorage (web demo persistence)
- Git
Delivery information
Built-to-order project. Delivery timeline is shared after order confirmation based on current queue.
Support terms
Complete documentation, setup guide, and viva preparation included. Support for setup and explanation provided.
Download free synopsis (PDF)
Enter your name and email — the synopsis PDF downloads immediately. We may send occasional project updates; no spam, unsubscribe anytime.