Hoe Beancount en Fava real-time dashboards aandrijven

Inleiding​

Beancount is een open-source dubbel boekhoudsysteem dat platte tekstbestanden als grootboek gebruikt. Het legt de nadruk op eenvoud, transparantie en flexibiliteit bij het bijhouden van financiën. Fava is een krachtige webgebaseerde front-end voor Beancount, met een interactieve interface voor het bekijken van rapporten, visualisaties en het beheren van je grootboek. In dit rapport verkennen we de kernmogelijkheden van Beancount en Fava, en hoe je met deze tools real-time of bijna-real-time financiële analyses kunt bereiken. We behandelen configuratietips voor automatisering en gegevensvernieuwing, Fava's visualisatiefuncties (voor directe cashflow-weergaven en het spotten van trends), integratie met externe dashboards (Grafana, Metabase, enz.), voorbeelden van aangepaste dashboards en plugins, use cases in persoonlijke financiën en kleine bedrijven, vergelijkingen met andere platforms (Power BI, QuickBooks), en de voor- en nadelen van het gebruik van Fava+Beancount voor datagedreven inzichten.

Verken een live voorbeeldgrootboek:

Verken het live grootboek →

Kernmogelijkheden van Beancount en Fava​

Beancount (Plain-Text Boekhoudmotor)​

• Dubbel boekhouden in platte tekst: Beancount slaat transacties op in één .beancount-tekstbestand (of meerdere bestanden die samen worden ingevoegd). Elke transactie moet in balans zijn (totale debets = totale credits) over rekeningen heen, wat de boekhoudkundige integriteit waarborgt. Het platte-tekstformaat betekent dat je gegevens leesbaar zijn voor mensen, versiebeheerbaar zijn en niet vastzitten aan een leverancier.
• Flexibele, hiërarchische rekeningen: Je kunt elke gewenste rekening definiëren (bijv. Assets:Bank:Checking, Expenses:Food:Coffee) in een hiërarchie. Beancount heeft geen mening over je rekeningschema, dus het werkt voor persoonlijke financiën, boekhouding van kleine bedrijven, beleggingen, enz. – het is "flexibel: werkt voor persoonlijke financiën, boekhouding voor kleine bedrijven, crypto, aandelenbeleggingen en meer."
• Meerdere valuta's en goederen: Beancount heeft eersteklas ondersteuning voor meerdere valuta's en goederen (bijv. aandelen, crypto). Je kunt transacties in verschillende valuta's vastleggen, wisselkoersen definiëren (prijsdirectieven) en kostprijzen bijhouden. Het kan rapporten produceren "tegen kostprijs" of "tegen marktwaarde" als prijsgegevens beschikbaar zijn. Dit maakt het geschikt voor portfolio's en internationale financiën.
• Geautomatiseerde controles en balansen: Het systeem ondersteunt balansasserties (je kunt aangeven wat het saldo van een rekening op een datum zou moeten zijn, en Beancount geeft een fout als het niet klopt) en balanstransacties voor het afsluiten van boeken. Het ondersteunt ook equity-openings-/afsluitingsboekingen en het berekenen van ingehouden winsten voor periodeafsluitingen. Deze helpen je boeken consistent te houden en fouten vroegtijdig op te sporen.
• Krachtige query- en rapportage-engine: Beancount wordt geleverd met een querytaal BQL (Beancount Query Language). Gebruik bea query voor BQL in de terminal en bea report voor de standaardoverzichten; installeer de CLI quick start in plaats van de oudere upstream console-scripts. Je kunt het grootboek bevragen voor aangepaste rapporten (bijv. een lijst van uitgaven per begunstigde, cashflow voor een periode) – in wezen behandel je het grootboek als een database. Het blijft snel, zelfs met duizenden transacties. Exporteer CSV met bea query -f csv -o report.csv "BQL", waarbij je BQL vervangt door je query. Zie Financial Reporting Templates voor volledige voorbeelden.
• Uitbreidbaarheid via plugins: Beancount is geschreven in Python en staat aangepaste plugins toe om de functionaliteit uit te breiden. Plugins kunnen extra regels of berekeningen afdwingen wanneer het bestand wordt verwerkt. (Er zijn bijvoorbeeld plugins voor het verwerken van belastingpartijen, of om te zorgen dat geen enkele aankoop een kostprijs mist.) Het pluginsysteem en de Python-API laten gevorderde gebruikers aangepast gedrag scripten of Beancount integreren met andere systemen.
• Importeurs voor externe gegevens: Een belangrijk praktisch kenmerk is het importeurraamwerk in het aparte beangulp-pakket (er is geen beancount.ingest-module in Beancount 3.2.3). Je schrijft een importeurklasse die subclasseert van beangulp.Importer en identify, extract en account implementeert. Deze parseert een gedownload bestand (CSV, OFX, PDF-afschriften, enz.) en converteert het naar Beancount-boekingen. Dit is essentieel voor automatisering (daarover later meer).
• Controleerbaar en versiebeheervriendelijk: Omdat het platte tekst is, kun je je grootboek in Git of een ander versiebeheersysteem bewaren. Elke wijziging is transparant en je hebt een volledige geschiedenis van bewerkingen. Dit maakt audits of het beoordelen van wijzigingen eenvoudig (veel gebruikers committen de wijzigingen van elke dag naar een Git-repository, wat een fraudebestendig logboek van alle financiële boekingen oplevert). Dit niveau van transparantie is een groot onderscheidend punt ten opzichte van gesloten boekhoudsoftware – "geen SaaS lock-in—gewoon schone, transparante boekhouding met krachtige rapportage."

Fava (Webinterface voor Beancount)​

• Interactieve web-UI: Fava biedt een lokale webserver die je Beancount-grootboek weergeeft in een rijke UI. Het toont kernrapporten (winst-en-verliesrekening, balans, enz.), rekeningoverzichten en journalen in de browser met interactieve bediening. De UI is dynamisch en gebruiksvriendelijk vergeleken met de commandoregel. Je start het met een simpele fava yourfile.beancount en krijgt een webapplicatie voor je boeken.
• Ingebouwde grafieken en diagrammen: Fava genereert grafieken om je gegevens te visualiseren. Het bevat bijvoorbeeld een lijn­grafiek van het nettovermogen in de tijd, staafdiagrammen voor inkomsten versus uitgaven per maand, en taart-/treemap-diagrammen voor uitgavenverdelingen. Deze visuals worden bijgewerkt met je gegevens en ondersteunen verschillende weergaven (bijv. "tegen kostprijs" versus "marktwaarde" voor beleggingen). We verkennen deze visualisatiemogelijkheden later in detail.
• Filteren en zoeken: Bovenaan Fava's pagina's laat een filterbalk je gegevens in real-time doorzoeken en segmenteren. Je kunt filteren op tijd (bijv. jaar, kwartaal, maand), op rekening-regex, op begunstigde, op omschrijving, of op tags/links. Dit maakt real-time gegevensinspectie gemakkelijk – bijvoorbeeld snel filteren op "Tag=Travel" en "Year=2025" om alle reiskosten in 2025 te zien, met totalen. De interface ondersteunt complexe queries via deze filterbalk of via de Query-pagina (waar je direct BQL-queries kunt uitvoeren).
• Ondersteuning voor meerdere bestanden en consolidatie: Fava kan meerdere Beancount-bestanden tegelijk laden (handig als je grootboeken scheidt) en ertussen schakelen. Het kan ze ook consolideren indien nodig (bijvoorbeeld persoonlijke en zakelijke grootboeken samen bekijken).
• Gegevensinvoer en bewerken: Uniek is dat Fava niet alleen-lezen is – het heeft een editor en een formulier voor het invoeren van transacties. Je kunt nieuwe transacties toevoegen via een webformulier (het voegt de boeking in je .beancount-bestand in). Je kunt het bronbestand ook vanuit Fava in een externe editor openen. Fava ondersteunt ook sneltoetsen voor power users. Dit maakt Fava een lichtgewicht boekhoudsysteem waarin je gegevens kunt invoeren en bekijken vanuit dezelfde interface.
• Rapporten en rekening-drilldown: Fava biedt standaard boekhoudkundige rapporten: winst-en-verliesrekening, balans, proefbalans en een positieslijst voor beleggingen. De balans en winst-en-verliesrekening zijn interactief – je kunt op een rekening klikken om in de details te duiken, of schakelen tussen weergave tegen kostprijs versus marktwaarde voor activa. Fava toont ook "ongerealiseerde winsten" voor beleggingen als je prijsgegevens hebt. Het genereert een journaal-weergave van alle boekingen en laat toe dat journaal op verschillende criteria te filteren (geweldig voor het vinden van specifieke transacties).
• Documentbeheer: Als je bonnen of afschriften bijvoegt, helpt Fava die te organiseren. Beancount kent een documentenmap, en Fava laat je bestanden naar rekeningen of transacties slepen – het slaat ze op en voegt een documentboeking toe in je grootboek. Dit is handig om ondersteunende documenten aan je grootboekgegevens te koppelen.
• Aanpassing via extensies: Fava kan worden uitgebreid met plugins (geschreven in Python) om nieuwe rapporten of functionaliteit toe te voegen. Sommige extensies zijn meegeleverd (bijv. een portfoliolijst-rapport voor beleggingen). We bespreken aangepaste extensies later, maar in wezen laat Fava's ontwerp toe dat nieuwe pagina's en zelfs aangepaste JavaScript worden geïnjecteerd via de extensie-API. Dit betekent dat als een bepaalde analyse of dashboard niet ingebouwd is, een gevorderde gebruiker die kan toevoegen.
• Prestaties: Fava is efficiënt – het herlaadt de gegevens in het geheugen en serveert pagina's snel. De onderliggende Beancount-parsing is snel, dus typische persoonlijke grootboeken laden binnen een seconde of twee. In de praktijk kan Fava persoonlijke grootboeken van vele jaren aan, hoewel extreem grote bestanden (tienduizenden transacties) baat kunnen hebben bij enige optimalisatie (bijv. het archiveren van oude boekingen).
• Webtoegang en mobiliteit: Door Fava op een server of zelfs je laptop te draaien, kun je je financiën vanuit elke browser benaderen. Sommige gebruikers hosten Fava op een privéserver of Raspberry Pi zodat ze onderweg hun financiën kunnen controleren (mogelijk beveiligd achter een wachtwoord of VPN, aangezien Fava geen ingebouwde authenticatie heeft). Dit geeft je in wezen een zelfgehoste "webapp" voor je financiën, zonder je gegevens aan een derde partij te geven.

Samengevat biedt Beancount een robuuste basis voor transparante, op tekst gebaseerde boekhouding met strikte dubbel-boekhoudregels en ondersteuning voor meerdere valuta's. Fava bouwt daarop voort door een toegankelijke interface te bieden met directe inzichten (rapporten, grafieken) en de mogelijkheid om met je gegevens te interacteren. Samen vormen ze een zeer flexibel boekhoud- en analysesysteem dat je van begin tot eind beheert.

Real-time (of bijna real-time) analyse met Beancount & Fava​

Het bereiken van real-time of bijna-real-time analyses met Beancount en Fava vereist het automatiseren van de gegevensstroom naar je grootboek en ervoor zorgen dat de tools actuele informatie tonen. Standaard is Beancount een batchproces (je voegt boekingen toe aan het bestand en bekijkt vervolgens rapporten), en Fava detecteert wijzigingen en vereist een vernieuwing. Met de juiste opzet kun je updates echter stroomlijnen zodat nieuwe transacties en wijzigingen bijna onmiddellijk verschijnen.

Detectie van bestandswijzigingen: Fava controleert het grootboekbestand op wijzigingen. Als je het .beancount-bestand (of ingevoegde bestanden) in een editor bewerkt, toont de pagina een melding "File change detected. Click to reload." Fava pollt zijn get_changed-endpoint. Wanneer de watcher een wijziging meldt, herlaadt Fava het grootboek aan de serverzijde en biedt de melding één klik om de weergave te vernieuwen. In de praktijk is deze herlaadactie zeer snel (meestal minder dan een seconde voor typische grootboeken). Dit betekent dat Fava kan dienen als een live dashboard als je grootboekbestand frequent wordt bijgewerkt. Standaard wacht het op je klik om je weergave niet te verstoren.

Doorlopende import-/update-pijplijn: Om real-time gegevens te krijgen, moet je het toevoegen van transacties aan het Beancount-bestand automatiseren. Er zijn een paar gangbare strategieën:

• Geplande importtaken (Cron): Veel gebruikers zetten een cronjob (of geplande taak) op om periodiek nieuwe transacties van financiële instellingen op te halen (bijvoorbeeld elke nacht of elk uur) en aan het grootboek toe te voegen. Je kunt bijvoorbeeld een beangulp-importeur draaien over de nieuwste bankdownload (CSV of OFX). Een Beancount-gebruiker bouwde een automatiseringspijplijn zodat zijn boeken zichzelf bijwerken: "seeing my accounting book updating itself without me touching it in an open format brings me pure joy". Dit werd bereikt door verbinding te maken met bank-API's en regelmatige updates te plannen. Een aangepast Python-script dat bank-API's gebruikt (bijv. Plaid) kan volgens een schema draaien en nieuwe boekingen naar het grootboek schrijven. Valideer elke run met bea check voordat deze je hoofdbestand aanraakt. Na elke geplande import kun je, als je Fava draait, Fava eenvoudig vernieuwen om de nieuwe gegevens te zien.

• Bestandswatchers en triggers: In plaats van tijdgebaseerde schema's kun je bestandswatchers gebruiken om op gebeurtenissen te reageren. Als je bank je bijvoorbeeld dagelijks een afschrift kan e-mailen of je een CSV in een map plaatst, kan een script dat bestand detecteren (met inotify op Linux of vergelijkbaar) en onmiddellijk de importroutine uitvoeren, en vervolgens Fava opdracht geven te herladen. Hoewel Fava nog geen live reload naar de browser ondersteunt, zou je ten minste de gegevens bijgewerkt hebben zodat ze actueel zijn wanneer je de pagina de volgende keer bekijkt of op herladen klikt. Sommige communityprojecten gaan verder: voor ledger (een neef van Beancount) maakte een gebruiker een kleine server die ledger-gegevens in real-time aan Grafana blootstelt, wat aantoont dat een vergelijkbare aanpak met Beancount mogelijk is – in wezen bouw je een daemon die continu gegevens naar je dashboards voedt.

• Directe API-integratie: In plaats van via bestanden te gaan, kunnen gevorderde gebruikers rechtstreeks verbinding maken met bank-API's (zoals Plaid of regionale Open Banking-API's) om frequent transacties op te halen. Een gemotiveerd individu kan "live" imports in een lus scripten (met passende rate limiting) – in feite de bank elke paar minuten pollen voor nieuwe gegevens. Niets weerhoudt je ervan om "signing up with Plaid API and doing the same [automation] locally". Elke nieuwe transactie kan aan het Beancount-bestand worden toegevoegd zodra deze binnenkomt. Met deze aanpak wordt Fava echt een real-time dashboard voor je rekeningen, dat kan wedijveren met de actuele feed in commerciële apps.

Gegevensvernieuwing in Fava: Zodra je gegevens worden bijgewerkt, is het eenvoudig om Fava ze te laten tonen: een browservernieuwing (F5) of op de herlaadmelding klikken laadt de nieuwste grootboekstatus. Let op dat fava --debug geen grootboekwijzigingen naar de browser pusht. De helptekst luidt "Turn on debugging". Het draait de Werkzeug-debugger en code-reloader voor Fava's eigen code en stelt Jinja-template auto-reload in. Dat herlaadt servercode en paginatemplates tijdens de ontwikkeling van extensies. Het staat los van de bestandswatcher die grootboekwijzigingen detecteert. Als alternatief, als je een aangepaste front-end bouwt, kun je deze Fava's get_changed-endpoint laten pollen en verversen wanneer er nieuwe gegevens worden gemeld.

Directe berekeningen: Beancount's snelle parsing betekent dat zelfs als je je grootboekbestand elke paar minuten bijwerkt, de doorlooptijd van gegevensophaling → bestandsupdate → Fava-herlaadactie snel is. Een gebruiker merkt bijvoorbeeld op dat het herladen van Fava na het bewerken van het bestand "nauwelijks merkbaar is... beslist minder dan een seconde" voor grootboeken van redelijke omvang. Zo kun je een Fava-venster openhouden en periodiek verversen om een live dashboard na te bootsen. (Voor een echt live ervaring zou je een klein script kunnen bouwen om de browser automatisch te verversen of de functie van de browser gebruiken om elke N seconden te verversen.)

Reconciliatie en waarschuwingen: Om real-time gegevens te vertrouwen, wil je ook saldi frequent reconciliëren. Beancount maakt dit gemakkelijk met balansasserties en een "up-to-date"-indicator. In feite kleurt Fava rekeningen groen, geel of rood wanneer het open-directief fava-uptodate-indication-metadata bevat. De kleur geeft aan of recente balanscontroles de nieuwste boekingen van de rekening dekken. Dit kan worden gebruikt om snel te zien of het saldo van een rekening in het grootboek overeenkomt met het nieuwste afschrift van de bank. In een bijna-real-time opzet kun je dagelijkse balanscontroles automatiseren (zodat het grootboek elke ochtend het slotbalans van gisteren van de bank voor elke rekening bevat). Fava's indicator vertelt je dan of je auto-import iets heeft gemist of of er een discrepantie is, wat vertrouwen geeft dat de "live" gegevens die je ziet accuraat zijn.

Automatiseringsvoorbeeld: Stel dat je dagelijkse cashflow-updates wilt. Je kunt een cronjob instellen die elke nacht om 3 uur draait: deze voert een Python-script uit dat de API van je bank gebruikt om de transacties van de laatste dag op te halen, ze naar import_today.beancount schrijft en dat bestand vervolgens aan je hoofdgrootboek toevoegt. Het schrijft ook een balansassertie voor het einde van de dag. Wanneer je wakker wordt, open je Fava – het toont alle transacties tot en met gisteren, en je ziet de inkomsten/uitgaven van de huidige maand bijgewerkt. Als je gedurende de dag een uitgave doet, kun je deze handmatig toevoegen (bijvoorbeeld via Fava's nieuwe-transactieformulier op je telefoon), of wachten op de nachtelijke import. Deze hybride aanpak (grotendeels geautomatiseerd, met de mogelijkheid om ad-hoc handmatig toe te voegen) geeft een bijna-real-time beeld. Een andere aanpak is om Fava's Journaal-pagina open te laten en deze als register te gebruiken: terwijl je uitgeeft, leg je de transactie snel vast (zoals in een chequeboekje) – dan ben je de real-time feed. Dit is handmatiger, maar sommige gebruikers genieten van het bewustzijn dat het brengt. Voor echt streaming updates zonder handmatige stappen moet je investeren in scripting en mogelijk API's van derden gebruiken zoals besproken.

Samengevat kun je door Beancount's importautomatisering te combineren met Fava's snelle verversing bijna-real-time financiële gegevens krijgen. Het is misschien niet "druk-op-de-knop gemakkelijk" om hetzelfde niveau van live feed te bereiken als een dienst zoals QuickBooks (die automatisch bankfeeds ophaalt), maar het is mogelijk – en belangrijk, je behoudt volledige controle en transparantie over het proces. Zoals een voorstander van plaintext accounting opmerkte, kan een beetje inspanning vooraf een geautomatiseerd systeem opleveren dat "way better than commercial solutions, and far more flexible and extensible" is. In de volgende sectie zullen we zien hoe Fava's visualisatiemogelijkheden je in staat stellen deze actuele gegevens onmiddellijk te begrijpen, waarbij ruwe transacties worden omgezet in inzichten.

Beheerde prijzen voor gehoste waarderingen​

Live Prices levert ondersteunde waarderingskoersen aan gehoste Beancount.io-grootboeken. De loader controleert op nieuwe gegevens wanneer een grootboek laadt na het venster van vijf minuten voor verversing; een provider-waarneming kan ouder zijn. Dit is geen streaming feed.

De hier beschreven Fava-bedieningselementen behoren tot Fava. Het toevoegen van een beheerde include voegt die bedieningselementen niet toe aan de gehoste viewer en verandert een kostprijsweergave niet in een marktwaardeweergave. Upstream Fava heeft lokale prijsbestanden nodig. Een compatibele bea-versie kan ze exporteren; zie de installatiegids voor compatibiliteit.

Visualisatiemogelijkheden in Fava (Kasstromen, Trends, Real-time Inspectie)​

(GitHub - beancount/fava: Fava - web interface for Beancount) Fava's winst-en-verliesrapport (in de web-UI) ondersteunt rijke visualisaties zoals treemaps (afgebeeld) en sunburst-diagrammen voor snel inzicht in de samenstelling van inkomsten en uitgaven. In deze treemap vertegenwoordigt elke rechthoek een uitgavecategorie, geschaald naar het bedrag – je ziet onmiddellijk dat Huur (groot groen blok) de uitgaven domineert. De bovenste filterbalk en bedieningselementen (rechtsboven) maken het mogelijk de valuta, het grafiektype en de periode te wijzigen (bijv. maandelijkse gegevens bekijken). Fava biedt ook lijngrafieken (bijv. nettovermogen in de tijd) en staafdiagrammen (bijv. inkomsten versus uitgaven per maand) om trends in je financiële gegevens te helpen spotten.

Een van Fava's grootste sterke punten is het onmiddellijk omzetten van de grootboekgegevens in visuele, interactieve rapporten. Zodra het grootboek is geladen, genereert Fava grafieken die cashflows en trends in één oogopslag begrijpelijk maken:

• Treemap/sunburst van inkomsten en uitgaven: Op de winst-en-verliespagina kan Fava je inkomsten en uitgaven weergeven als een treemap of sunburst-diagram. Deze zijn uitstekend voor een cashflowvisualisatie "in één oogopslag". Als je maandelijkse uitgaven bijvoorbeeld als treemap worden weergegeven, komt de oppervlakte van elke rechthoek overeen met de omvang van elke uitgavecategorie. Grote blokken laten onmiddellijk zien waar het meeste geld naartoe ging (bijv. huur of hypotheek, belastingen, enz.), terwijl kleinere blokken kleine uitgaven tonen. Dit is uiterst nuttig voor het spotten van trends in bestedingen – als het blok "Uit eten" elke maand groeit, zul je dat visueel opmerken. Je kunt overschakelen naar een sunburst-diagram om hiërarchische uitsplitsingen te zien (bijv. de buitenste ring kan subcategorieën tonen zoals Boodschappen versus Restaurants binnen de categorie Voeding). Deze grafieken worden bijgewerkt voor welke periode je ook hebt gefilterd (één maand, jaar tot nu, enz.), wat je directe cashflowvisualisatie voor die periode geeft. Een gebruiker op het plaintext accounting-forum merkte op: "I make a lot of use of the income and expense treemaps. They give a great visual sense of our fiscal movements." – dit soort onmiddellijk begrip is precies waar Fava's grafieken naar streven.

• Nettovermogen en saldo in de tijd: Fava biedt een lijngrafiek voor nettovermogen in de tijd (op de pagina "Balance Sheet" of "Statistics"). Deze grafiek toont de som van je activa minus passiva op elk moment (per dag, week of maand). Het is onmisbaar voor het spotten van trends – je kunt de ontwikkeling van je financiën zien (bijv. gestaag stijgend, of dalingen op bepaalde momenten). Als je beleggingen hebt, kun je schakelen tussen weergave tegen kostprijs versus marktwaarde (als prijsgegevens zijn vastgelegd) – je zou bijvoorbeeld kunnen zien dat je nettovermogen tegen marktwaarde fluctueert met de aandelenkoersen, terwijl het tegen kostprijs vlakker is. Fava kan ook rekeningensaldi in de tijd weergeven. Als je op een rekening klikt (bijv. Assets:Bank:Checking), toont de rekeningpagina een grafiek van de saldogeschiedenis van die rekening. Je kunt onmiddellijk inspecteren hoe je kasrekening beweegt – wat in feite een cashflowgrafiek is (de helling van de saldolijn geeft de netto cashflow aan). Als deze daalt, weet je dat je in die periode meer uitgeeft dan verdient. Door deze trends te onderzoeken kun je patronen spotten zoals "elke december daalt mijn spaargeld (feestdagenuitgaven)" of "mijn beleggingen groeiden sterk dit kwartaal".

• Staafdiagrammen voor periodieke vergelijking: In de winst-en-verliesweergave heeft Fava tabbladen voor "Monthly Profit", "Monthly Income", "Monthly Expenses", enz. Als je deze selecteert, worden staafdiagrammen per maand getoond. Monthly Net Profit toont bijvoorbeeld het overschot/tekort van elke maand als een staaf, waardoor het gemakkelijk is de prestaties over maanden te vergelijken. Je kunt snel uitschieters identificeren (bijv. een grote negatieve staaf in april betekent dat die maand een ongewoon verlies/uitgave had). Op dezelfde manier stapelt of groepeert het "Monthly Expenses"-staafdiagram uitgaven per categorie per maand, zodat je kunt zien welke categorieën fluctueren. Dit is geweldig voor het spotten van trends in de tijd – je zou bijvoorbeeld kunnen opmerken dat je "Reis"-uitgaven elke zomer pieken, of dat "Nutsvoorzieningen"-rekeningen in de winter hoger zijn. Fava geeft je in wezen een deel van de mogelijkheden van een budgetteerapp (het volgen van trends) maar met volledige aanpasbaarheid (aangezien jij de categorieën en hun groepering definieert).

• Real-time filteren en gegevensinspectie: De visualisaties in Fava zijn niet statisch; ze werken samen met Fava's filtering. Stel dat je een specifiek scenario wilt inspecteren: "Hoe zien mijn driemaandelijkse cashflows eruit voor alleen mijn zakelijke rekeningen?" Je kunt het tijdfilter instellen op Q1 2025 en rekeningen filteren op je zakelijke hiërarchie – Fava werkt de grafieken onmiddellijk bij om netto-inkomen, treemap van uitgaven, enz. te tonen, maar alleen voor die subset. Dit interactieve segmenteren betekent dat je zeer snel ad-hoc analyses kunt doen, zonder queries te schrijven. De Journaal-weergave ondersteunt ook live filtering: je kunt zoeken op begunstigde of een substring van de omschrijving en onmiddellijk een gefilterde lijst van transacties zien. Als je naar real-time gegevens kijkt (stel dat je net de transacties van vorige week hebt geïmporteerd), kun je filteren op een tag zoals #uncategorized om nieuwe transacties te zien die mogelijk gecategoriseerd moeten worden, of op @pending (als je openstaande boekingen markeert) om te zien wat nog niet is afgewikkeld. Deze real-time inspectiemogelijkheid helpt ook de gegevenskwaliteit te waarborgen – omdat je anomalieën on-the-fly kunt isoleren en aanpakken.

• Cashflowoverzicht (indirect): Hoewel Beancount/Fava niet standaard een formeel cashflowoverzicht produceert (uitsplitsing Operationeel/Investeringen/Financiering), kun je het nabootsen met aangepaste queries of door rekeningen te structureren. Je zou bijvoorbeeld bepaalde transacties kunnen taggen of specifieke rekeningen gebruiken voor investeringen en financiering, en vervolgens totalen opvragen. Fava's query-interface voert BQL uit zoals SELECT sum(position) WHERE account ~ 'Assets:Bank:Checking'. Het retourneert het checkingsaldo achter de grafieken. Het uitgewerkte voorbeeld hieronder toont de volledige rondgang. Dat gezegd hebbende, vinden de meeste particuliere gebruikers de combinatie van balanstrends en inkomsten-/uitgavecategorieën voldoende om cashflows te begrijpen.

• Posities en portfoliovisualisatie: Op de pagina Holdings toont Fava je huidige posities in goederen (bijv. aandelen, obligaties, crypto) met hoeveelheden, kostprijs, marktwaarde en ongerealiseerde winsten. Hoewel dit een tabel is, geen grafiek, is het zeer nuttig voor real-time inspectie van de status van je portfolio. Sommige community-extensies (zoals fava-investor, later besproken) voegen meer visuals toe voor portfolio's, zoals toewijzingstaartdiagrammen of prestatiegrafieken. Zelfs zonder extensies kun je bijvoorbeeld zien hoe de waarde van je aandelenportfolio verandert op basis van de nieuwste koersen – als je prijsopgaven regelmatig bijwerkt (wat dagelijks geautomatiseerd kan worden), weerspiegelen Fava's grafieken de nieuwste beschikbare gedateerde prijzen, die ouder kunnen zijn dan het moment waarop je het rapport opent.

Uitgewerkt voorbeeld: twee maanden uitgaven​

Dit voorbeeld werkt van begin tot eind op Beancount 3.2.3 met beanquery 0.2.0. Sla het grootboek op als example.beancount. Het bevat twee salarisbetalingen en vier uitgaven.

option "title" "Analytics example"
option "operating_currency" "USD"
 
2024-01-01 open Assets:Bank:Checking USD
2024-01-01 open Expenses:Food:Groceries USD
2024-01-01 open Expenses:Food:Dining USD
2024-01-01 open Expenses:Housing:Rent USD
2024-01-01 open Income:Salary USD
2024-01-01 open Equity:Opening-Balances USD
 
2024-01-05 * "Employer" "January salary"
  Income:Salary  -3000.00 USD
  Assets:Bank:Checking  3000.00 USD
 
2024-01-08 * "Grocery Store" "Weekly groceries"
  Expenses:Food:Groceries  120.00 USD
  Assets:Bank:Checking  -120.00 USD
 
2024-01-12 * "Restaurant" "Dinner out"
  Expenses:Food:Dining  80.00 USD
  Assets:Bank:Checking  -80.00 USD
 
2024-02-01 * "Landlord" "February rent"
  Expenses:Housing:Rent  1000.00 USD
  Assets:Bank:Checking  -1000.00 USD
 
2024-02-05 * "Employer" "February salary"
  Income:Salary  -3000.00 USD
  Assets:Bank:Checking  3000.00 USD
 
2024-02-10 * "Grocery Store" "Weekly groceries"
  Expenses:Food:Groceries  150.00 USD
  Assets:Bank:Checking  -150.00 USD

Controleer het eerst. Voer daarna de query voor bestedingen per categorie uit.

bea --file example.beancount check
bea --file example.beancount query "SELECT account, sum(position) WHERE account ~ 'Expenses' GROUP BY account ORDER BY account"

Een schoon grootboek geeft exitcode 0 van bea check; fouten worden weergegeven met een niet-nul exitcode. De query retourneert één rij per uitgaverekening.

        account          sum(position)
-----------------------  ------------
Expenses:Food:Dining        80.00 USD
Expenses:Food:Groceries    270.00 USD
Expenses:Housing:Rent     1000.00 USD

Nog twee queries completeren het beeld. Totale inkomsten en totale uitgaven:

SELECT sum(position) WHERE account ~ 'Income'
SELECT sum(position) WHERE account ~ 'Expenses'

Ze retourneren (-6000.00 USD) en (1350.00 USD). Het huishouden verdiende dus 6.000,00 USD, gaf 1.350,00 USD uit en spaarde 77,5%. Het checkingsaldo bevestigt het:

SELECT sum(position) WHERE account ~ 'Assets:Bank:Checking'

Het retourneert (4650.00 USD). Dezelfde queries draaien ongewijzigd op Fava's Query-pagina. Fava 1.30.16 toont dezelfde drie uitgavenrijen als een interactieve tabel.

In de praktijk worden Fava's visuele rapporten net zo snel bijgewerkt als de onderliggende gegevens. Op het moment dat een nieuwe transactie wordt toegevoegd en de pagina wordt herladen, worden de grafieken opnieuw berekend. Er is geen langdurige herverwerking nodig. Dit betekent dat als je een semi-geautomatiseerde pijplijn hebt die de hele dag gegevens aanvoert, je Fava open kunt houden en periodiek kunt verversen om bijgewerkte grafieken te krijgen – in feite real-time financiële monitoring.

Stel je bijvoorbeeld voor dat je een klein bedrijf runt en je kasgeld en dagelijkse uitgaven wilt monitoren. Je zou Fava open kunnen hebben op een aangepast dashboard (misschien met een extensie of het query-scherm) dat "Kasrekening saldo vandaag" en "Uitgaven – Vandaag versus Gisteren" toont. Elke keer dat je ververst nadat nieuwe gegevens binnenkomen, zie je die cijfers bijgewerkt. Dit is vergelijkbaar met wat dure real-time dashboards bieden, maar dan met open-source tools. Het verschil is dat je mogelijk handmatig moet verversen of verversingen moet plannen, terwijl die tools updates automatisch pushen. Maar functioneel is het inzicht dat je krijgt hetzelfde, met als extra voordeel dat je in Fava op elk getal kunt inzoomen (erop klikken om de onderliggende transacties te zien) – iets wat veel BI-dashboards missen.

Samengevat verandert Fava je boekhoudgegevens in onmiddellijke visuele inzichten: cashflowuitsplitsingen, trendlijnen, vergelijkingen in de tijd en interactieve filtering helpen je allemaal het verhaal achter de cijfers te zien. Of je nu de bestedingen van vorige week op anomalieën inspecteert of meerjarentrends in nettovermogen beoordeelt, Fava's grafieken en rapporten bieden duidelijkheid in real-time (zodra je gegevens er zijn). Vervolgens zullen we zien hoe je deze mogelijkheden kunt uitbreiden of integreren met externe tools als je nog meer aangepaste analyses nodig hebt.

Integratie met externe dashboards en visualisatietools​

Hoewel Fava een rijke set ingebouwde rapporten en grafieken biedt, wil je Beancount's gegevens misschien integreren met andere business intelligence (BI)- of dashboardtools zoals Grafana, Metabase, of aangepaste webfront-ends (bijv. een React-app). De motivatie kan zijn om financiële gegevens te combineren met andere gegevensbronnen, geavanceerde grafische mogelijkheden te gebruiken, of dashboards in een ander formaat met anderen te delen. Dankzij Beancount's openheid zijn er meerdere manieren om integratie te bereiken:

• Database-integratie (BeanSQL / Beanpost): Een eenvoudige aanpak is het exporteren of synchroniseren van je Beancount-grootboek naar een SQL-database. Eenmaal in SQL kan elke BI-tool de gegevens bevragen. In feite hebben communityleden hiervoor tools gemaakt. Beanpost is bijvoorbeeld een experiment dat een Beancount-grootboek spiegelt naar een PostgreSQL-database, waarbij veel van Beancount's logica als SQL-functies wordt geïmplementeerd. Dit biedt "a flexible backend that can integrate with other tools like web apps or reporting systems." Je kunt Beanpost draaien om je tekstgrootboek continu naar Postgres te synchroniseren. Vervolgens kan een tool zoals Metabase of Tableau verbinding maken met die Postgres-database en kun je elke gewenste grafiek of dashboard bouwen (die live bijwerkt naarmate de database wordt bijgewerkt). Een gebruiker meldde dat hij Postgres + PostGraphile gebruikte om automatisch een GraphQL-API voor de grootboekgegevens beschikbaar te stellen en vervolgens een aangepaste React-front-end daarbovenop schreef – waarbij het grootboek in wezen als een webservice werd behandeld. Deze aanpak komt tegemoet aan gevallen waarin Fava's interface misschien niet voldoende is (bijv. multi-user toegang, of meer mobielvriendelijke UI's). Het is meer engineergericht, maar het toont het potentieel: je kunt Beancount relatief gemakkelijk integreren met moderne webstacks. Een lichtgewicht variant is het exporteren van queryresultaten naar SQLite – het draaien van bea --file ledger.beancount query "SELECT ..." print een tabel die je kunt plakken of doorsturen, en spreadsheet-CSV vanaf de CLI wacht op native exportopties voor bea query. Sommige mensen gebruiken SQLite als tussenstap om in tools zoals Metabase te pluggen (die SQLite-bestanden via een verbinding kan lezen).

• Grafana (tijdreeksdashboards): Grafana is populair voor monitoring en tijdreeksgegevens. Financiële gegevens in de tijd (uitgaven, saldi) kunnen als tijdreeksen worden behandeld. Er is communitydiscussie geweest over het verbinden van Beancount met Grafana. Een idee was een Grafana Data Source Plugin die on-the-fly BQL-queries tegen een Beancount-bestand zou kunnen uitvoeren. Dit zou Grafana-panelen in staat stellen direct bijvoorbeeld "Saldo van checkingsrekening" als een gauge of "Uitgaven over de laatste 30 dagen" als een grafiek weer te geven, door het grootboek te bevragen. Op dit moment (2025) is er geen speciale plugin gepubliceerd, maar enthousiastelingen hebben ad-hoc oplossingen gebouwd. Een Reddit-gebruiker aquilax bouwde bijvoorbeeld een eenvoudige server die Ledger CLI-gegevens beschikbaar stelt aan Grafana, en deelde deze als grafana-ledger-datasource-server. Een vergelijkbaar concept kan op Beancount worden toegepast: je zou een kleine HTTP-server in Python schrijven die het Beancount-grootboek laadt (met Beancount's API om gegevens te bevragen) en endpoints beschikbaar stelt die JSON-databronnen voor Grafana retourneren. Grafana heeft een generieke JSON-databron-plugin die vervolgens van deze API kan putten. In de praktijk betekent dit dat je een Grafana-dashboard kunt ontwerpen met panelen zoals "Maandelijkse omzet (staafdiagram)" of "Dagelijks kassaldo (lijngrafiek)", en die panelen halen gegevens op uit je Beancount-gestuurde API. Grafana zou rijke visualisatiemogelijkheden bieden (annotaties, drempels, combineren met servermetrics, enz.). Andreas Gerstmayr (een van Fava's maintainers) suggereerde precies deze aanpak en noemde zelfs dat hij een Fava-extensie genaamd fava-dashboards had gemaakt (daarover hieronder meer) om grafieken van BQL-queries weer te geven, als alternatief voor een volledige Grafana-opstelling. Als je de voorkeur geeft aan Grafana's UI, is integratie haalbaar – het vereist alleen het bouwen van de databrug.

• Metabase (ad-hoc queries en dashboards): Metabase is een gebruiksvriendelijke BI-tool waarmee je queries kunt uitvoeren en dashboards kunt maken zonder code. Als je je grootboek exporteert naar een relationeel formaat (via Beanpost of door tabellen van transacties, boekingen, enz. uit te schrijven), kun je Metabase op die database richten. Je kunt aangepaste tabellen maken zoals expenses (date, category, amount) vanuit je grootboek, en vervolgens in Metabase gemakkelijk grafieken genereren (bijv. een taartdiagram van uitgaven per categorie voor de afgelopen maand). Het voordeel is dat niet-technische gebruikers (of collega's) vervolgens met de gegevens kunnen interacteren via Metabase's GUI zonder het Beancount-bestand aan te raken. Het nadeel is dat je de export/synchronisatie moet onderhouden. Sommige gebruikers hebben de nachtelijke conversie van het Beancount-grootboek naar SQLite geautomatiseerd en laten Metabase vervolgens de SQLite lezen; anderen gebruiken misschien de genoemde Postgres-aanpak. Het belangrijkste is dat de gegevensportabiliteit van Beancount dit mogelijk maakt – je bent vrij om de gegevens te dupliceren naar elke vorm die je externe tool nodig heeft.

• Aangepaste front-ends / applicaties: Als je specifieke behoeften hebt, kun je altijd een aangepaste applicatie bovenop Beancount schrijven. De Beancount Python-bibliotheek geeft je toegang tot alle geparseerde boekingen, saldi, enz., dus een Python-webframework (Flask, Django, FastAPI) kan worden gebruikt om een op maat gemaakte app te bouwen. Een klein bedrijf zou bijvoorbeeld een dashboard kunnen bouwen dat KPI-metrics toont (zoals brutomarge, dagelijkse omzet, enz.) door het grootboek te bevragen en mogelijk te combineren met niet-grootboekgegevens (zoals het aantal bediende klanten). Een communitylid bouwde een mobielvriendelijke web-UI omdat Fava niet intuïtief was voor hun echtgenoot – ze gebruikten het grootboek in een database om deze aangepaste UI aan te sturen. Als je de voorkeur geeft aan JavaScript/TypeScript, kun je een tool gebruiken om het grootboek naar JSON te converteren en van daaruit verder te bouwen. Fava zelf stelt zijn Query-pagina beschikbaar via een JSON-query-API, dus een aangepaste front-end kan er BQL naartoe sturen en de geretourneerde tabellen weergeven in plaats van een nieuwe query-backend te bouwen.

• Excel/Power BI-integratie: Het is het vermelden waard dat je zelfs kunt integreren met Excel of Power BI. Totdat bea query native CSV-export krijgt, gebruik je Fava's Query-pagina-export voor spreadsheetbestanden die Excel direct opent. Een workflow zou kunnen zijn: een nachtelijke taak genereert een CSV-bestand met belangrijke financiële gegevens uit Beancount, en Power BI is ingesteld om dat bestand te importeren. Dit is een beetje indirect, maar voor organisaties die al veel Excel/Power BI gebruiken, is het een integratie met lage drempel. Power BI ondersteunt ook Python-databronnen, dus je zou een kort Python-script kunnen schrijven dat BQL-queries uitvoert en dat als gegevensbron binnen Power BI gebruiken, waarmee je een directe verbinding bereikt.

Casestudy – Idee voor Grafana-integratie: Josh, een Beancount-gebruiker, vroeg op de mailinglijst naar het pushen van Beancount-metrics naar Prometheus en het bekijken in Grafana. De kernontwikkelaars antwoordden dat in plaats van gegevens in Prometheus te dupliceren, een betere aanpak een Grafana-plugin of -service is die het Beancount-grootboek direct bevraagt. Andreas deelde zijn fava-dashboards-extensie die aangepaste grafieken binnen Fava zelf weergeeft als voorbeeldoplossing. De conclusie is: je hebt opties – ofwel integreren via bestaande BI-infrastructuur (Prometheus+Grafana of SQL+Metabase) ofwel Fava uitbreiden om aan je behoeften te voldoen (de volgende sectie gaat daar dieper op in).

Beveiliging en multi-user overwegingen: Als je integreert in externe tools, let dan op de gevoeligheid van gegevens. Beancount's platte tekst bevat vaak privéfinanciële informatie, dus elke server die deze beschikbaar stelt, moet worden beveiligd (geauthenticeerd). Als je gegevens naar een cloud-BI-tool verplaatst, kun je wat privacy verliezen. Zelfgehoste tools (open-source versies van Grafana/Metabase) kunnen lokaal worden gedraaid om dat te beperken. Ook, als meerdere mensen dashboards moeten bekijken, kan een extern alleen-lezen dashboard de voorkeur hebben boven iedereen toegang geven tot Fava (waar ze gegevens kunnen bewerken als ze niet voorzichtig zijn). Een startup zou Beancount bijvoorbeeld intern kunnen gebruiken, maar Metabase gebruiken om afdelingshoofden bestedingen versus budget te laten zien zonder de grootboekbestanden aan te raken.

Samengevat: Beancount en Fava werken goed samen met anderen. Je kunt het hele ecosysteem van datatools benutten met wat lijmcode: grootboekgegevens naar een SQL-database pushen voor BI-tools, ze via API's serveren voor webapps, of zelfs gespecialiseerde bibliotheken gebruiken om ze naar tijdreekssystemen te streamen. Deze flexibiliteit betekent dat je nooit vastloopt als Fava's ingebouwde visuals niet aan een nichevereiste voldoen – je kunt altijd integreren in een ander platform terwijl je Beancount als je bron van waarheid blijft gebruiken. Vervolgens kijken we naar het uitbreiden van Fava zelf met plugins en aangepaste dashboards, wat vaak een gemakkelijkere route is dan externe integratie als je gewoon een paar extra functies nodig hebt.

Aangepaste Dashboards en Fava Uitbreiden met Plugins (Codevoorbeelden)​

Fava is ontworpen om uitbreidbaar te zijn: je kunt nieuwe pagina's, grafieken en gedragingen toevoegen door Fava-plugins (extensies) in Python te schrijven. Dit maakt het mogelijk de webinterface aan te passen aan je specifieke behoeften zonder een volledig aparte app te bouwen. We verkennen twee belangrijke manieren voor aanpassing: (1) het gebruiken of schrijven van Fava-extensies, en (2) het opzetten van aangepaste dashboards via communityplugins zoals fava-dashboards.

Fava Extensions (Aangepaste Plugins)​

Een Fava-extensie is in wezen een Python-module die een subklasse van fava.ext.FavaExtensionBase definieert. Wanneer Fava start, kan het deze module laden en in de app integreren. Extensies kunnen nieuwe rapportpagina's registreren, inhaken op gebeurtenissen en zelfs aangepaste JavaScript bevatten voor interactiviteit. Fava 1.30.16 bundelt er twee: fava.ext.auto_commit en fava.ext.portfolio_list. Andere kunnen via pip worden geïnstalleerd of vanaf nul worden geschreven.

Om een extensie in te schakelen gebruik je het Beancount custom directive in je grootboekbestand:

2010-01-01 custom "fava-extension" "my_extension_module" "{'option': 'value'}"

Dit vertelt Fava de gegeven module te laden. Als je een extensie via pip hebt geïnstalleerd, verwijs je hier naar de modulenaam. De optionele string aan het einde is configuratie voor de extensie. Fava parseert deze als een Python-literal, dus "{'option': 'value'}" komt aan als een dict.

Voorbeeld – Auto-Commit-extensie: De meegeleverde fava.ext.auto_commit commit wijzigingen naar git wanneer je het bestand via Fava bewerkt. Als je het wilde gebruiken, zou je toevoegen:

2025-01-01 custom "fava-extension" "fava.ext.auto_commit"

Het overschrijft after_write_source, after_insert_entry, after_entry_modified, after_delete_entry en after_insert_metadata. Elke hook voert een git commit uit in de eigen map van het grootboekbestand. Het grootboek moet dus al in een git-checkout staan. Het demonstreert hoe extensies inhaken op Fava's bewerkingsgebeurtenissen.

Voorbeeld – Portfolio List-extensie: De meegeleverde fava.ext.portfolio_list voegt een pagina toe die je beleggingsrekeningen vermeldt. Het stelt report_title = "Portfolio List" in en levert een template mee. Fava detecteert dat en voegt een nieuw zijbalkitem "Portfolio List" toe onder Rapporten. Het stelt ook has_js_module = True in om de bijbehorende JavaScript te laden. Om het expliciet in te schakelen zou je toevoegen:

2025-01-01 custom "fava-extension" "fava.ext.portfolio_list"

(Geen configuratie nodig in dit geval.)

Een aangepaste extensie schrijven: Stel dat je een aangepaste rapportpagina wilt, bijvoorbeeld "Receivables Aging" voor facturen. Je zou een bestand receivables.py kunnen maken zoals:

# receivables.py
from fava.ext import FavaExtensionBase
 
 
class ReceivablesReport(FavaExtensionBase):
    report_title = "Receivables Aging"
 
    def after_load_file(self):
        # Runs after Fava loads the ledger. Summarise open
        # invoices here so the template only renders.
        self.overdue = [
            txn for txn in self.ledger.all_entries
            if "invoice" in getattr(txn, "tags", set())
        ]

Je zou ook een templates/ReceivablesReport.html naast de module maken om de HTML voor de pagina te definiëren. In die template kun je attributen lezen zoals self.overdue die je hook heeft voorbereid. Zodra deze extensie is geschreven, voeg je aan je grootboek toe:

2025-01-01 custom "fava-extension" "receivables"

(ervan uitgaande dat receivables.py in de map van het Beancount-bestand of op de PYTHONPATH staat, kan Fava het op naam vinden). Bij het starten van Fava zie je nu een pagina "Receivables Aging".

Onder de motorkap roept Fava de methoden van je extensie aan op vaste punten. De beschikbare hooks in Fava 1.30.16 zijn after_load_file, before_request, after_entry_modified, after_insert_entry, after_delete_entry, after_insert_metadata en after_write_source. Een methode gedecoreerd met @extension_endpoint wordt bovendien een JSON-API-endpoint onder de extensie. Meestal zijn de geboden hooks plus een template voldoende.

De Fava-documentatie merkt op dat het extensiesysteem nog in ontwikkeling is, maar het is bruikbaar. In feite zijn veel geavanceerde functies geprototypeerd als extensies.

Aangepaste Dashboards met fava-dashboards (Community Extensie)​

In plaats van een extensie vanaf nul te schrijven, kun je de door een Fava-maintainer gemaakte fava-dashboards-plugin van derden gebruiken. Deze extensie stelt je in staat willekeurige dashboards te definiëren via een YAML-configuratiebestand, met tekst, tabellen en grafieken, aangedreven door BQL-queries. Het is in feite een manier om nieuwe "pagina's" in Fava te maken die meerdere aangepaste panelen bevatten.

Installatie en opzet: Eerst installeer je het pakket (bijv. pip install fava-dashboards). Versie 2.0.2 laadt schoon naast Fava 1.30.16. Activeer het vervolgens in je Beancount-bestand met een custom directive die naar je dashboards-configuratie verwijst. Bijvoorbeeld:

2010-01-01 custom "fava-extension" "fava_dashboards" "{ 'config': '/path/to/dashboards.yaml' }"

(fava-dashboards/README.md at main · andreasgerstmayr/fava-dashboards · GitHub). Dit vertelt Fava de fava_dashboards-module te laden en je YAML-bestand voor configuratie te lezen.

YAML-formaat voor dashboards: In dashboards.yaml definieer je een of meer dashboards en hun panelen. Twee regels komen uit de eigen pijplijn van de extensie. Aggregaatkolommen hebben een AS-alias nodig. En de BQL-tekenconventie geldt: inkomstensommen komen negatief aan, uitgaven positief. Bijvoorbeeld:

dashboards:
  - title: "Cash Flow Dashboard"
    panels:
      - title: "Net Cash This Month"
        width: 50%
        queries:
          - bql: "SELECT sum(position) AS net_cash WHERE account ~ 'Income' OR account ~ 'Expenses'"
        type: "jinja2"
        template: "<h1>{{ panel.queries[0].result[0][0] }}</h1>"
      - title: "Spending by Category"
        width: 50%
        queries:
          - bql: "SELECT account AS category, sum(position) AS total WHERE account ~ 'Expenses' GROUP BY account ORDER BY account"
        type: "jinja2"
        template: "<table>{% for row in panel.queries[0].result %}<tr><td>{{ row[0] }}</td><td>{{ row[1] }}</td></tr>{% endfor %}</table>"

Het eerste paneel toont de gesommeerde positie direct. Op het uitgewerkte voorbeeldgrootboek geeft het (-4650.00 USD) weer. Dat is 6.000,00 USD aan inkomsten netto na 1.350,00 USD aan uitgaven. Het tweede paneel loopt over de queryrijen in een tabel. Het project geeft ook grafiekpanelen weer van dezelfde queries. Zie de gelinkte README voor de API van grafiekscripts.

De extensie zorgt voor het weergeven hiervan wanneer je de dashboardpagina in Fava opent. Je kunt meerdere dashboards maken (elk verschijnt als een tabblad of aparte pagina). Dit is uiterst krachtig voor het maken van aangepaste financiële dashboards. Je zou bijvoorbeeld een "Budget versus Werkelijk"-dashboard kunnen maken: één paneel toont een tabel van budget versus werkelijk per categorie (via een query die twee rekeningensets vergelijkt), een ander paneel toont een staafdiagram van bestedingen jaar-tot-nu versus vorig jaar, enz. Dit alles met alleen configuratie en minimale scripting, gebruikmakend van je grootboekgegevens via BQL.

Codevoorbeeld – fava-dashboards inschakelen: Zoals hierboven getoond is het toevoegen van de extensie één regel in je grootboek. Voor de volledigheid een minimaal voorbeeld daarvan in context:

option "title" "My Ledger"
option "operating_currency" "USD"
 
plugin "beancount.plugins.auto_accounts"  ; (auto-opens accounts)
 
1970-01-01 custom "fava-extension" "fava_dashboards" "{ 'config': 'dashboards.yaml' }"

En in dashboards.yaml:

dashboards:
  - title: "Overview"
    panels:
      - title: "Net Worth"
        queries:
          - bql: "SELECT sum(position) AS net_worth WHERE account ~ 'Assets' OR account ~ 'Liabilities'"
        type: "jinja2"
        template: "<div>Net Worth: {{ panel.queries[0].result[0][0] }}</div>"

Op het uitgewerkte voorbeeldgrootboek geeft dit <div>Net Worth: (4650.00 USD)</div> weer. Een echt dashboard zou mooi formatteren en meer panelen toevoegen.

Met dit op zijn plaats toont Fava, wanneer je het draait en naar het "Overview"-dashboard navigeert, je berekende nettovermogen. Je kunt vervolgens de template verfijnen of grafieken toevoegen zoals nodig.

Andere noemenswaardige extensies: Naast fava-dashboards hebben communityleden plugins gebouwd zoals fava-investor voor beleggingsanalyse en fava-review voor transactiebeoordeling. Dit zijn pakketten van derden met hun eigen installatiestappen en Fava-compatibiliteitsbereiken. Controleer hun README's voordat je installeert. De community onderhoudt een "awesome-beancount"-lijst van plugins en tools. Door deze te doorbladeren vind je misschien een kant-en-klare extensie die aan je behoeften voldoet.

Wanneer uitbreiden versus extern integreren: Over het algemeen, als je behoefte puur presentatie of berekening op de bestaande grootboekgegevens is, is een Fava-extensie ideaal (houdt alles op één plek, respecteert filters, enz.). Als je behoefte het combineren van externe gegevens inhoudt of je een drastisch andere UI nodig hebt, kan externe integratie (vorige sectie) gerechtvaardigd zijn. Website-analytics naast financiën tonen bijvoorbeeld – beter in Grafana/Metabase; maar een nieuwe financiële KPI of rapport toevoegen – beter als Fava-plugin.

Voorbeeld – Een aangepaste KPI in Fava: Stel dat je het "Spaarquote" (percentage van het inkomen dat wordt gespaard) wilt bijhouden. Je zou dit kunnen doen met een extensie die het berekent en een klein vakje op de hoofdpagina toont. Of met fava-dashboards zou één paneel een Jinja2 kunnen zijn die Savings Rate: X% uitvoert door totale inkomsten en totale uitgaven te bevragen. Dit soort aangepaste metrics is heel gemakkelijk te injecteren met deze tools, terwijl het in een gesloten systeem zoals QuickBooks misschien onmogelijk is om een nieuwe metric op het dashboard te maken.

Dezelfde twee queries voeden een spaarquote-paneel. Let op de tekens: BQL sum(position) retourneert inkomsten als een negatieve positie en uitgaven als positief, en Jinja kan de ene positie niet van de andere aftrekken. Toon dus beide benen en vermeld het percentage in de template-tekst:

- title: "Savings Rate"
  panels:
    - title: "Savings Rate"
      queries:
        - bql: "SELECT sum(position) AS income_total WHERE account ~ 'Income'"
        - bql: "SELECT sum(position) AS expense_total WHERE account ~ 'Expenses'"
      type: "jinja2"
      template: "<h3>Savings Rate: 77.5% ({{ panel.queries[0].result[0][0] }} earned, {{ panel.queries[1].result[0][0] }} spent)</h3>"

Op het uitgewerkte voorbeeldgrootboek geeft dit Savings Rate: 77.5% ((-6000.00 USD) earned, (1350.00 USD) spent) weer. Het percentage is (6.000,00 − 1.350,00) / 6.000,00. Bereken het uit de groottes. Draai of trek de posities in de template niet om.

Het belangrijkste punt: Fava is geen statische tool – het is een uitbreidbaar platform. Met een beetje Python of zelfs alleen configuratiecode kun je het uitgebreid aanpassen. Veel gebruikers delen kleine scripts of extensies op forums om dingen te doen zoals het tonen van aankomende rekeningen, het genereren van PDF-facturen uit transacties, of het integreren van Beancount met belastingberekeningsbibliotheken. Wanneer je investeert in het leren of gebruiken van deze extensies, krijg je een zeer op maat gemaakt financieel analysesysteem zonder vanaf nul te beginnen.

Gebruikssituaties: Persoonlijke financiën versus klein zakelijk boekhouden​

Beancount en Fava kunnen zowel voor persoonlijke financiën als voor boekhouding van kleine bedrijven worden gebruikt, maar de use cases en voordelen verschillen enigszins in accent:

Persoonlijke financiën​

Voor individuen blinkt Beancount+Fava uit in het geven van volledige zichtbaarheid en inzicht in iemands financiën zonder afhankelijk te zijn van propriëtaire apps. Veelvoorkomende use cases voor persoonlijke financiën zijn:

• Het volgen van uitgaven en budgetteren: Velen gebruiken Beancount om elke uitgave vast te leggen en vervolgens bestedingspatronen te analyseren. Met Fava kunnen ze zien waar het geld elke maand naartoe gaat (treemap van uitgaven) en budgetten bijhouden door te vergelijken met verwachte waarden (sommigen doen dit via de Budgets-extensie of aangepaste queries). Een gebruiker beschreef dat na het adopteren van Beancount "analysis of financial data (spending, giving, taxes, etc.) is trivial. It’s easy to do with Fava, but also easy with scripts... I have one Python script that pulls data out of Beancount using BQL, then I use pandas to prepare a report.". Dit toont aan hoe particuliere gebruikers profiteren van zowel de ingebouwde UI als de mogelijkheid om indien nodig aangepaste analyses te scripten.

• Nettovermogen en het volgen van doelen: Omdat je alle activa (bankrekeningen, beleggingen, zelfs fysieke activa als je wilt) in één grootboek kunt opnemen, krijg je één weergave van je nettovermogen. Liefhebbers van persoonlijke financiën gebruiken dit om voortgang naar doelen te volgen (bijv. "FI-nummer" of het aflossen van schulden). Fava's grafieken die het nettovermogen in de tijd tonen zijn motiverend – je kunt letterlijk de curve van je vermogen zien. Het is gebruikelijk om verplichtingen zoals studieleningen of hypotheken in Beancount bij te houden en hun saldi bij te werken; het grootboek geeft dan een volledig beeld van financiële gezondheid.

• Beleggingen en crypto: Persoonlijk gebruik strekt zich vaak uit tot het volgen van een portfolio. Beancount kan aandelen, crypto, enz. aan, met kostprijsbasis en berekeningen van gerealiseerde winsten (via plugins of queries). Het voordeel boven de site van een broker is dat je over alle rekeningen heen kunt consolideren en de werkelijke vermogensallocatie kunt zien. Communityplugins zoals fava-investor voegen bijvoorbeeld beleggingsanalysepagina's toe aan Fava. Dit is iets wat hobbybeleggers meestal in Excel doen; Beancount biedt een meer rigoureuze, geautomatiseerde manier. Een blogpost getiteld "Beancount: DeFi Accounting For Noobs" illustreert zelfs het gebruik ervan om cryptocurrency-transacties en yield farming bij te houden, wat de flexibiliteit in moderne scenario's voor persoonlijke financiën aantoont.

• Persoonlijke financiën in meerdere valuta's: Als je in het buitenland woont of buitenlandse beleggingen aanhoudt, is Beancount uiterst nuttig omdat het valuta's kan omrekenen en aggregeren. Gebruikers hebben opgemerkt dat "many accounting software are not good at multi-currencies… With Beancount, you can define any commodity you want", en rapporten krijgen in je voorkeursvaluta. Voor een particuliere gebruiker die bijvoorbeeld een salaris in USD maar uitgaven in EUR heeft, is dit een groot pluspunt.

• Levensbijhouding en dagboek: Een onconventionele maar echte use case: sommigen behandelen het grootboek als een levenslog, taggen transacties met levensgebeurtenissen (zoals #wedding of #vacation2025) en gebruiken het vervolgens om kosten van evenementen te berekenen of zelfs als dagboek van activiteiten (financiële metadata als proxy voor levensgebeurtenissen). Het platte-tekstformaat en taggen maken dit mogelijk op een manier die traditionele tools niet gemakkelijk toestaan.

• Eenvoud en eigenaarschap: Persoonlijke financiën gaan ook over mentaliteit. Velen kiezen Beancount omdat ze "wanted to own this data and easily analyze it, and didn’t want to be locked into a subscription or vendor". De recente ondergang van Mint.com (een populaire gratis budgetteertool) heeft enthousiastelingen richting plaintext accounting gedreven voor levensduur. Met Beancount weten ze dat ze hun grootboek over 20 jaar nog steeds kunnen openen. Voor de financiën van één individu geven Beancount's gegevens (misschien gesynchroniseerd via Dropbox of Git) en Fava's web-UI (die lokaal of op een privéserver kan draaien) een balans van gemak en controle die elders moeilijk te vinden is.

Potentiële uitdagingen voor persoonlijk gebruik: de eerste opzet en het leren van dubbel boekhouden kunnen voor sommigen een drempel zijn. Maar veel bronnen (zoals de Beancount-tutorial en communityforums) helpen nieuwe gebruikers. Eenmaal opgezet kan het onderhoud grotendeels worden geautomatiseerd zoals beschreven, wat geweldig is voor iemand die zijn huishoudfinanciën met minimale inspanning beheert.

Kleine Ondernemingsboekhouding​

Kleine bedrijven, startups en freelancers kunnen Beancount+Fava ook gebruiken, hoewel de vereisten hier meer formele rapportage en misschien samenwerking omvatten:

• Boekhouden en financiële overzichten: Een bedrijf kan zijn grootboek bijhouden in Beancount, met vastlegging van facturen, rekeningen, loonadministratie, enz., en balans- en winst-en-verliesrekeningen produceren. Beancount ondersteunt de benodigde accrual-boekhouding (je kunt rekeningen markeren als Debiteuren/Crediteuren en facturen vastleggen met boekingen naar inkomsten en debiteuren, en later een betaling om debiteuren af te wikkelen). Fava toont die dan gepast onder Activa of Passiva. Een Reddit-discussie vroeg of Beancount geschikt is voor bedrijven en of het correcte financiële overzichten kan genereren – ja, het kan balansen, winst-en-verliesrekeningen en (met wat query-hulp) cashflowoverzichten produceren, aangezien dat gewoon weergaven van de dubbel-boekhoudgegevens zijn. Het addertje onder het gras is dat Beancount geen specifieke boekhoudnormen afdwingt (dat hangt af van hoe je het gebruikt). Dus een deskundige gebruiker (of accountant) moet het rekeningschema correct opzetten voor het bedrijf. Er zijn communityvoorbeelden van Beancount dat voor startups wordt gebruikt – een HN-commenter zei: "I really enjoy using Beancount + Git for managing the accounting book for my own startup company", hoewel ze opmerkten dat het een beetje vervelend was om periodiek boekingen toe te voegen. Die verveling kan worden verlicht met importautomatisering zoals we zagen.

• Real-time financiële monitoring: Voor een klein bedrijf is cashflow koning. Met Fava kan een bedrijfseigenaar de banksaldi en cashflow bijna in real-time monitoren, net als bij persoonlijke financiën – maar het is hier nog kritischer. Door bankfeeds of imports te automatiseren kunnen ze opvangen of een klantbetaling is binnengekomen of een grote uitgave is afgewikkeld. QuickBooks biedt bankfeeds die "let you see how your business is doing in real time"; met Beancount repliceer je dit met je eigen bankintegratie. Het voordeel van Beancount is transparantie – je ziet precies wat is geïmporteerd en hoe het is gecategoriseerd, in plaats van QuickBooks' soms ondoorgrondelijke matching-logica te vertrouwen.

• Facturering en debiteuren/crediteuren: Beancount heeft geen ingebouwde factureringsmodule (zoals het genereren van PDF-facturen of het bijhouden van factuurnummers). Creatieve gebruikers hebben dit echter met add-ons opgelost. Je zou bijvoorbeeld een factuur-PDF kunnen genereren uit een transactie met een Jinja2-template of zelfs een extern script dat openstaande debiteurenposten leest. Er is een project "Beanie" dat als lichtgewicht debiteurensysteem bovenop Beancount werkt. Kleine bedrijven gebruiken Beancount misschien voor het grootboek en een andere tool voor het uitgeven van facturen, en importeren de factuurgegevens vervolgens in Beancount. Het is een extra stap vergeleken met QuickBooks (dat facturen kan verzenden en ze vervolgens automatisch kan vastleggen zodra ze betaald zijn), maar het zorgt ervoor dat alle gegevens in het open grootboek terechtkomen.

• Loonadministratie en afschrijving: Dit zijn boekhoudtaken die kleine bedrijven uitvoeren. Beancount kan zeker loonboekingen vastleggen (het splitsen van brutoloon, belastingen, inhoudingen, enz. in de juiste rekeningen) – maar je zou die doorgaans berekenen met externe tools of je loonadministratieprovider en ze vervolgens invoeren. Afschrijvingsschema's voor vaste activa zouden eveneens handmatig moeten worden ingevoerd (of je zou een plugin kunnen schrijven om maandelijkse afschrijvingsboekingen te automatiseren). Beancount heeft hier geen magie voor, maar veel software voor kleine bedrijven ook niet, afgezien van wat templates. Het voordeel is dat je alles wat ongebruikelijk is kunt scripten. Als je bijvoorbeeld een aangepast schema voor omzetverantwoording hebt, kun je die journaalboekingen in Python scripten en opnemen.

• Transparantie en controleerbaarheid: Bedrijven waarderen wellicht dat Beancount een duidelijke audittrail biedt. Elke transactie is duidelijk en kan worden geannoteerd met links naar documenten (bonnen, contracten). Bij een audit kun je het grootboekbestand samen met bijgevoegde documenten tonen, wat vrij eenvoudig is. Versiebeheer betekent ook dat je een auditlog hebt van wie/wanneer wijzigingen heeft aangebracht (als meerdere mensen samenwerken via Git). Vergelijk dit met QuickBooks, waar een accountant wijzigingslogboeken moet onderzoeken die niet gemakkelijk toegankelijk zijn voor de gebruiker.

• Kosten: Beancount+Fava is gratis, wat aantrekkelijk is voor startups of kleine bedrijven die softwarekosten proberen te minimaliseren. QuickBooks, Xero, enz. hebben maandelijkse kosten. De afweging is echter dat die ondersteuning en een gemakkelijkere opzet bieden. Een technisch onderlegde bedrijfseigenaar ruilt misschien graag wat tijd in om kosten te besparen en flexibiliteit te winnen.

Echte voorbeelden: Een andere gebruiker op HN zei dat hij het voor een advies-LLC gebruikte en dat het goed werkte, maar dat toen het aantal transacties groeide, hij bestanden per jaar begon te splitsen om de snelheid te behouden. De consensus is: voor een klein bedrijf (zeg tienduizenden transacties per jaar of minder) is Beancount perfect capabel. Als je een grotere MKB'er zou zijn met honderdduizenden transacties, zou de prestaties kunnen rechtvaardigen dat je een database-aanpak gebruikt of een speciaal gebouwd boekhoudsysteem kiest – hoewel we Beanpost hebben om dat aan te pakken door Postgres als backend te gebruiken.

Samenwerking: Een verschilpunt – QuickBooks Online laat meerdere gebruikers (eigenaar, accountant, enz.) gelijktijdig werken. Met Beancount kan samenwerking via Git (meerdere gebruikers committen wijzigingen). Dit werkt, maar vereist enige Git-kennis en conflictoplossing als mensen tegelijkertijd bewerken. Sommigen hebben online Git-platforms of zelfs Google Drive gebruikt om het grootboekbestand te delen. Het is haalbaar, maar niet zo naadloos als cloudboekhoudsoftware. Voor een klein team (of solo-boekhouder + eigenaar) is het echter beheersbaar, en je kunt altijd alleen-lezen toegang verlenen via Fava (host het op een interne server en laat anderen rapporten bekijken zonder te bewerken).

Regelgevende naleving: Voor persoonlijke financiën geen probleem. Voor bedrijven moet je misschien officiële rapporten produceren of boekhoudnormen volgen. Beancount kan worden gebruikt om GAAP-conforme overzichten te genereren, maar het vereist dat de gebruiker de gegevens dienovereenkomstig invoert. Er is geen ingebouwde handhaving van GAAP-regels (bijv. geen ingebouwde module voor vaste activa om ervoor te zorgen dat je correct afschrijft). Een externe accountant kan nog steeds met een Beancount-grootboek werken (aangezien het in feite een gegeneraliseerd journaal is) – hij zou het naar Excel kunnen exporteren en indien nodig aanpassingen doen. Sommige bedrijven geven hierdoor misschien de voorkeur aan bekende software, of hebben op zijn minst een accountant die vertrouwd is met platte-tekstgegevens.

Wie gebruikt het voor bedrijven? Waarschijnlijk power users: technische startups, freelancers met een programmeerachtergrond, of bedrijven die sterk waarde hechten aan gegevenscontrole (bijv. misschien financiële handelsfirma's die aangepaste rapportage willen). Een Reddit-thread had iemand die vroeg of Beancount geschikt zou zijn voor een handelsbedrijf – antwoorden gaven aan dat het ja is, het ondersteunt meerdere valuta's en kan de benodigde overzichten produceren, maar je zult er wat tooling omheen moeten bouwen.

Ter afsluiting van deze sectie: Gebruikers van persoonlijke financiën houden van Beancount vanwege het inzicht en de controle die het geeft over hun persoonlijke geld – het verandert financiën in een dataset die ze kunnen bevragen en waarvan ze kunnen leren, wat leidt tot zaken als het gemakkelijk volgen van elke uitgave en het berekenen van metrics die typische budgetteertools niet kunnen. Gebruikers van kleine bedrijven waarderen de transparantie, kostenbesparingen en hackbaarheid – ze kunnen boekhouding integreren met de rest van hun softwarestack en vendor lock-in of maandelijkse kosten vermijden. Beide use cases profiteren van real-time analyses: een persoon kan de voortgang van zijn maandbudget volgen, een bedrijf kan dagelijkse cashflows volgen – in beide gevallen kan Fava actuele informatie presenteren wanneer het tijdig van gegevens wordt voorzien.

Vergelijking met Andere Realtime Analytics Platforms​

Het is nuttig om Beancount+Fava te vergelijken met andere oplossingen die "real-time" financiële analyses bieden, zoals QuickBooks (met live bankfeeds) en Power BI (of vergelijkbare BI-dashboards). Elke aanpak heeft zijn sterke en zwakke punten wat betreft transparantie, flexibiliteit en responsiviteit:

Samengevat, Beancount+Fava versus QuickBooks: Beancount biedt superieure transparantie (je ziet en beheert alles, en je gegevens zullen niet verdwijnen of opgesloten worden) en flexibiliteit (je kunt alles in het grootboek modelleren, niet alleen wat QuickBooks verwacht). Het vereist meer doe-het-zelven, vooral voor automatisering en mooie UI-details. QuickBooks is een plug-and-play oplossing geoptimaliseerd voor de behoeften van kleine bedrijven – bankfeeds, facturering, loonadministratie (met add-ons) – en biedt bijna real-time updates met minimale gebruikersinspanning. Het is echter in veel opzichten een black box; je vertrouwt erop dat de software je gegevens correct verwerkt, en soms betekent dat dat het moeilijk is fouten te corrigeren of te begrijpen hoe het tot een getal is gekomen. Veel Beancount-gebruikers zijn mensen die gefrustreerd raakten door die black boxes. Ze ruilen wat gemak in voor duidelijkheid.

Beancount+Fava versus Power BI (of andere BI): Ze kunnen complementair zijn. Power BI is geen boekhoudsysteem; het is voor analyse. Een geavanceerde opzet zou Beancount kunnen gebruiken om te consolideren en de nauwkeurigheid van gegevens te waarborgen, en vervolgens Power BI gebruiken om executive dashboards van die gegevens te maken. Als we direct vergelijken, gaat Power BI meer over visuele flexibiliteit en het combineren van gegevensbronnen. Fava's grafieken zijn eenvoudiger van opzet (gericht op boekhoudkundige behoeften) maar vereisen veel minder werk om te beginnen (ze werken out-of-the-box op je grootboek, geen modellering nodig). Als je doel puur is om inzichten en mooie visuals te krijgen en je bereid bent de gegevens voor te bereiden, kan een BI-tool passend zijn. Maar als je doel is de boeken bij te houden en interactieve rapporten als bijproduct te krijgen, volstaat Fava alleen vaak.

Je zou ook kunnen vergelijken met andere tools voor persoonlijke financiën (bijv. Mint of YNAB) of ERP-systemen, maar de vraag noemt specifiek real-time analyseplatforms. Op het gebied van real-time financiële weergaven: Beancount+Fava is als het hebben van een aangepast, open-source "live" finansdashboard, QuickBooks is een gesloten-source geautomatiseerde boekhouding met live banksynchronisatie, en Power BI is een flexibel analyseplatform (niet specifiek financieel, maar kan voor financiën worden gebruikt als het wordt gevoed met gegevens).

Een veelzeggend citaat dat open-source versus commercieel contrasteert: "With a little effort upfront, open source tooling can actually be way better than commercial solutions, and far more flexible and extensible." Dit vat de afweging samen. QuickBooks is gepolijst en werkt out-of-the-box voor gangbare scenario's met minimale inspanning. Maar zodra je iets wilt dat het niet doet, loop je tegen een muur aan. Met Beancount loop je zelden tegen een muur aan – je hebt de broncode en gegevens, je kunt uitbreiden of integreren zoals nodig. De prijs is dat je bereid moet zijn te sleutelen.

Voor- en nadelen van het gebruik van Fava en Beancount voor datagestuurde inzichten​

Laten we tot slot de voordelen en nadelen van Beancount+Fava als oplossing voor financiële analyses destilleren:

Voordelen​

• Transparantie en vertrouwen: Alle berekeningen (totalen, saldi) zijn afgeleid van een platte-tekstgrootboek dat je kunt inspecteren. Er is geen mysterieus gedrag. Dit wekt groot vertrouwen in de cijfers – cruciaal als je beslissingen erop baseert. Het is "clean, transparent accounting" zonder lock-in. Je kunt een gerapporteerd cijfer altijd terugvoeren naar de onderliggende transacties, wat de essentie is van datagedreven inzicht.

• Reproduceerbaarheid en audittrail: Omdat je het grootboek kunt versioneren, heb je een tijdlijn van wijzigingen. Als iets deze maand niet klopt, kun je het grootboek diffen om te zien wat er is veranderd. Dit betekent ook dat je kunt experimenteren ("wat als ik deze uitgave herclassificeer?") en gemakkelijk ongedaan kunt maken. Datagedreven werk omvat vaak iteraties, en een controleerbaar grootboekmoedigt dat aan.

• Flexibiliteit in analyse: Je bent niet beperkt tot vooraf gebouwde rapporten. De combinatie van BQL-queries, Python-scripting en Fava's filters betekent dat je bijna elke financiële vraag kunt beantwoorden. Wil je weten "How much have I spent at Starbucks each year for the last 5 years?" – één query verwijderd. Of "What’s the moving average of my 3-month expenses vs income?" – scriptbaar met Python+pandas bovenop een query. Deze flexibiliteit is een groot pluspunt voor wie graag in gegevens duikt. Power users hebben zelfs extensies gebouwd om financiële indicatoren (bijv. portefeuilleprestatiemetrics) binnen Fava te berekenen. Kortom, je kunt zeer granulaire inzichten krijgen die veel kant-en-klare software niet kan bieden.

• Integratie en uitbreidbaarheid: Fava's pluginsysteem en de toegankelijke Beancount-API betekenen dat de tools kunnen meegroeien met je behoeften. Als je morgen een nieuw soort activa moet volgen of een nieuwe gegevensfeed wilt integreren, kun je het systeem uitbreiden. De architectuur (platte tekst in, diverse outputs uit) is zeer uitbreidbaar. Dit staat in contrast met gesloten systemen waar je misschien een functie moet aanvragen en moet wachten.

• Gegevensconsolidatie: Voor individuen en zelfs bedrijven is het kunnen consolideren van alle rekeningen (meerdere banken, brokers, enz.) in één systeem krachtig. Veel commerciële oplossingen siloën je (of rekenen extra voor meerdere valuta's of meerdere entiteiten). Met Beancount kun je alles samenbrengen. Dit geeft een holistisch gegevensbeeld, waardoor inzichten over de hele linie mogelijk zijn. Je kunt bijvoorbeeld je werkelijke algehele vermogensallocatie of netto cashflow over persoonlijk en zakelijk berekenen als je dat wilde, aangezien het gewoon gegevensboekingen zijn.

• Kosteneffectiviteit: Het is gratis en open-source. Voor persoonlijk gebruik is dit een groot pluspunt (geen abonnement zoals veel budgetteerapps). Voor startups of kleine organisaties kunnen die besparingen oplopen. Maar naast de monetaire kosten is het ook efficiënt qua draaien (Fava kan op een kleine server draaien) en portabiliteit (geen kostbare migraties als je het ontgroeit – het is gewoon tekst).

• Community en kennisdeling: De plaintext accounting-community (Beancount, Ledger, enz.) is zeer collaboratief. Mensen delen hun configuraties, aangepaste scripts en tips op forums en blogs. Dit betekent dat als je een nichebehoefte hebt, iemand misschien iets vergelijkbaars heeft aangepakt. Meerdere gebruikers hebben bijvoorbeeld bijgedragen aan slimme importtools en zelfs machine learning-categorisering (bijv. de "smartimporter"-bibliotheek die scikit-learn gebruikt om begunstigden automatisch te categoriseren op basis van eerdere gegevens). Na verloop van tijd kan het gebruik van Beancount zelfs _slimmer worden als je deze communitytools benut – wat het gemak van commerciële software benadert terwijl de transparantie behouden blijft.

• Empowerment en leren: Het gebruik van Fava/Beancount dwingt je om je op een dieper niveau met je financiële gegevens bezig te houden. Veel gebruikers melden dat ze door dit systeem een veel beter begrip van hun financiën kregen dan ooit met geautomatiseerde apps. Het is een beetje als het verschil tussen je eigen maaltijd koken en fastfood halen – meer moeite, maar je weet precies wat erin zit en het kan op de lange termijn gezonder zijn. Voor datagedreven inzichten kan dit "eigenaarschap" van het proces leiden tot meer betekenisvolle ontdekkingen, omdat je gemakkelijk kunt herformuleren hoe je naar de gegevens kijkt.

Nadelen​

• Initiële opzet en leercurve: Laten we eerlijk zijn – Beancount en Fava zijn niet zo plug-and-play als bijvoorbeeld QuickBooks of Mint. Je moet de basis van dubbel boekhouden leren (als je die niet kent), de syntaxis van Beancount-bestanden, en mogelijk wat Python als je sterk wilt aanpassen. Deze initiële investering kan een drempel zijn. Voor niet-technische gebruikers kan het ontmoedigend zijn (hoewel Fava's interface veel helpt door een vriendelijkere ervaring te bieden zodra het is opgezet). Ter vergelijking: veel commerciële tools verbergen boekhoudconcepten achter eenvoudigere interfaces (wat zowel een voor- als een nadeel kan zijn).

• Geen ingebouwde banksynchronisatie: Door het ontwerp maakt het niet automatisch verbinding met bank-API's (die vaak propriëtair zijn of overeenkomsten vereisen). Dus je downloadt handmatig afschriften of zet je eigen automatisering op (via Python-scripts of diensten zoals Plaid die vaak geld kosten). Voor wie gewend is dat bankfeeds "gewoon werken", kan dit als een stap terug voelen. Een gebruiker merkte op dat hij bij het proberen van Beancount "did not find a reasonable way to get bank feeds" – dit kan frustrerend zijn tenzij je bereid bent te coderen of oplossingen van derden te gebruiken.

• Real-time betekent jouw tijd: Het bereiken van real-time responsiviteit is mogelijk maar niet out-of-the-box. Je moet cronjobs of triggers configureren zoals beschreven. Als iets kapotgaat (bijv. een bank verandert het CSV-formaat), moet je je importeur repareren. Met een dienst zoals QuickBooks regelt de leverancier zulke wijzigingen. In wezen ben je je eigen IT-ondersteuning. Dit is de klassieke open-source afweging. Voor een hobbyist kan dat prima of zelfs leuk zijn; voor een drukke eigenaar van een klein bedrijf kan het een last zijn.

• Schaalbaarheid en prestatiegrenzen: Voor zeer grote datasets (vele jaren van gedetailleerde transacties) kan Beancount langzamer worden. Het is over het algemeen efficiënt (mensen hebben tienduizenden boekingen zonder problemen). Maar zoals te zien in de HN-thread, moest een gebruiker na 3 jaar jaarlijks "de boeken sluiten" omdat het bestand groeide om queries snel te houden. De Beancount v2-code is Python en kan wat langzaam zijn voor enorme gegevens, hoewel v3 (in ontwikkeling met een C++-kern) dit verbetert. Er zijn mitigerende maatregelen (bestanden splitsen, Beanpost gebruiken om naar een database te offloaden, enz.), maar het is een overweging. QuickBooks heeft waarschijnlijk interne schaalbaarheid en de meeste BI-tools zijn gebouwd op databases die bedoeld zijn voor grote gegevens – dus die kunnen grote datasets misschien soepeler aan.

• Functiegaten (ten opzichte van speciale software): Beancount+Fava richt zich op boekhouden en analyse. Het mist sommige aanvullende functies: bijv. geen loonverwerking, geen factuurgeneratie (zonder aangepast scripten), geen geïntegreerde belastingformulieren, enz. Als je doel uitgebreid financieel beheer is, moet je misschien aanvullen met andere tools. Je zou bijvoorbeeld loonadministratie via een loondienst doen en gewoon de journaalboekingen importeren. Dat werkt, maar het is niet zo naadloos geïntegreerd als iets als een ERP dat alles in één doet. Voor persoonlijke financiën heeft Beancount geen dingen zoals ingebouwde schuldenaflossingsplanners of budgetteer-enveloppen (hoewel je deze kunt simuleren). Er wordt verwacht dat je inzichten afleidt en vervolgens beslissingen neemt, in plaats van voorschrijvend advies of planningsmodules te bieden.

• Gebruikersinterface en afwerking: Hoewel Fava heel aardig is, is het niet zo gepolijst of begeleidend als sommige commerciële aanbiedingen. Er is geen "wizard" om je door de opzet te leiden of te zorgen dat je geen fouten maakt. Je moet misschien documentatie lezen om te weten hoe je X doet. En bepaalde UI-functies die je zou verwachten (drag-and-drop categorisering, multi-step undo, mobiele pushmeldingen, enz.) zijn er niet. De Fava-UI verbetert voortdurend (met bijdragen), maar het wordt gebouwd door een kleine community. Als je gewend bent aan strakke moderne SaaS-UI's, kan Fava wat utilitair aanvoelen (hoewel sommigen juist de cleane eenvoud prefereren). Op mobiel werkt Fava (vooral alleen-lezen) maar het is niet volledig geoptimaliseerd voor kleine schermen; QuickBooks heeft bijvoorbeeld speciale mobiele apps.

• Afhankelijkheid van de community/maintainer: Martin Blais (Beancount's auteur) en bijdragers onderhouden Beancount, en anderen onderhouden Fava. Ontwikkeling kan sporadisch zijn (zoals normaal in OSS). Hoewel de software nu zeer bruikbaar is, moet je, als je een nieuwe functie nodig hebt of er is een bug, misschien zelf repareren of wachten. Met een betaald product heb je ondersteuning om te bellen (kwaliteit varieert, maar het is er tenminste). Dat gezegd hebbende is de community meestal zeer behulpzaam via de mailinglijst of GitHub-issues.

• Boekhoudkennis vereist: Vooral voor zakelijk gebruik moet je weten wat je doet. Beancount zal je niet tegenhouden om een boeking te maken die vanuit boekhoudkundig oogpunt "fout" is (behalve onbalans of niet-overeenkomende transactie). QuickBooks daarentegen heeft vangrails (en ook verborgen complexiteit zoals automatische uitgestelde-omzetregistratie, enz., als je die inschakelt). Als je niet voorzichtig bent in Beancount, zou je een accrual kunnen verpesten en het pas opmerken als je een rapportprobleem ziet. In wezen gaat Beancount ervan uit dat je ofwel de basisboekhouding onder de knie hebt of bereid bent het te leren. Dit is eigenlijk een voordeel voor sommigen (dwingt het goed te doen), maar een nadeel als je een systeem wilt waarbij je niet hoeft na te denken.

Om de voor- en nadelen samen te vatten: Beancount + Fava biedt ongeëvenaarde controle en aanpasbaarheid voor wie zich diep met zijn financiële gegevens wil bezighouden, wat het een krachtige tool maakt voor datagedreven inzichten. Het verandert je boeken in een doorzoekbare dataset en je rapporten in een uitbreidbare webapp. De prijs voor deze kracht is de inspanning die je investeert in het opzetten en onderhouden ervan, en de noodzaak om enigszins zelfvoorzienend te zijn in het beheren van je systeem. In tegenstelling tot iets als QuickBooks of een BI-suite, die meer bij de hand nemen en bepaalde functies automatisch leveren, geeft Beancount je een toolkit. Als je analytisch ingesteld bent, kan deze toolkit ongelooflijk bevrijdend zijn – je kunt inzichten extraheren die kant-en-klare rapporten misschien nooit tonen. Zoals een gebruiker die zijn Beancount-grootboek over jaren automatiseerde schreef: "open-source tools (like Beancount) don’t meet all my needs [out-of-the-box]… I am obsessed with automating everything… I built what I needed". Dit vat de aanpak samen: als je bereid bent te bouwen wat je nodig hebt, hoe klein of groot ook, zul je door Fava/Beancount worden ondersteund en zal het je gegevens nooit voor je verbergen. Voor een datagedreven mentaliteit is dat een enorm voordeel.

Concluderend is het gebruik van Fava en Beancount voor real-time financiële analyses een beetje als het hebben van je eigen aanpasbare laboratorium voor je financiën. Je krijgt duidelijkheid, flexibiliteit en eigenaarschap die moeilijk te evenaren zijn met propriëtaire platforms, wat het ideaal maakt voor wie deze aspecten waardeert en bereid is wat gemak in te leveren om ze te krijgen. Het moderne landschap toont zelfs hybride benaderingen – sommigen gebruiken bijvoorbeeld een commerciële tool maar exporteren periodiek naar Beancount voor diepere analyse, of omgekeerd gebruiken ze Beancount als primair en een BI-tool voor presentatie. Met de kennis uit dit onderzoek kan men een weloverwogen beslissing nemen of Fava+Beancount aansluit bij hun behoeften en, zo ja, vol vertrouwen doorgaan om de mogelijkheden ervan te benutten voor rijke, real-time financiële inzichten.

Bronnen:

• Blais, M. (2020). Beancount Documentation – Design principles and usage. [Online]. Beschikbaar: beancount.github.io
• Aumayr, D., Gerstmayr, A. (2025). Fava Documentation & GitHub Repository. [Online]. Beschikbaar: beancount.github.io/fava/ en github.com/beancount/fava
• LowEndBox. (2025). "Beancount: Lightweight FOSS Double-Entry Accounting...from the Command Line!" LowEndBox Tutorial.
• Fang-Pen Lin. (2024). "My Beancount books are 95% automatic after 3 years." Personal Blog Post.
• Google Groups – Beancount Forum. (2023). Discussion on Grafana integration (Josh D. and Andreas G.)
• QuickBooks Marketing Page. "Bank Feeds – Understand all your transactions in an instant." Intuit QuickBooks.
• Watt, A. (2023). "Beancount for Personal Finance." Alex Watt Blog.
• Reddit – r/plaintextaccounting. Various discussions (2021-2023) on business use of Beancount and ledger visualization.
• Fava Extension Documentation – Help: Extensions.
• fava-dashboards GitHub README – Andreas Gerstmayr's custom dashboards plugin.
• Awesome Beancount list – community-curated resources for Beancount.