FYRA Finance
A Private, Offline-First Double-Entry Ledger System
Problem
Modern digital trackers require reading private messages and invoices, syncing transactions to central servers. This leads to client privacy intrusion, statement redundancy, and multi-directional bill friction.
Solution
Built FYRA, an advanced personal finance ecosystem developed specifically for isolated client-side environments. It delivers a robust client-side financial shield: keeping files encrypted inside keystore envelopes, and executing an offline netting engine.
Approach
Designed an offline-first Android application utilizing SQLDelight + SQLCipher, local OCR parsing with ML Kit, and Android Keystore AES-GCM encryption. Created a custom social split engine that nets overlapping group balances.
Architecture
Clean Architecture & MVI patterns with Jetpack Compose. ViewModel streams balances via StateFlow, and WorkManager executes background statement scanning and ingestion in a fully sandboxed environment.
Outcome
- Successfully netted group expenses reducing wire operations by 50%.
- Encrypted personal statement cache on-device using local Android Keystore.
- Implemented an interactive credit card accordion tracking wallet.
Case Study
Overview
FYRA Finance is a private, offline-first personal financial operating system (PFOS) built specifically for isolated client-side environments. It combines personal wealth monitoring, credit card accordion ledger management, multi-directional debt netting, and local OCR parsing under a zero-cloud sandbox architecture.
System Context & Problem Matrix
Modern digital tracking systems rely on continuous telemetry, scanning private user notifications, cards statements, and invoices. Traditional synchronizers leak private records to central repositories, resulting in:
- Severe Client Privacy Intrusion: Financial indicators are mined on host databases.
- Ecosystem Redundancies: Multi-card users holding distinct credentials struggle to correlate varying due frames, outstanding rates, and card limit bottlenecks.
- Multi-directional Obligation Friction: Group expenses shared among roommates or friends create direct, messy settlements rather than a consolidated netting matrix.
The Decentralized Offline Architecture
FYRA resolves these systemic failures by delivering a robust client-side financial shield:
- AES-GCM Encrypted Cache: Keeps files, credentials, and receipts secured inside local Android Keystore envelopes.
- Stateful Permission Controls: Provides visual on-off overrides for SMS triggers, push receivers, and local biometric vaults.
- Unified Import Logs: Ensures full visibility of imports, duplicates caught to block double countings, and partial parsing errors.
- Interactive Credit Cards Wallet: Configures custom structured card heights with a polished click-safe accordion drawer to optimize limit indicators and statement tracking.
- Bilateral Netting Engine: Eliminates direct split debt vectors and establishes a clean, minimalist netted hierarchy among social groups.
Deep Architecture & Stack
Built on standard Clean Architecture and Model-View-Intent (MVI) design patterns, FYRA compiles a secure offline execution sandbox:
- Jetpack Compose Layer: Adapts perfectly to vertical mobile card sheets, foldable display grids, and expanded tablet split-details views.
- ViewModel Channels: Employs StateFlow and Kotlin Flow to stream balances, encrypted statement receipts, and instant transactions feed securely on main threads.
- Local Cores DBMS: Holds schemas for account entities, transaction entries, and receipt profiles using SQLDelight and SQLCipher for encrypted local storage.
- Offline OCR Scanner: ML Kit and CameraX capture and parse local invoices and statement proof blocks entirely on-device with zero network requests.
Social Netting Algorithm
Rather than requiring individual peer payments, FYRA solves optimization equations to net overlapping balances. For example:
- User A spends ₹15,000 for dinner on a card. Normally: B owes A ₹5,000, C owes A ₹5,000.
- B separately holds receipt debts of ₹3,000 from A. C owes B ₹2,000.
The engine netting model compiles the entire network state:
- User C: Pays ₹7,000 to A (Net)
- User B: Pays ₹2,000 to C (Net)
- User A: Net recipient of consolidated balances
This reduces the total transaction operations from 4 separate wire operations to exactly 2 settled transfers, achieving a 50% netting efficiency increase.