Building a Local-First Financial IDE: How I forced Gemini AI to do strict Double-Entry Accounting

I got tired of accounting software that feels like a slow, cloud-based spreadsheet from 2010.
As a developer, I spend my day in VS Code—it's fast, keyboard-driven, and local. I wanted my financial tools to feel the exact same way. So, I decided to build Finance-OS under my new studio, Auvira Systems.
My strict requirements were:
Zero Cloud Database: Financial data is sensitive. It should live in the browser, not on my servers.
Double-Entry Ledger: It had to be mathematically rigorous. No "editing" history, only reversals.
AI Command Bar: I wanted to type "Paid $50 for AWS hosting" and have the system automatically balance the books.
Here is how I architected it using React 19, Vite, and Gemini, and the massive technical hurdles I ran into along the way.

1. The Local-First Architecture The biggest paradigm shift was dropping Postgres/MongoDB. Instead, the entire application state—every transaction, account, and predictive forecast—lives in the user's browser using localStorage (and eventually IndexedDB for scale). The benefit? Zero latency. When you switch between the Chart of Accounts and the Forecasting Engine, it's instant. The challenge? Data portability. To solve this, I built a "Sovereign Vault" feature. Users can export their entire ledger as a single, encrypted JSON file and import it on another machine. You own your database.
2. Forcing an LLM to do strict accounting This was the hardest part. LLMs are notoriously bad at math and strict formatting. If the AI hallucinates a number, a double-entry ledger (where Assets = Liabilities + Equity) will break instantly. To fix this, I used Google Gemini as a stateless parser, not a database. When a user types a command, the app sends it to a stateless proxy. The prompt strictly enforces a JSON schema:

// The AI is only allowed to return this structure
interface AIResponse {
  debitAccount: string;
  creditAccount: string;
  amountInCents: number; // NEVER use floats for currency!
  description: string;
}

The Golden Rule: The AI does not touch the ledger. It only suggests the JSON payload. The local React application catches the JSON, verifies that the accounts exist, ensures the debits equal the credits, and then commits the transaction to the local state.
If the AI hallucinates, the local TypeScript logic rejects it.

1. The "Privacy Shield" (A fun UI detail) Because the app is local, I found myself using it in coffee shops. But having my runway and cash burn visible on my screen in public was stressful. I built a global "Privacy Shield" toggle. When activated, it applies a Tailwind blur-md and reduced opacity to all sensitive financial integers across the entire app.

// A simple but highly effective UI pattern
<p className={`text-2xl font-mono ${isPrivacyMode ? 'blur-md opacity-50' : ''}`}>
  {formatCurrency(totalCash)}
</p>

Try it out (No Sign-up Required)
Building complex, stateful applications entirely in the browser has been an incredible learning experience. We are just scratching the surface of what "Local-First" web apps can do.
Because there is no backend database, I built a frictionless Guest Mode. You can click the link below, jump straight into the IDE, and test the AI command bar yourself. Your data will stay on your machine.

👉 Try Finance-OS Live Here

I'd love to hear your thoughts on local-first architectures and if you've ever tried forcing an LLM to interact with strict mathematical systems!

I'm Chisom, founder of Auvira Systems. We build sovereign software for founders.