Flow Expense Tracker: Why Developers Are Ditching Subscriptions

Stop paying $60/year just to know where your money went.

Every developer has been there. You sign up for yet another "free" finance app, sync your bank accounts, watch the onboarding animation, and then—bam—paywall. Want to see last year's trends? Upgrade. Multiple accounts? That's premium. Export your own data? Surprisingly, also premium. Your financial data, locked behind someone else's cloud, mined for "insights" they'll sell back to you as targeted ads.

What if I told you there's a Flow expense tracker that breaks every rule in the fintech playbook? No subscriptions. No data harvesting. No forced cloud sync. Just pure, offline-first financial tracking that puts you in complete control.

Built with Flutter by a solo developer who was fed up with the status quo, Flow is the open-source expense tracker that's making privacy-conscious developers switch in droves. It works fully offline, backs up to your own iCloud on your terms, and even lets you automate transactions through URI schemes. And did I mention it's absolutely free?

If you're tired of renting your own financial history, keep reading. This might be the last expense tracker you'll ever need.

What is Flow?

Flow is a free, open-source personal finance tracker built with Flutter—the cross-platform UI toolkit from Google. Created by sadespresso as a passion project during their free time, Flow represents a radical departure from mainstream fintech applications. While competitors chase recurring revenue and data monetization, Flow pursues something increasingly rare: genuine user empowerment.

The project lives at github.com/flow-mn/flow, where it has garnered attention from developers worldwide who appreciate its privacy-first architecture and beautifully simple UX. Unlike bloated alternatives that require account creation, phone verification, and endless permission requests, Flow asks for nothing except storage access to save your data locally.

What makes Flow particularly relevant now is the growing developer backlash against subscription fatigue and surveillance capitalism. The app arrives at a cultural inflection point where technical users increasingly demand data sovereignty—the right to own, control, and port their information without vendor lock-in. Flow answers this demand with a fully offline core, optional iCloud backups you configure, and export formats (CSV, PDF, ZIP/JSON) that ensure you're never trapped.

The "built with love, and Flutter" tagline isn't marketing fluff. Flutter enables Flow's genuine cross-platform reach—currently available on iOS and Android via beta releases, with Linux and macOS builds possible for those comfortable compiling from source. Windows support is theoretically achievable though untested. This polyglot platform strategy means your expense data travels with you regardless of ecosystem allegiance.

Perhaps most tellingly, Flow's development is transparently funded through voluntary donations rather than extraction. The maintainer personally covers Apple's $99/year Developer Program fee to keep the app on the App Store. That economic reality—sustainable only through community support—speaks volumes about the project's values versus venture-backed competitors.

Key Features That Set Flow Apart

Flow's feature set reveals a philosophy of intentional restraint combined with unexpected depth. Here's what makes it technically compelling:

True Offline-First Architecture Flow operates completely without internet connectivity. The only exception? Downloading currency exchange rates when you use multiple currencies—a reasonable compromise. Your transaction history, account balances, and attachments live in ObjectBox, a high-performance NoSQL database optimized for Flutter. This isn't cached cloud data pretending to be offline; it's genuinely local-first computing.

Infinite Flexibility in Account Modeling Unlike apps that restrict you to "checking," "savings," and "credit card," Flow supports unlimited accounts and currencies—including various cryptocurrencies. This matters for developers who hold crypto, maintain foreign currency accounts, or simply want granular budget segmentation. Each account maintains independent transaction histories with full audit trails.

Rich Metadata Attachments Every transaction supports categories, tags, file attachments, and optional geo-tagging. The geo-tagging implementation is particularly noteworthy: it's entirely opt-in, using your device's location services only when you explicitly request it. No background location harvesting, no "anonymized" movement profiles sold to data brokers.

Reflective Spending Analysis Flow includes built-in tools for spending reflection—not algorithmic nudges designed to modify behavior, but genuine data visualization that helps you understand patterns. The distinction matters: you're the analyst, not the analyzed.

Enterprise-Grade Data Portability This is where Flow exposes how restrictive competitors truly are:

• Fully recoverable backups in ZIP/JSON format—your complete database, structured and portable
• CSV exports for spreadsheet analysis
• PDF generation for records and sharing
• Periodic auto-backups to iCloud (configurable, not mandatory)

Zero Telemetry Guarantee Explicitly: no trackers, no analytics. In an era where "free" apps routinely ship with Facebook SDK, Google Analytics, and half a dozen attribution frameworks, Flow's clean network profile is practically revolutionary. Verify it yourself—monitor the app's connections. There aren't any.

URI-Based Automation For power users, Flow exposes a flow-mn URL scheme enabling programmatic transaction creation. Integrate with Shortcuts, Tasker, or custom scripts. This isn't advertised to casual users, but developers will immediately recognize the possibilities.

Real-World Use Cases Where Flow Dominates

Scenario 1: The Privacy-Paranoid Developer

You're building a security-focused product. You understand attack surfaces. The idea of uploading your entire financial history to a Silicon Valley server—encrypted or not—makes your skin crawl. Flow's fully offline operation means your spending patterns on AWS, VPN subscriptions, and hardware purchases never traverse networks unnecessarily. Your threat model just got simpler.

Scenario 2: The Multi-National Remote Worker

You invoice in USD, hold EUR for European contracts, keep GBP for UK operations, and speculate in crypto. Most trackers either don't support multi-currency properly or charge premium tiers for it. Flow's infinite currency support with live exchange rate downloads handles this natively. Your financial picture stays coherent without subscription upgrades.

Scenario 3: The Automation-Obsessed Power User

You already script everything: deployments, backups, notifications. Why manually enter recurring transactions? Using Flow's URI scheme automation, you generate flow-mn:///transaction/new? URLs from your invoicing system, cron jobs, or mobile Shortcuts. That monthly VPS charge? Automated. Client reimbursements? One tap from your project management webhook.

Scenario 4: The Data Hoarder Who Demands Exit Options

You've been burned before. A beloved app gets acquired, sunsets, or triples prices. Your data? Trapped in proprietary formats. Flow's ZIP/JSON backups contain your complete database schema. The CSV and PDF exports ensure compatibility with any future tool. This isn't just portability—it's financial data sovereignty as a design principle.

Step-by-Step Installation & Setup Guide

Mobile Installation (Recommended)

The fastest path to Flow is through official beta channels:

Android:

# Via Google Play Store (beta)
# Visit: https://play.google.com/store/apps/details?id=mn.flow.flow

# Or via Obtainium for direct GitHub tracking
# Obtainium link configured in README for automatic release tracking

iOS:

# Via App Store (beta)
# Visit: https://apps.apple.com/mn/app/flow-expense-tracker/id6477741670

Building from Source (Developers)

For those wanting desktop builds or custom modifications:

Prerequisites:

# Install Flutter (latest stable)
# https://flutter.dev/docs/get-started/install

# Verify installation
flutter doctor

# Android builds require JDK 11+
java -version

# iOS/macOS builds require Xcode
xcode-select --install  # if not present

Clone and Build:

# Clone the repository
git clone https://github.com/flow-mn/flow.git
cd flow

# Install dependencies
flutter pub get

# For running tests, install ObjectBox dynamic libraries first
bash <(curl -s https://raw.githubusercontent.com/objectbox/objectbox-dart/main/install.sh)

# Run tests
flutter test

# Build for your target platform
flutter build apk          # Android
flutter build ios          # iOS (macOS only)
flutter build macos        # macOS (macOS only)
flutter build linux        # Linux
flutter build windows      # Windows (untested)

Configuration Notes:

• ObjectBox requires native libraries; the install script handles this automatically for most platforms
• Desktop builds (Linux, macOS, Windows) are possible but not UI-optimized—the interface targets mobile form factors
• Windows specifically is untested; expect potential path or permission issues

REAL Code Examples: URI-Based Automation Deep Dive

Flow's URI scheme automation is where this expense tracker transforms from simple app to developer power tool. Let's examine the actual implementation patterns from the repository.

Example 1: Single Transaction via Query Parameters

The simplest automation pattern—add one transaction with URL-encoded parameters:

// The JSON structure you want to encode:
{
  "title": "Tous les jours",
  "amount": 42000.00
}

This becomes the following URI:

flow-mn:///transaction/new?title=Tous+les+jours&amount=42000.00

Implementation breakdown:

• Schema: flow-mn:// — registers with OS as Flow-specific
• Path: /transaction/new — routes to transaction creation screen
• Query params: Standard URL encoding for title and amount
• Currency: Determined by target account's configured currency (no override possible currently)

Practical usage: Generate this URL from your invoice system, expense report template, or bookmark it with pre-filled values for recurring entries.

Example 2: Batch Transaction Import via JSON Stringification

For bulk operations, Flow accepts a stringified JSON payload:

// The structured data before URL encoding:
{
  "t": [
    {
      "title": "Fresh blueberry piece",
      "amount": "13000.00",
      "transactionDate": "2011-12-05",
      "category": "Food",
      "tags": "My fave cafe",
      "accountUuid": "faa6d523-277f-46af-9493-67768e5b48ab"
    },
    {
      "title": "Caffe Mocha ice",
      "amount": "10000.00",
      "transactionDate": "2011-12-05",
      "category": "Drinks"
    }
  ]
}

After URI encoding, this becomes:

flow-mn:///transaction/new?json=%7B%22t%22%3A%5B%7B%22title%22%3A%22Fresh%20blueberry%20piece%22%2C%22amount%22%3A%2213000.00%22%2C%22transactionDate%22%3A%222011-12-05%22%2C%22category%22%3A%22Food%22%7D%2C%7B%22title%22%3A%22Caffe%20Mocha%20ice%22%2C%22amount%22%3A%2210000.00%22%2C%22transactionDate%22%3A%222011-12-05%22%2C%22category%22%3A%22Drinks%22%7D%5D%7D

Critical implementation details:

• Root key: "t" array contains all transactions (abbreviated for URI compactness)
• Amount as string: "13000.00" preserves precision; floating-point JSON numbers risk rounding
• Optional fields: Second transaction omits tags and accountUuid—Flow uses defaults
• Account targeting: accountUuid references specific account; omitting uses currently selected or default account
• Date format: ISO 8601 YYYY-MM-DD for unambiguous parsing

Developer power move: Generate this JSON from your time-tracking tool, commit messages (for project expense allocation), or receipt OCR pipeline.

Example 3: Generating URIs Programmatically

Here's how you'd construct these in practice:

// Dart/Flutter example for generating Flow URIs
import 'dart:convert';

Uri buildSingleTransactionUri(String title, double amount) {
  return Uri(
    scheme: 'flow-mn',
    host: '',           // Empty host for custom scheme
    path: '/transaction/new',
    queryParameters: {
      'title': title,
      'amount': amount.toStringAsFixed(2),
    },
  );
}

Uri buildBatchTransactionUri(List<Map<String, dynamic>> transactions) {
  final payload = jsonEncode({'t': transactions});
  return Uri(
    scheme: 'flow-mn',
    path: '/transaction/new',
    queryParameters: {'json': payload},
  );
}

// Usage
final coffeeUri = buildSingleTransactionUri('Morning coffee', 4.50);
// → flow-mn:///transaction/new?title=Morning+coffee&amount=4.50

final batchUri = buildBatchTransactionUri([
  {
    'title': 'Server hosting',
    'amount': '24.99',
    'transactionDate': '2024-01-15',
    'category': 'Infrastructure',
    'tags': 'AWS alternative',
  },
]);

Integration patterns:

• iOS Shortcuts: Create "Log Expense" shortcut that prompts for amount, constructs URI, opens Flow
• Tasker (Android): Trigger on notification from banking app, parse amount, auto-generate URI
• Webhook endpoint: Receive expense data from SaaS tools, redirect to Flow URI
• CLI tool: Shell script wrapping xdg-open or open with generated URIs

Advanced Usage & Best Practices

Backup Strategy: The 3-2-1 Rule Adapted Flow's auto-backup to iCloud is convenient but not sufficient. Implement:

1. Primary: iCloud periodic auto-backup (enabled in settings)
2. Secondary: Manual ZIP/JSON export to local storage monthly
3. Tertiary: Archive exports to separate physical or cloud location

The ZIP backups contain your complete ObjectBox database—restore by replacing the app's data directory.

Account UUID Discovery The batch transaction API requires accountUuid for targeting. These aren't exposed in the standard UI. To find them:

• Export a backup and inspect the JSON structure
• Or examine the ObjectBox database directly using ObjectBox Browser

Currency Exchange Rate Management Exchange rates download only when multi-currency is active and internet is available. For accurate historical reporting:

• Record transactions in original currency when possible
• Use exchange rate notes in transaction descriptions for manual rate tracking

Geo-Tagging with Privacy Geo-tags are stored locally only—never uploaded. For maximum privacy:

• Disable location permission entirely if unused
• Or enable only "While Using" to prevent background tracking
• Review geo-tagged transactions periodically; location data reveals patterns

Eny AI Receipt Parser Integration The companion service at eny.gege.mn enables photo-to-transaction automation. For developers, this represents a potential API integration point—watch for future programmatic access.

Comparison with Alternatives

The verdict? Flow sacrifices polished bank sync (by design—no Plaid integration means no credential sharing) for genuine ownership. If you value privacy, customization, and zero recurring costs over convenience features, the choice is clear.

FAQ

Is Flow really free? What's the catch? No catch. Flow is genuinely free and open-source under an OSI-approved license. The developer accepts donations to cover App Store fees, but functionality is never paywalled. Compare this to "free" apps that monetize your data—Flow's sustainability depends on community support, not extraction.

Can I sync between multiple devices? Not directly—by design. Flow is offline-first. Use iCloud backup/restore to transfer data between devices, or manually export/import. For developers, this is a feature: no server compromise can expose your financial data because there is no server.

How do I contribute or report bugs? Visit github.com/flow-mn/flow and review the Contribution Guide and Code of Conduct. The project welcomes code contributions, translations, and testing.

Is my data secure without cloud sync? Arguably more secure. Your data never transits third-party servers, never sits in databases you don't control, and never faces mass-extraction via API breaches. Physical device security (passcode, encryption) becomes your threat model—far simpler than cloud threat modeling.

Can I import from other expense trackers? Flow supports CSV import; format your existing exports to match expected columns. For proprietary formats, community converters may exist—check GitHub Issues. The open-source nature means you can also write custom migration scripts against the ObjectBox schema.

What happens if development stops? Your data remains fully portable via ZIP/JSON exports. The Flutter codebase remains buildable. Unlike SaaS tools that vanish with their servers, Flow's local-first architecture ensures no vendor lock-in—ever.

Does Flow support bank connection or automatic import? No, and this is intentional. Bank APIs require credential sharing, introduce security surfaces, and typically demand paid middleware. Flow prioritizes manual entry with excellent UX and automation you control via URI schemes over opaque integrations.

Conclusion: Reclaim Your Financial Data

Flow isn't just another expense tracker. It's a statement about how personal finance software should work in an era of surveillance capitalism and subscription exhaustion. By choosing github.com/flow-mn/flow, you're not just getting a free tool—you're voting for data sovereignty, transparent development, and user-respecting design.

The technical implementation impresses: Flutter-powered cross-platform reach, ObjectBox for genuine offline performance, URI automation for developer extensibility, and export formats that ensure you're never trapped. The social model inspires: a solo maintainer funding App Store presence through community support rather than extraction.

Is Flow perfect? No—desktop UI needs work, bank sync is intentionally absent, and you'll invest time in manual entry or automation setup. But perfection was never the goal. Freedom was.

Your move. Download the beta from Google Play or the App Store. Star the repository. Consider buying the developer a coffee. And finally—track your expenses without trading your privacy.

Because your spending patterns shouldn't be someone else's business model.