Why Putting Financial Logic in the Database or UI Is a Disaster Waiting to Happen

When building an Android application, it is tempting to let the Android framework leak into your business logic.

You import android.content.Context into your calculation helpers to format currency strings. You use Android's TextUtils or Log utilities inside your accounting algorithms. Or even worse, you delegate financial calculation logic to complex SQLite database triggers and custom SQL queries.

It seems convenient at first. But as your project matures, this coupling creates two crippling problems:

1. Testing Becomes Painfully Slow: Tests that touch Android framework dependencies cannot run as pure JVM unit tests. They require heavy Robolectric environments or physical Android emulators, ballooning test execution times from seconds into minutes.
2. Platform Lock-In and UI Coupling: When calculation rules are intertwined with database schemas or UI state holders, refactoring a database table or redesigning a screen risks subtly altering how financial balances are computed.

Here is why FinLedger enforces a strict architectural boundary: all financial accounting logic must live in pure Kotlin domain engines with zero Android dependencies.

The Architecture of Domain Isolation

In FinLedger, the domain engine packages (com.finance.app.domain.engine.*) represent the mathematical heart of the application.

flowchart TD
    subgraph Frameworks["Android Framework Layer (Transient & Volatile)"]
        Compose["Jetpack Compose UI & Lifecycle"]
        Room["Room SQLite ORM & DAO Cursors"]
        Hilt["Dagger Hilt Dependency Injection"]
        Work["WorkManager Background Jobs"]
    end
    subgraph PureDomain["Pure Kotlin Domain Engine (Permanent & Isolated)"]
        direction TB
        LedgerEngine["LedgerEngine.kt:
Balance Computation & Parity"]
        PostingEngine["Posting.kt:
Double-Entry Delta Rules"]
        CCEngine["CreditCardBillingEngine.kt:
Statement Due Dates & Waterfalls"]
        BudgetEngine["BudgetEngine.kt:
Refund Netting & Burn Rates"]
    end
    Frameworks -->|"Depends Upon"| PureDomain
    PureDomain -.->|"Zero Imports of android.* or androidx.*"| Frameworks

Notice the dependency arrow:

• The presentation layer and data repositories depend on the domain engine.
• The domain engine depends on nothing except the Kotlin Standard Library and standard java.time classes.
• There are strictly zero imports of android.*, androidx.*, or Room database annotations inside domain calculation files.

The Testing Dividend: 1,570 Tests in 12 Seconds

The most immediate benefit of pure Kotlin domain isolation is testing velocity.

In FinLedger, verifying that accounting invariants hold across complex financial scenarios requires thousands of test assertions:

• Does lending money via a credit card correctly increase credit card liability while simultaneously establishing a loan receivable?
• Does an edited transaction date crossing a credit card closing boundary recompute statements without creating orphan balances?
• Does splitting an expense three ways with fractional paisa remainders balance to the exact cent without penny loss?

Because LedgerEngine.kt, Posting.kt, and CreditCardBillingEngine.kt are pure Kotlin:

• The test suite executes directly on the desktop JVM without booting an Android virtual machine or launching a mock instrumentation runner.
• All 1,570 automated unit tests execute in under 12 seconds.

flowchart LR
    subgraph SlowTesting["Framework-Coupled Testing"]
        direction TB
        T1["Instrumented Tests / Robolectric"] --> Mock["Boot Dalvik / ART Virtual Machine"]
        Mock --> SlowExec["1,500 Tests: 4 to 8 Minutes"]
    end
    subgraph PureJVM["FinLedger Pure Domain Testing"]
        direction TB
        T2["Pure JUnit 4 Test Suites"] --> JVM["Direct JVM Bytecode Execution"]
        JVM --> FastExec["1,570 Tests: Under 12 Seconds (100% Pass)"]
    end

When test suites run in seconds rather than minutes, developers run them continuously after every code change. Refactoring ceases to be terrifying. You can optimize algorithms, rewrite database queries, and overhaul user interfaces with complete confidence that your financial engine remains mathematically intact.

Why SQLite Triggers and Database-Level Math Fall Short

A common counter-argument is: "Why not let SQLite handle balances using database triggers and SQL views?"

While SQLite is a powerful relational engine, placing business calculation logic in database triggers introduces severe maintenance issues:

1. Opaque Debugging: Stepping through a broken balance update in Kotlin using standard debugger breakpoints is trivial; debugging a silent recursive SQLite trigger failure in an embedded mobile database is excruciating.
2. Schema Migration Hell: When business rules evolve, altering embedded SQLite triggers across existing user databases requires complex, error-prone Room migrations.
3. Loss of Immutability: Kotlin domain engines leverage immutable data classes and pure functions. Database triggers operate via mutable in-place side effects, making concurrency management and reactive UI state tracking significantly harder.

By keeping SQLite as a fast, encrypted dumb persistence store and delegating all math to pure Kotlin functions, the database does what it does best (storing relational rows securely) and Kotlin does what it does best (executing expressive, type-safe business logic).

Key Takeaway

Frameworks come and go; user interfaces are redesigned every few years; database libraries evolve.

Your core business logic—how money moves, how balances are computed, and how financial statements are generated—is the permanent soul of your software.

Isolating your calculations in pure Kotlin guarantees lightning-fast automated testing, zero platform lock-in, and uncompromising accounting reliability.

---

FinLedger is a privacy-first, offline-first personal finance application for Android that models bank accounts, credit cards, and cash without double-counting.

Explore FinLedger on Google Play: https://play.google.com/store/apps/details?id=com.devanshufinance.app