Why Local-First Desktop Apps Are Making a Comeback (And How to Build One)

The most interesting thing about Aurafy isn't that it's a trading journal—it's that it runs entirely on your machine, no cloud required. While everyone's building SaaS apps, this developer shipped a desktop tool that stores everything locally in SQLite, charges once instead of monthly, and never touches your sensitive trading data.

This "local-first" approach is quietly gaining momentum as developers and users grow tired of subscription fatigue and privacy concerns. But there's a deeper technical story here about why the Electron + React + SQLite stack is becoming the go-to choice for indie developers building premium desktop tools.

The Architecture That Actually Works

The beauty of this stack lies in its simplicity. Electron gives you cross-platform desktop apps using web tech, React handles the UI with familiar patterns, and SQLite manages data without any server complexity. But the real magic happens in how these pieces communicate.

Electron's two-process architecture is key here. The main process (Node.js) handles database operations and system access, while the renderer process (React) manages the UI. They communicate through IPC (Inter-Process Communication), which keeps your database secure and your UI responsive.

Here's how the database integration typically works:

1// In main process (main.js)
2const Database = require('better-sqlite3');
3const { app, ipcMain } = require('electron');
4const path = require('path');
5
6// Initialize DB in userData directory
7const db = new Database(path.join(app.getPath('userData'), 'trading.db'));
8

Then in your React components, you access this through a secure context bridge:

1// In preload.js
2const { contextBridge, ipcRenderer } = require('electron');
3
4contextBridge.exposeInMainWorld('dbAPI', {
5  getTrades: () => ipcRenderer.invoke('db-get-trades'),
6  addTrade: (trade) => ipcRenderer.invoke('db-add-trade', trade)
7});
8

Why This Matters Beyond Trading Journals

This isn't just about building trading apps. The local-first approach solves real problems that cloud-based tools create:

Performance: SQLite can handle massive datasets instantly. No API latency, no loading spinners for basic operations. For data-heavy applications like trading journals, note-taking apps, or project management tools, this feels dramatically faster than web apps.

Privacy by design: Your data never leaves your machine. In an era of data breaches and privacy scandals, this is becoming a genuine selling point. Financial data, personal notes, business information—users increasingly want control.

Monetization freedom: No ongoing hosting costs means you can charge once instead of monthly subscriptions. This is huge for indie developers who want to build sustainable businesses without the complexity of recurring billing and user management.

But there's also a technical advantage that's often overlooked: rapid prototyping. You can build and ship a working desktop app in days, not weeks. No backend deployment, no API design, no database hosting—just focus on solving the user's problem.

The Practical Implementation Details

Getting started requires handling a few gotchas that aren't obvious from tutorials:

Database packaging: SQLite files need special handling during builds. You can't put them in Electron's ASAR archive because it's read-only. Use extraResources in your electron-builder config:

1{
2  "build": {
3    "extraResources": [
4      {
5        "from": "assets/init.db",
6        "to": "init.db"
7      }
8    ]
9  }
10}

Native dependencies: The better-sqlite3 library includes native code that needs rebuilding for Electron's Node.js version:

1npm install better-sqlite3
2npx electron-rebuild

Database migrations: Plan for schema changes from day one. SQLite supports ALTER TABLE for most changes, and you can version your database with a simple user_version pragma.

When Local-First Makes Sense

This approach isn't right for everything. Collaborative tools, real-time sync, and web-based workflows still need cloud infrastructure. But for personal productivity tools, creative applications, and specialized professional software, local-first offers compelling advantages.

The trading journal example is perfect because it's intensely personal data that benefits from instant access and complete privacy. Similar opportunities exist for:

• Creative tools: Photo editors, writing apps, design tools
• Professional utilities: Time tracking, project management, specialized calculators
• Personal productivity: Note-taking, habit tracking, personal finance

Why This Matters

We're seeing a quiet rebellion against always-online software. Users are tired of subscriptions, privacy concerns, and depending on internet connections for basic productivity. The Electron + React + SQLite stack gives developers a proven path to build desktop apps that feel modern but work entirely offline.

For indie developers especially, this represents a different business model: build once, sell once, and let users own their tools and data. In a world of subscription fatigue, that's starting to look pretty appealing.

If you're considering a desktop app, don't automatically assume you need cloud sync. Sometimes the best feature is the one you don't build—and local-first might be exactly what your users didn't know they wanted.