Hacker News Reader

Comment by Youden | Hacker News Reader

I've been looking at the various open source accounting options recently and I settled on Beancount: http://furius.ca/beancount/

~95% of the reason is the fantastic web interface Fava: https://beancount.github.io/fava/

It's a bit annoying that you have to configure it with Python code but once you set it up it's pleasant to use.

The pain point for me right now is figuring out the counterparty for transactions (e.g. I can see that money went out of my bank account to pay the grocery store but I need to map that to the "Expenses:Groceries" category). It seems I need to use some kind of smart importer or something.

One application I thought got that part quite right was Buchhaltung (which works with Ledger/hledger rather than Beancount): https://github.com/johannesgerer/buchhaltung. It's matching system made that dead easy. Buchhaltung also comes with an AqBanking integration if you live in a country where banks actually provide useful APIs.

View on HN

I spent some time thinking about this problem recently (after also discovering beancount) and kind of concluded that double-entry accounting doesn't really work so well - as commonly explained - for individuals.

If you were a business for example, then your "expenses" would actually represent things like business units and other managers and stuff - other people handling money - which is basically what double-entry was invented to manage. But there isn't a "Coffee" business unit for you - it's just a nominal category and really more of a tag explaining why you were paying "Joe's Coffee Cart Holding Inc." $3

My conclusion on this then is that what I really need is an extensive tagging system to associate with transactions, because the actual "accounts" should represent places money can actually go to or did go to - since in the event of unexplained balances and the like, that's the type of thing I can actually track down.

> the actual "accounts" should represent places money can actually go to or did go to

I'm not an accountant but I don't believe this is true. You can use accounts for anything you like. I implement a simple tagging system on top of beancount using accounts like Expenses:Food and it works just fine.

Agree, and if you don’t like the account naming changing it can be a simple cut-and-replace ^h operation. Beancount also supports hashtags on transactions if you need (e.g.for certain events like vacations)

(Plug: I helped add “extension reports” to Fava recently, so you can now also make your own Jinja templates for your bespoke financial goals if querying+custom links isn’t enough)

In businesses, accounts represent the what (sales, salaries, rent, hotels, etc). You’d use another dimension altogether for business units. But they all have same chart of accounts. This is so it can be viewed in a consolidated way.

Double entry is for audit ability and balancing the various financial statements. It ensures they stay in balance.

I've actually found double-entry bookkeeping really useful for personal finances. Let's say I transfer money from one financial institution to another (say, a bank to an investment firm). With double-entry, I can track and reconcile both sides ("legs") of that transfer: one positive, and one negative. And they have to match up for things to balance.

I think the point is that most people don't transfer money between accounts.

My credit cards are each an account that I transfer money to each month. Most of my purchases go on one of my cards and then get paid off each month. CC transactions match that CC account and a category like Expenses:Auto:Gas.

My checking account is pretty much just account "transfers" and an occasional transfer to my "Cash in Wallet" account for ATM withdrawals.

Hmm. Treating cards this way feels promising. Might even have the advantage of making you feel each purchase twice.

Real-world example from my Gnucash file: I buy a present for my friend Alice for say 50$. Another friend, Bob, wants to share half of the cost and promises to give me the money next week.

I can easily [1] represent this as a split transaction where 50$ go out of my wallet's account. Half goes into Expenses:Gifts:Alice, half goes into AccountsReceivable:Bob. Once Bob pays me back, I transfer the money from AccountsReceivable:Bob back into Wallet.

[1] I guess I have different standards of "easy" than most of the population.

This is still a very small percentage of expenses most people do, though.

Not that it can't be used. I would be happy if this was taught in grade school more. But, I admit it is a rarely needed skill for most.

Have gone through a similar thought process- and don't disagree with the point that double entry specifically is not that helpful for individuals largely tracking cash-

HOWEVER-

Let me share that beancount actually has the most extensive and flexible tagging and metadata system of any accounting software I've used.

In addition to the conventional hierarchical accounts/categories, with beancount one can attach to transactions- and query with beancount's sql- both:

* arbitrary single value labels, like tags

* arbitrary name-value pairs, like metadata

The flexibility is truly a game changer.

What in the world are you talking about ?! Please consult a CPA and buy a financial accounting textbook. Like in physics every has an equal and opposite transaction.

I have the exact opposite experience. Anything that doesn't do double-entry (at least under the hood) is -- eventually -- insufficient for recording the nuances of variation in personal financial needs.

I hear you there, tools like Mint are more than sufficient for most people, however, it's not about how complicated are your finances (having multiple bank accounts, etc.), but whether you actually want to have a clear picture of your assets.

If you borrow your friend money, the fact that someone owes you that money is an asset. If you split rent with someone, and you don't settle it all immediately, that's also an asset or liability. If you do any independent work, double entry lets you realize that when you do the work, and then it's waiting in your receivables until you get paid. Someone pointed out that you don't usually have multiple accounts, but it doesn't have to be just bank accounts - we're talking broker accounts, retirement accounts, savings, credit cards, etc., transfers to these things should not show as expenses. Additionally, you can get smarter and (just like a business) remove money from your available pool, and budget for future.

To be fair, some single-entry bookkeeping tools probably implement some of these features, but in that case they really are just trying to simulate double entry bookkeeping.

On a higher level, I suspect that double entry for individuals would be more popular among HN crowd that in outside world; software is area that slightly selects for people being a little anal about code quality, getting all cases / code paths covered etc., and that is similar quality to wanting to make sure your accounts are in order.

Beancount really is wonderful. I use it for my personal finances, but I also moved my local hackerspace (Hackerspace.Gent) to use it to keep track of everybody's bar accounts. The backend uses beancount as a library to manage stock and balances, so that the data has a single point of truth in the (public) ledger. We can then always run easy analysis using the command line tools to see how much profit we made from events, which categories of things sell well, etc. Further, the metadata support allows us to keep certain preferences (like who the members are, how they prefer their name displayed, etc) all in one place.

If anybody is interested, the code is open source:

Backend: https://github.com/0x20/backtab

Frontend: https://github.com/0x20/tab-ui

I'm not going to explicitly link to the data but it shouldn't be hard to find if you want to see it

Have you seen Beancount-import (https://github.com/jbms/beancount-import)? It provides a web interface just focusing on the import and transaction reconciling/categorization piece, and includes a decision-tree-based classifier that learns as you go.

I gave it a go based on your suggestion and I found it a horror to set up (it forces you to write a new importer just for it!?) but it's quite nice once you do.

Yeah, I haven't tried it with an existing importer, but I can't say I'm surprised. FWIW, it does work pretty well in combination with finance-dl (same author): https://github.com/jbms/finance-dl

+1 for beancount. I started with gnucash only to discover it doesn't play well with multiple currencies. Then, I looked into ledger and it was much better but I realized I would like access it programmatically. Finally, I settled on beancount which has an amazing UI, has sql-like query utility and good python bindings to extend it in any way I want.

For categorizing new transactions I found that regex matching and doing the rest manually works for me (takes me around 20 minutes every month)

> It's a bit annoying that you have to configure it with Python code but once you set it up it's pleasant to use.

Not necessarily a good idea in every case, but if it's "just data" in the Python config file, you could make the Python config instead slurp in an actual data file of your desired format (YAML, TOML, whatever), and then transform it into Python data structures as needed.

Beancount is really cool. I've been using it for about 2 years now and really like it so far.

I'm also maintaining an "awesome" resources list for Beancount here - https://awesome-beancount.com/ , in case it's helpful for others.

Being a beancount user along with fava and also ledger-cli for managing accounts. The solution to your issue is simple, account Expenses:Grocery will record all the transactions related to grocery. In journal entry there is a field for payee where you can record counterparty and on top of that each entry can have multiple tags. You can tag them and then generate report based on those tags. So you can have a simple accounting report where all the Expenses:Grocery involving a specific tag or a counter party. Fava and beancount query makes it very easy to generate. You can check this mailing list thread for narration and payee in entries. https://groups.google.com/forum/m/#!topic/beancount/tJrA2n9L...

Smart importer? https://github.com/beancount/smart_importer

The setup portion can be streamlined using pyenv and pipenv. I've migrated to a few computers over the last several years (3 Linux and 1 Mac), and had beancount and fava running within a minute on each.

It's also not too difficult to throw Fava and Beancount into a Docker container and host it on a web server, if that's your thing.

Indeed, there's a few on Docker Hub, just to make it even easier to get started.

https://hub.docker.com/r/yegle/fava/dockerfile

If you like Fava-like interface, maybe check out Prudent, which works with ledger: https://prudent.me

> currently for MacOS only

Fail

GnuCash also has AqBank integration, but I haven't tried it. Actually really hadn't heard of it before seeing it there, is it more common elsewhere?

The UI on linux is ... absymal to set up. But once you do, it's pretty straightforward, not much different than downloading OFX and importing though.

I need to check this out!

Reply on news.ycombinator.com