DEV Community: Asiv

Building a Zero-Telemetry Android Vault: Flutter, Encrypted SQLite, and Why We Ditched Cloud Sync

Asiv — Sat, 26 Sep 2026 14:17:38 +0000

When building personal finance software, standard engineering advice says:

"Spin up Supabase, plug in Plaid for automatic bank scraping, and charge $12/month."

We rejected that premise entirely when architecting MyneWallet.

Handling money data requires extreme operational discipline. If your remote server stores a user's transaction ledger, you are one zero-day exploit, misconfigured S3 bucket, or sub-processor breach away from exposing their entire financial identity.

Here is the engineering breakdown of how we built an offline-first, zero-telemetry financial vault in Flutter—handling decimal currency math without floating-point errors, deterministic envelope allocation, and client-side web verification.

The Core Constraint: Zero Network Permissions

The cleanest way to guarantee data privacy is architectural, not legal:

No Firebase SDKs.

No Mixpanel, Segment, or analytics beacons.

No network requests carrying payload figures.

Every ledger write, balance reconciliation, and category balance calculation runs strictly inside an on-device SQLite database encrypted with SQLCipher.

[User Device]
└── Flutter UI Layer
└── Integer Math Engine
└── Encrypted SQLite Database (On-Device Storage Only)
The app operates identically in airplane mode because it has zero remote dependencies.

Handling Currency Math Without Floating-Point Traps

In financial software, standard IEEE 754 floating-point operations (0.1 + 0.2 = 0.30000000000000004) are unacceptable. Over multi-year ledgers with thousands of line items, floating-point rounding errors compound into balance drift.

To guarantee precision, all monetary values in our SQLite database are stored as 64-bit Integers representing minor units (cents):

Dart
class Money {
final int minorUnits; // $14.99 is stored as 1499 integer cents

const Money(this.minorUnits);

Money operator +(Money other) => Money(minorUnits + other.minorUnits);
Money operator -(Money other) => Money(minorUnits - other.minorUnits);

String toFormattedString(String currencySymbol) {
final double value = minorUnits / 100.0;
return '(currencySymbol){value.toStringAsFixed(2)}';
}
}
By enforcing integer arithmetic, our envelope auto-allocation algorithms never lose a single cent to binary rounding residue.

The Envelope Allocation Engine

Under a True Zero-Based Budgeting (ZBB) model, every single unit of income must be assigned a job before the month begins:

💡 The Core Equation:

To Assign = Unallocated Cash − Total Assigned Envelopes

When income arrives, our deterministic Auto-Assign engine allocates funds through a three-stage priority pipeline:

Fixed Monthly Obligations: Rent, utilities, debt minimums.

Sinking Fund Targets: Amortized monthly allocations for annual commitments.

Flexible Spending: Groceries, personal allowances, dining.

If a category overspends, the ledger flags the exact variance and prompts the user to reallocate from another envelope, keeping the core ledger balanced to zero.

Client-Side Web Companion & Open Methodology

Alongside the mobile app, we built 10 standalone client-side financial calculators that run in the browser without cookies, tracking scripts, or server requests:

Web Suite: https://thebrinklabs.com/tools/

Formulas & Verification Gates: https://thebrinklabs.com/methodology

Every formula, rounding rule, and mathematical test case is published openly, allowing users to verify our math directly in their browser's Network tab before downloading the mobile app.

Conclusion & Open Discussion
Privacy in software is often treated as a marketing bullet point. In practice, it is a set of hard architectural trade-offs: no password reset flows, no remote sync fallbacks, and total reliance on robust local database integrity.

Google Play: https://play.google.com/store/apps/details?id=com.thebrinklabs.mynewallet.expensetracker

Architecture Docs: https://thebrinklabs.com/

How are other indie developers handling local encrypted storage and offline state management in Flutter? Let's discuss in the comments below!

Why I stripped Firebase and built an offline-first budget vault on Flutter & SQLite?

Asiv — Wed, 09 Sep 2026 13:18:51 +0000

I am a Banking Professional, and like many developers and finance enthusiasts, I hit a breaking point with modern personal finance software.

Almost every mainstream budgeting app (YNAB, Monarch, Copilot) operates on the exact same playbook:

Mandatory cloud account synchronization.
Third-party bank scraping integrations (Plaid/Yodlee).
Recurring, aggressive annual subscriptions ($100+/year).
Invasive corporate telemetry tracking your spending behavior.

I wanted a personal financial command center with absolute data sovereignty. That led to engineering MyneWallet around a strict architectural constraint: the network is disabled by default.

Here is why we tore out cloud infrastructure, stripped Firebase, and built a local-first financial engine on Flutter and SQLite.

The Problem with the Default "Firebase Stack" for Finance

When bootstrapping a mobile app in Flutter, the default advice is always: Throw Firebase Auth, Firestore, and Firebase Analytics at it.

For a privacy-first financial vault, that default stack is a liability:

- Third-Party Telemetry & Surveillance: Even if you don't actively log sensitive transactions, including tracking SDKs links device IDs, IP addresses, and behavioral metrics back to corporate ad networks.
- Binary Bloat & Cold Start: Stripping Firebase SDKs immediately trimmed megabytes off the release APK and reduced cold-start initialization to under 300ms.
- The "Always-Online" Trap: When your app relies on cloud sync, an offline subway ride or poor reception turns a 2-second expense entry into a spinning loader.

We decided that a financial breach cannot expose our users' data if we don't have servers to breach in the first place.

Key Architectural Decisions

- On-Device SQLite Sandbox: The entire financial ledger resides in an encrypted SQLite database stored securely inside the Android OS application sandbox. No external servers, no account registration screens, and zero remote data storage.
- Strict Integer Mathematics: In fintech, 0.1 + 0.2 != 0.3 is an unacceptable failure mode. All currency calculations in MyneWallet are processed and stored as integer minor units (cents). Every ledger balance mutation runs in atomic database transactions, preventing rounding drift across multi-year projections.
- Zero Telemetry SDKs: There are no advertising SDKs, product trackers, or crash-reporting pipelines sending pings home. If a user turns on Airplane Mode, 100% of the app—including 60fps hardware-accelerated analytics—functions without friction.
- Client-Side Cryptographic Backups: Cloud backup is strictly opt-in to the user's personal Google Drive. The archive is encrypted locally on-device using AES-256 with randomized initialization vectors (IV) before any network socket is opened. We never hold the keys.
- True Zero-Based Budgeting (ZBB) Engine: Built strictly on the envelope methodology: every dollar gets a destination. We engineered a real-time Auto-Assign engine and an honest "Safe to Spend" metric that isolates liquid cash from money already committed to future bills or emergency reserves.

Why We Killed the Subscription Model

Modern software suffers from massive subscription fatigue. Paying monthly rent just to track what you already earned makes no financial sense.

The core tracking and budgeting engine in MyneWallet is free forever with zero ads. For power users wanting multi-year analytics, spending heatmaps, and Sankey cash-flow diagrams, it’s a single One-Time Lifetime Unlock. Buy it once, own it for life.

- Google Play: https://play.google.com/store/apps/details?id=com.thebrinklabs.mynewallet.expensetracker
- Web & Architecture Manifesto: https://thebrinklabs.com/mynewallet/

We also deployed 6 client-side, zero-tracking financial instruments on the web (Zero-Based Budget Allocator, Subscription Bleed Audit, Debt Payoff, Net Worth Calculator):
https://thebrinklabs.com/tools/

Over to You

I would love feedback from the community on our local-first constraints:

How do you approach offline-first database synchronization without compromising privacy?
Have you ditched third-party telemetry in your own apps?

I’ll be in the comments answering questions and discussing the Flutter/SQLite architecture!