My Chaotic Search for the Perfect Finance Tool (And Why I Ended Up With a Text File)
A developer's honest post-mortem of every finance app that failed them — and how Plain Text Accounting finally made sense of it all.
I have tried every personal finance tool available to the Indian developer. I am not proud of this. I am also not cured.
At some point over the past few years, I have installed, configured, imported data into, and subsequently abandoned: mobile apps with cheerful UX and zero data ownership, a self-hosted powerhouse that wanted me to also become a sysadmin, and a desktop application whose UI was clearly designed by someone who peaked in 2003.
This is the story of why I gave up on all of them — and why my finances now live in a plain text file that I push to Git.
The Rogues’ Gallery
Let me be precise about what failed and how, because “I didn’t like it” is not a post-mortem.
The Apps: Beautiful, Useless
The Indian fintech ecosystem has produced some genuinely impressive apps. The UPI integrations are fast. The SMS parsing is almost magical — you buy a coffee and the app already knows about it before you’ve put your phone back in your pocket.
The problem is not the UX. The problem is what happens when you want to do something you want to do.
Want to split a transaction across two categories? Good luck. Want to track a Systematic Investment Plan against a custom benchmark? That feature is “coming soon” and has been for two years. Want to export your data in a format that isn’t a CSV with seven mystery columns? Here is a PDF.
The apps model their understanding of money. The categories, the reports, the dashboards — all of it is built around what the app team decided you need to know. You are not a user configuring the system. You are a visitor consuming it.
I kept running into the same wall: I had a question about my finances that was completely reasonable, and the app simply had no way to answer it.
Firefly III: Genuinely Good, Deeply Inconvenient
Firefly III is the best open-source personal finance tool I’ve used. I want to be clear about this before I criticise it.
It has double-entry bookkeeping. It has rules and automation. It has more reports than you will ever need. It has an active community and decent documentation.
It also requires you to run a server.
This is not a dealbreaker for many developers — it might not even be a dealbreaker for you. But I want to track my finances, not maintain infrastructure for tracking my finances. The moment I found myself debugging a Docker networking issue at 11pm instead of reviewing my monthly spending, I accepted that Firefly and I were not compatible.
There is also no investment tracking worth mentioning. If your financial life includes mutual funds, SIPs, or PPF — which, if you’re an Indian salaried professional, it almost certainly does — you will be solving that problem yourself.
GnuCash works. It has worked, reliably, for decades. I will not be using it.
What I Actually Wanted
After the third tool had failed me, I spent some time thinking about what I actually wanted — not what the apps had assumed I wanted.
I did not want budgeting, in the envelope sense. The envelope budget is a perfectly good system, but it answers a question I was not asking. Envelope budgeting asks: how do I constrain my future spending? I was asking something simpler and, for me, more urgent: where has my money been going, and can I trust those numbers?
What I wanted was recording. A faithful, precise, queryable record of every financial event in my life — transactions, investments, reimbursements, transfers between accounts. Something I could interrogate. Something that would answer questions I had not thought to ask yet.
And then I wanted the ability to ask those questions in my own terms. Not the terms the app team had hardcoded. Mine.
This is, I realised, exactly how I think about code.
What Plain Text Accounting Actually Is
Plain Text Accounting is not a single tool. It is a philosophy — or if you prefer something less pretentious, a convention.
The convention is this: your financial records live in a plain text file. Each entry is a transaction with a date, a description, and two or more postings that record how money moved between accounts. The accounts you define. The structure you define. The file is yours.
A transaction looks something like this:
2025-05-01 Salary
assets:bank:hdfc:savings ₹1,20,000
income:salary ₹-1,20,000
2025-05-03 Zepto groceries
expenses:food:groceries ₹847
assets:bank:hdfc:savings ₹-847
That is it. Two transactions. Every rupee in each transaction balances to zero — this is double-entry bookkeeping, and it means your records are self-consistent by construction.
The file is text. You can read it in any editor. You can search it with grep. You can version it with Git, which means you have a complete audit trail of every change you have ever made to your financial records, with diffs.
There is no server. There is no subscription. There is no company that can shut down and take your data with it.
Why This Clicks for Developers
At some point in your career, you probably developed a preference for config files over GUIs. Not because GUIs are bad — they are often excellent — but because config files are legible. You can read them, diff them, commit them, share them.
You probably also developed a preference for tools that do one thing well and compose with other tools, over tools that try to own your entire workflow.
Plain Text Accounting is built on exactly these instincts. Your journal file is the config. The tool is the query engine. You own the data, and the data is boring, readable text.
There is also a practical advantage for the Indian financial context specifically. Our financial lives are messier than the apps account for. We have savings accounts, salary accounts, and emergency funds at different banks. We have SIPs, PPF, EPF, NPS. We have loans, credit cards, and reimbursements from employers. We have gold, sometimes. We have fixed deposits that mature on inconvenient dates.
No app has a dropdown for all of this. Plain text accounting does not have dropdowns at all — you define whatever accounts your actual life requires.
Enter hledger
There are several Plain Text Accounting tools. The most prominent are Ledger (the original), hledger, and Beancount. They share a similar journal format but differ in implementation, features, and — critically — how pleasant they are to use.
I chose hledger for reasons I will explain properly in the next article. For now: it is written in Haskell, which means it is fast and correct; it has excellent documentation; it has a web interface if you want one; and it runs as a single binary on every platform.
It reads your journal file and answers your questions. That is its job.
Your Finances Deserve Better Infrastructure
You write tests for your code. You lint it. You review it. You keep it in version control so that if something goes wrong, you can see exactly when it went wrong and what changed.
Your finances are not less important than your code. They are, by most reasonable measures, considerably more important.
And yet most of us track them in apps that we do not control, in formats we cannot read, with queries we cannot write, on servers we do not own.
Plain Text Accounting is the version-controlled, auditable, composable, plainly legible approach to personal finance. It is, in other words, the approach that treats your financial records with the same care you would give any other system you depend on.
The tools are free. The format is documented. The data is yours.
In the next article, we’ll get our hands dirty: installing hledger, designing an account structure for the Indian financial life, and recording our first transactions. If you want to follow along, the only thing you need before then is a text editor and mild curiosity.