Offline Expense Tracker with Bank SMS Auto-Parsing (Android)

The Offline Expense Tracker with Bank SMS Auto-Parsing is an Android app that converts the transaction alerts already sitting in a user's SMS inbox into a complete spending record, without manual entry and without bank account access. Students make dozens of small UPI and card payments every week, and the usual advice — record every expense in an app — collapses within days because opening an app after each payment is friction nobody sustains. Money leaks through food delivery, travel and purchases that are never recorded anywhere. This app removes the friction at its source: with the user's explicit permission, it reads incoming bank SMS through Android's READ_SMS permission, and a rule-based parser extracts the amount, merchant and date from each alert's wording, filing each expense into an offline Room database under the right category. No internet, no servers, no credentials. OTP messages are detected and discarded, credits are filed as income, and cash payments use a manual-entry form.

When a bank transaction SMS arrives, Android delivers it to the app's registered broadcast receiver — but only after the user has granted READ_SMS permission on first launch, with a screen explaining exactly why it is needed. The receiver hands the raw text to the rule-based parser, which works in a fixed sequence: first it pulls the amount from an Rs/INR pattern that tolerates comma-grouped Indian formats, then it tries merchant patterns in order — "at X on", "to X on/via/done", "towards X", "UPI/name" — because different banks order the amount and merchant differently, and finally it normalizes the date. Messages containing "OTP" are dropped before any logging, and alerts containing "credited" are filed as income. The record goes into a local Room database; the repository exposes it as a reactive stream, so the dashboard's monthly totals, category donut and merchant rankings refresh on every insert — fully offline.

1. On first launch the app shows a permission rationale screen and requests READ_SMS; if denied, the app falls back to manual entry and the SMS features stay disabled.
2. A broadcast receiver registered for incoming SMS forwards each new message's raw text to the parser service, still entirely on-device.
3. The parser extracts the amount first (Rs/INR pattern, comma-grouped formats), then tries merchant patterns in sequence — amount-first and merchant-first orderings are both covered — then normalizes the date.
4. Messages with OTP keywords are discarded before logging; alerts containing "credited" are typed as income; everything else becomes a debit expense.
5. The merchant is matched against category rules (food-delivery senders → Food, UPI names → Transfers); unmatched merchants land in Other for the user to reassign.
6. The structured record is inserted into the Room database; the repository's Flow stream recomputes monthly totals, category aggregates and merchant rankings reactively.
7. The SMS inbox screen displays every alert with its extracted amount, merchant, date and verdict (auto-logged, filed as income, or skipped).
8. Cash expenses are added through the validated manual form and flow through the same repository into the same dashboard.

Tech stack:

• Kotlin · Android SDK (minSdk 26)
• Room database · Coroutines + Flow
• READ_SMS · BroadcastReceiver
• Regex SMS parser · rule-based · no ML
• MPAndroidChart · Canvas charts
• Material 3 components
• Git version control

The app is built around four capabilities that remove every excuse for not tracking money. First, SMS inbox auto-import: a broadcast receiver captures transaction alerts the moment they arrive, so expenses are logged before the user even opens the app. Second, a rule-based parser that genuinely reads bank wording — it extracted amount, merchant and date correctly from 15 of 15 sample SMS formats in the demo build, tells debits from credits, and refuses OTP messages. Third, a fully offline Room database with reactive queries, so the ledger, charts and category totals update live with zero network calls. Fourth, an editable category engine: merchant rules assign Food, Travel, Shopping and more automatically, and any category can be renamed or recoloured. Around these sit a manual-entry form for cash payments, an SMS inbox screen that shows each alert with its parsed fields, and on-device charts that keep the whole picture private.

• [SMS inbox auto-import] A broadcast receiver on Android's SMS_RECEIVED action captures transaction alerts the moment they arrive and forwards the raw text to the parser — expenses are logged before the app is even opened.
• [Rule-based SMS parser] A fixed pattern sequence extracts the amount (Rs/INR, comma-grouped Indian formats), then the merchant ("at X on", "to X on/via/done", "towards X", "UPI/name"), then the normalized date; measured 15 of 15 sample SMS formats parsed correctly in the demo build (design target ≥93%).
• [OTP and promo filtering] Messages containing OTP keywords are dropped before any logging; promotional and balance-only messages never create ledger entries.
• [Offline Room database] Transactions and categories live in a local Room database with entities, DAOs and reactive Flow queries; the app makes zero network calls.
• [Editable category engine] Merchant rules map senders to categories (food delivery → Food, UPI names → Transfers); any category can be renamed, recoloured and reassigned by the user.
• [On-device dashboard] Monthly totals, a category donut, merchant rankings and recent activity rendered natively — no server, no analytics SDK.
• [Manual entry for cash] A validated form (amount, merchant, category, date) covers cash payments that never generate SMS; manual entries carry a distinct flag.
• [Permission-first design] The app explains the SMS permission with a dedicated rationale screen and keeps working in manual mode if the user denies it; no bank credentials are ever requested.

• Complete Kotlin source code as an Android Studio project
• Debug APK for direct install and live demonstration
• 15-format sample SMS suite with the parser self-test from the demo build
• Architecture document with permission flow, parser pattern reference and data-flow diagrams
• Project report PDF (background, parser design, Room schema, privacy rationale, testing)
• PPT presentation for the final review
• Viva Q&A preparation document (SMS permissions, broadcast receivers, regex parsing, Room, MVVM)