Built to order

Offline Bill Splitter Android App for Roommates with UPI Settlement Tracking

This project builds SplitBill, an offline-first Android app that lets roommates record shared expenses, split them equally or by custom shares, and see live who-owes-whom balances. A minimum-cash-flow engine reduces the full expense history to the fewest repayments, and every settlement is logged with its UPI transaction reference in a permanent on-device ledger — no account, server or internet needed. Suitable for B.E./B.Tech final-year projects in Computer Engineering, IT and Android app development.

Android GitKotlinLocalStorage persistenceAndroid StudioAndroid SDK · minSdk 24Room · SQLite on-device databaseMaterial Components for AndroidHTML · CSS · JavaScript demo appSoftware
Offline Bill Splitter Android App for Roommates with UPI Settlement Tracking — project thumbnail preview
More project photos (2)

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.

SYSTEM FLOW

4 components 7 connections

Live flow
Drag to explore
100%
userRoommate

Roommate recording expenses and logging UPI repayments.

Follow the working sequence

How it works

  1. Roommates are added to a group (name and share identity), stored as Member records in the local Room database.
  2. Each shared bill is recorded with a description, amount, payer and split type — equal across selected members, or custom per-person amounts.
  3. 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).
  4. A greedy minimum-cash-flow algorithm pairs the largest creditor with the largest debtor, emitting the smallest possible list of repayments.
  5. Money moves over any UPI app outside SplitBill; the payer then records the settlement in the app with the UPI transaction reference.
  6. 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.

Get a quotation