Hoe Beancount en Fava real-time dashboards aandrijven

Inleiding​

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

Verken een live grootboekvoorbeeld:

Verken het live grootboek →

Kernmogelijkheden van Beancount en Fava​

Beancount (Plain-Text Boekhoudmotor)​

• Dubbele Boekhouding in Platte Tekst: Beancount slaat transacties op in een enkel .beancount tekstbestand (of meerdere samen opgenomen bestanden). Elke transactie moet in balans zijn (totaal debet = totaal credit) over rekeningen, wat de integriteit van de boekhouding waarborgt. Het platte tekstformaat betekent dat uw gegevens leesbaar zijn voor mensen, versiebeheerbaar en niet gebonden aan een specifieke leverancier.
• Flexibele, Hiërarchische Rekeningen: U kunt elke rekening definiëren (bijv. Assets:Bank:Checking, Expenses:Food:Coffee) in een hiërarchie. Beancount is niet dogmatisch over uw rekeningenstelsel, dus het werkt voor persoonlijke financiën, kleine bedrijfsboekhouding, investeringen, enzovoort – het is "flexibel: werkt voor persoonlijke financiën, kleine bedrijfsboekhouding, crypto, aandelenbeleggingen en meer."
• Meerdere Valuta's en Commodities: Beancount ondersteunt meerdere valuta's en commodities (bijv. aandelen, crypto) als een eersteklas functie. U kunt transacties in verschillende valuta's registreren, wisselkoersen definiëren (prijsrichtlijnen) en kostprijzen bijhouden. Rapporten kunnen "tegen kostprijs" of "tegen marktwaarde" worden geproduceerd als prijgegevens beschikbaar zijn. Dit maakt het geschikt voor portefeuilles en internationale financiën.
• Geautomatiseerde Checks en Balances: Het systeem ondersteunt balansverklaringen (u kunt aangeven wat de balans van een rekening moet zijn op een datum, en Beancount geeft een foutmelding als het niet overeenkomt) en balanstransacties voor het sluiten van boeken. Het ondersteunt ook openings-/sluitingsboekingen van eigen vermogen en berekening van ingehouden winsten voor periode afsluitingen. Dit helpt ervoor te zorgen dat uw boeken consistent blijven en fouten vroegtijdig worden opgespoord.
• Krachtige Query- & Rapportage-engine: Beancount wordt geleverd met een querytaal BQL (Beancount Query Language). Gebruik bea query voor BQL in de terminal en bea report voor standaardrapporten; installeer de CLI quick start in plaats van de oudere upstream console scripts. U kunt het grootboek bevragen voor aangepaste rapporten (bijv. een lijst van uitgaven per begunstigde, kasstroom voor een periode) – het grootboek als een database gebruiken. Het blijft snel, zelfs met duizenden transacties. Exporteer CSV met bea query -f csv -o report.csv "BQL", waarbij BQL vervangen wordt door uw query. Zie Financial Reporting Templates voor volledige voorbeelden.
• Uitbreidbaarheid via Plugins: Beancount is geschreven in Python en staat toe om aangepaste plugins toe te voegen die de functionaliteit uitbreiden. Plugins kunnen extra regels of berekeningen afdwingen wanneer het bestand wordt verwerkt. (Bijvoorbeeld zijn er plugins om tax lots te verwerken of om te zorgen dat geen aankoop zonder kostprijs is.) Het pluginsysteem en de Python API laten gevorderde gebruikers aangepaste gedragingen scripten of Beancount integreren met andere systemen.
• Importers voor Externe Data: Een belangrijke praktische functie is het importer-framework in het aparte beangulp pakket (er is geen beancount.ingest module in Beancount 3.2.3). U schrijft een importer-klasse die erft van beangulp.Importer en identify, extract en account implementeert. Het parseert een gedownload bestand (CSV, OFX, PDF-afschriften, enz.) en zet dit om in Beancount-invoerregels. Dit is essentieel voor automatisering (hier later meer over).
• Controleerbaar en Versiebeheer-vriendelijk: Omdat het platte tekst is, kunt u uw grootboek in Git of een ander versiebeheersysteem bijhouden. Elke wijziging is transparant en u heeft een volledige geschiedenis van aanpassingen. Dit maakt audits of het beoordelen van wijzigingen eenvoudig (veel gebruikers committen iedere dag hun wijzigingen naar een Git-repository, wat een bewijsbare log van alle financiële invoer geeft). Dit niveau van transparantie is een belangrijk onderscheid ten opzichte van gesloten boekhoudsoftware – "geen SaaS-lock-in—gewone, transparante boekhouding met krachtige rapportage."

Fava (Webinterface voor Beancount)​

• Interactieve Web UI: Fava biedt een lokale webserver die je Beancount-boekhouding weergeeft in een rijke gebruikersinterface. Het toont kernrapporten (Winst- en Verliesrekening, Balans, enz.), rekeningregisters en dagboeken in de browser met interactieve bediening. De gebruikersinterface is dynamisch en gebruiksvriendelijker dan de commandoregel. Je start het met een simpele fava yourfile.beancount en krijgt een webapp voor je boekhouding.
• Grafieken en Diagrammen Ingebouwd: Fava genereert grafieken om je data te visualiseren. Bijvoorbeeld, het bevat een Netto Vermogen lijngrafiek over tijd, staafdiagrammen voor inkomsten versus uitgaven per maand, en taart-/boomdiagrammen voor uitgavenopdelingen. Deze visuals worden bijgewerkt met je data en ondersteunen verschillende weergaven (bijv. “tegen kostprijs” versus “marktwaarde” voor investeringen). We zullen deze visualisatiemogelijkheden later in detail verkennen.
• Filteren en Zoeken: Bovenaan de pagina's van Fava bevindt zich een filterbalk waarmee je je data real-time kunt uitsnijden en filteren. Je kunt filteren op tijd (bijv. jaar, kwartaal, maand), op rekening-regex, op begunstigde, op toelichting, of op tags/links. Dit maakt het gemakkelijk om data inspectie in real-time te doen – bijvoorbeeld snel filteren op “Tag=Reizen” en “Jaar=2025” om alle reiskosten in 2025 te zien, inclusief 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 boekhoudingen gescheiden houdt) en tussen deze wisselen. Het kan ze ook consolideren indien nodig (bijvoorbeeld privé- en zakelijke boekhoudingen samen bekijken).
• Data Invoer en Bewerking: Uniek is dat Fava niet alleen-lezen is – het heeft een editor en formulier voor transacties invoeren. Je kunt nieuwe transacties toevoegen via een webformulier (het voegt de invoer toe aan je .beancount-bestand). Je kunt ook het bronbestand openen in een externe editor vanuit Fava. Fava ondersteunt ook sneltoetsen voor gevorderde gebruikers. Dit verandert Fava in een lichtgewicht boekhoudsysteem waar je data kunt invoeren en bekijken vanuit dezelfde interface.
• Rapporten en Rekening Drilldown: Fava levert standaard boekhoudrapporten: Winst- en Verliesrekening, Balans, Proefbalans en een holdingslijst voor investeringen. De Balans en Winst- en Verliesrekening zijn interactief – je kunt op een rekening klikken om dieper in de details te duiken, of schakelen tussen weergave tegen kostprijs versus marktwaarde voor activa. Fava toont ook “niet-gerealiseerde winsten” voor investeringen als je prijsgegevens hebt. Het genereert een dagboek-weergave van alle boekingen en laat het dagboek filteren op diverse criteria (handig om specifieke transacties te vinden).
• Documentbeheer: Als je bonnen of afschriften toevoegt, helpt Fava met het organiseren daarvan. Beancount kent een documentenmap, en Fava laat je bestanden slepen en neerzetten op rekeningen of transacties – deze worden opgeslagen en een documentinvoer wordt toegevoegd in je boekhouding. Dit is handig om ondersteunende documenten gekoppeld te houden aan je boekhouddata.
• Aanpassing via Extensies: Fava kan uitgebreid worden met plugins (geschreven in Python) om nieuwe rapporten of functionaliteit toe te voegen. Sommige extensies zijn meegeleverd (bijv. een portefeuillelijst rapport voor investeringen). We zullen later praten over aangepaste extensies, maar de kern is dat Fava het mogelijk maakt nieuwe pagina's en zelfs aangepaste JavaScript in te voegen via de extensie-API. Dit betekent dat als een bepaalde analyse of dashboard niet ingebouwd is, een gevorderde gebruiker dit kan toevoegen.
• Prestaties: Fava is efficiënt – het laadt de data in het geheugen en serveert pagina's snel. De onderliggende Beancount-parser is snel, dus typische persoonlijke boekhoudingen laden binnen een seconde of twee. In de praktijk kan Fava persoonlijke boekhoudingen van vele jaren aan, hoewel extreem grote bestanden (tienduizenden transacties) baat kunnen hebben bij wat optimalisatie (bijv. archiveren van oude invoeren).
• Webtoegang en Mobiliteit: Door Fava op een server of zelfs je laptop te draaien, kun je je financiën vanaf elke browser benaderen. Sommige gebruikers hosten Fava op een privéserver of Raspberry Pi zodat ze hun financiën onderweg kunnen bekijken (mogelijk beveiligd achter een wachtwoord of VPN aangezien Fava geen ingebouwde authenticatie heeft). Dit geeft je in feite een zelf-gehoste “webapp” voor je financiën, zonder je data aan derden te geven.

Samengevat biedt Beancount een robuuste basis voor transparante, op tekst gebaseerde boekhouding met strikte dubbele boekingsregels en ondersteuning voor meerdere valuta's. Fava bouwt hierop 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 uiterst flexibel boekhoud- en analysetoolsysteem dat je volledig zelf beheert.

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

Het bereiken van real-time of bijna real-time analyse met Beancount en Fava houdt in dat je de gegevensstroom naar je grootboek automatiseert en ervoor zorgt dat de tools actuele informatie tonen. Standaard is Beancount een batchproces (je voegt boekingen toe aan het bestand, vervolgens bekijk je rapporten) en Fava detecteert wijzigingen en vereist een vernieuwing. Met de juiste configuratie kun je updates stroomlijnen zodat nieuwe transacties en wijzigingen vrijwel direct verschijnen.

Bestandswijzigingsdetectie: Fava bewaakt het grootboekbestand op wijzigingen. Als je het .beancount-bestand (of bijbehorende bestanden) in een editor bewerkt, toont de pagina een melding “Bestandswijziging gedetecteerd. Klik om te herladen.” Fava pollt zijn get_changed-eindpunt. Wanneer de watcher een wijziging rapporteert, herlaadt Fava het grootboek server-side en biedt de melding één klik om het overzicht te verversen. In de praktijk is deze herlading erg snel (meestal onder een seconde voor standaard grootboeken). Dit betekent dat Fava kan dienen als een live dashboard als je grootboekbestand regelmatig wordt bijgewerkt. Standaard wacht het op jouw klik om je zicht niet te verstoren.

Continue import-/updatepijplijn: Om real-time data 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 stellen een cron-job (of geplande taak) in om periodiek nieuwe transacties van financiële instellingen op te halen (bijvoorbeeld elke nacht of elk uur) en deze aan het grootboek toe te voegen. Zo kunt u bijvoorbeeld een beangulp-importer uitvoeren over de laatste bankdownload (CSV of OFX). Een Beancount-gebruiker bouwde een automatiseringspipeline zodat zijn boeken zichzelf bijwerken: “het zien van mijn boekhouding die zichzelf bijwerkt zonder dat ik eraan hoef te zitten in een open formaat, brengt me pure vreugde”. Dit werd bereikt door verbinding te maken met bank-API's en regelmatige updates in te plannen. Een aangepast Python-script dat gebruikmaakt van bank-API's (bijv. Plaid) kan op een schema draaien en nieuwe boekingen naar het grootboek schrijven. Valideer elke run met bea check voordat het je hoofdbestand raakt. Na elke geplande import, als je Fava hebt draaien, kun je Fava eenvoudig vernieuwen om de nieuwe gegevens te zien.

• Bestandbewaking en triggers: In plaats van tijdgebaseerde schema's kunt u bestandbewakers gebruiken om op gebeurtenissen te reageren. Als uw bank u bijvoorbeeld dagelijks een overzicht per e-mail kan sturen of u een CSV in een map plaatst, kan een script dat bestand detecteren (met inotify op Linux of iets vergelijkbaars) en onmiddellijk de importroutine uitvoeren, waarna het Fava signaleert om te herladen. Hoewel Fava nog geen live reload in de browser ondersteunt, heeft u op zijn minst bijgewerkte data zodat de pagina bij de volgende keer controleren of herladen up-to-date is. Sommige communityprojecten gaan verder: voor ledger (een neef van Beancount) maakte een gebruiker een kleine server die ledger-gegevens real-time toegankelijk maakt voor Grafana, wat aantoont dat een soortgelijke aanpak mogelijk is met Beancount – bouw in feite een daemon die continu data voedt aan uw dashboards.

• Directe API-integratie: In plaats van via bestanden kunnen geavanceerde gebruikers direct verbinding maken met bank-API's (zoals Plaid of regionale Open Banking API's) om vaak transacties op te halen. Een gedreven persoon kan "live" imports in een lus scripten (met passende snelheidsbeperking) – effectief elke paar minuten de bank pollend op nieuwe gegevens. Er staat niets u in de weg om “u aan te melden bij de Plaid API en dezelfde [automatisering] lokaal te doen”. Elke nieuwe transactie kan toegevoegd worden aan het Beancount-bestand zodra deze binnenkomt. Met deze aanpak wordt Fava echt een realtime dashboard voor uw rekeningen, concurrerend met de up-to-date feed in commerciële apps.

Gegevens vernieuwen in Fava: Zodra je gegevens worden bijgewerkt, is het tonen van deze updates in Fava eenvoudig: een browser refresh (F5) of het klikken op de vernieuwingsmelding laadt de meest recente grootboekstatus. Let op: fava --debug duwt geen grootboekwijzigingen naar de browser. De helptekst luidt “Turn on debugging”. Het start de Werkzeug debugger en code herlader voor Fava’s eigen code en zet Jinja template auto-reload aan. Dit herlaadt servercode en paginatemplates tijdens extensieontwikkeling. Het is niet gerelateerd aan de bestandsmonitor die grootboekwijzigingen detecteert. Als alternatief, als je een aangepaste front-end bouwt, zou je die Fava’s get_changed endpoint kunnen laten poll-en en verversen wanneer die nieuwe data meldt.

Onmiddellijke berekeningen: Beancount’s snelle parsing betekent dat zelfs als je je grootboekbestand om de paar minuten bijwerkt, de omzetting van data ophalen → bestand bijwerken → Fava herladen snel gaat. Bijvoorbeeld, een gebruiker merkt op dat het herladen van Fava na het bewerken van het bestand “bijna niet merkbaar is… zeker minder dan een seconde” voor redelijk grote grootboeken. Zo kun je een Fava-venster openhouden en periodiek verversen om een live dashboard na te bootsen. (Voor een echt live ervaring kan men een klein script bouwen dat de browser automatisch ververst of de browse-reload elke N seconden functie gebruiken.)

Reconciliatie en meldingen: Om real-time data te vertrouwen, wil je ook saldi regelmatig reconciliëren. Beancount maakt dit eenvoudig met saldo-asserties en een “up-to-date” indicator. In feite kleurt Fava accounts groen, geel of rood wanneer de open directive fava-uptodate-indication metadata bevat. De kleur geeft aan of recente saldo-controles de nieuwste boekingen van het account dekken. Dit kan snel laten zien of het saldo van een account in het grootboek overeenkomt met het meest recente bankafschrift. In een bijna real-time setup kun je dagelijkse saldo-controles automatiseren (zodat het grootboek elke ochtend het sluitingsaldo van gisteren van de bank per account bevat). De indicator van Fava zou dan aangeven als je auto-import iets gemist heeft of als er een discrepantie is, wat vertrouwen geeft dat de “live” data die je ziet correct is.

Automatiseringsvoorbeeld: Stel dat u dagelijkse kasstroomupdates wilt. U zou een cronjob kunnen instellen die elke nacht om 3 uur ’s nachts draait: deze voert een Python-script uit dat de API van uw bank gebruikt om de transacties van de afgelopen dag op te halen, schrijft ze in import_today.beancount, en voegt dat bestand vervolgens toe aan uw hoofdboek. Het schrijft ook een balansassertie voor aan het eind van de dag. Wanneer u wakker wordt, opent u Fava – het toont alle transacties tot gisteren, en u ziet de inkomsten/uitgaven van de huidige maand bijgewerkt. Als u gedurende de dag een uitgave doet, kunt u deze handmatig toevoegen (bijvoorbeeld via Fava's formulier voor nieuwe transacties op uw telefoon), of wachten op de nachtelijke import. Deze hybride aanpak (voornamelijk geautomatiseerd, met de mogelijkheid om handmatig incidenteel toe te voegen) geeft een bijna real-time beeld. Een andere aanpak is om Fava's Journaal-pagina open te laten staan en deze als register te gebruiken: terwijl u uitgeeft, registreert u de transactie snel (zoals het bijhouden van een kasboek) – dan bent u de real-time feed. Dit is handmatiger, maar sommige gebruikers waarderen het bewustzijn dat het geeft. Voor echt streaming updates zonder handmatige stappen, moet u investeren in scripting en mogelijk gebruikmaken van API's van derden zoals besproken.

Samengevat, door de importautomatisering van Beancount te combineren met de snelle verversing van Fava, kunt u vrijwel real-time financiële data krijgen. Het is misschien niet “push-button easy” om hetzelfde niveau van live feeds te bereiken als een dienst zoals QuickBooks (die automatisch bankfeeds binnenhaalt), maar het is mogelijk – en belangrijker nog, u behoudt volledige controle en transparantie over het proces. Zoals een pleitbezorger van plaintext-accounting opmerkte, kan een beetje inspanning vooraf leiden tot een geautomatiseerd systeem dat “veel beter is dan commerciële oplossingen, en veel flexibeler en uitbreidbaar” is. In de volgende sectie zullen we zien hoe de visualisatiemogelijkheden van Fava u onmiddellijk in staat stellen om deze up-to-date data te begrijpen, waarbij ruwe transacties worden omgezet in inzichten.

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

(GitHub - beancount/fava: Fava - webinterface voor Beancount) Fava’s Inkomsten- en Uitgavenrapport (in de web-UI) ondersteunt geavanceerde visualisaties zoals treemaps (afgebeeld) en sunburst-grafieken voor snel inzicht in de samenstelling van inkomsten en uitgaven. In deze treemap vertegenwoordigt elk rechthoek een uitgavencategorie, genummerd naar zijn bedrag – je ziet meteen dat Huur (grote groene vlakte) de uitgaven domineert. De bovenste filterbalk en bedieningselementen (rechtsboven) maken het mogelijk om de valuta, het grafiektype en de periode aan te passen (bijv. maandelijkse data bekijken). Fava biedt ook lijngrafieken (bijv. netto waarde over tijd) en staafgrafieken (bijv. inkomsten versus uitgaven per maand) om trends in je financiële data te herkennen.

Een van Fava’s grootste krachten is het direct omzetten van de grootboekdata naar visuele, interactieve rapporten. Zodra het grootboek geladen is, genereert Fava grafieken die het gemakkelijk maken om kasstromen en trends in één oogopslag te begrijpen:

• Inkomsten- en Uitgaven Treemap/Sunburst: Op de pagina Inkomsten- en Uitgavenstaat kan Fava jouw inkomsten en uitgaven tonen als een treemap of sunburst-diagram. Deze zijn ideaal voor visuele weergave van kasstromen „in één oogopslag“. Bijvoorbeeld, als je maandelijkse uitgaven als treemap getoond worden, komt de oppervlakte van elke rechthoek overeen met de omvang van elke uitgavencategorie. Grote vlakken tonen direct waar het grootste deel van je geld naartoe ging (bijv. huur of hypotheek, belastingen, enzovoort), terwijl kleinere vlakken kleine uitgaven weergeven. Dit is bijzonder handig om trends te herkennen in bestedingen – als het blok „Uit eten“ elke maand groeit, zie je dat visueel. Je kunt schakelen naar een sunburst-grafiek om hiërarchische uitsplitsingen te zien (bijv. de buitenste ring toont subcategorieën zoals Boodschappen versus Restaurants binnen de categorie Voeding). Deze grafieken worden bijgewerkt voor welke periode je ook gefilterd hebt (één maand, jaar-tot-nu, enzovoort), en geven je directe kasstroomvisualisatie voor die periode. Een gebruiker op het plaintext accounting-forum merkte op: „Ik maak veel gebruik van de inkomsten- en uitgaven-treemaps. Ze geven een uitstekend visueel gevoel van onze financiële bewegingen.“ – die onmiddellijke duidelijkheid is precies waar Fava’s grafieken voor bedoeld zijn.

• Vermogen en Balans in de Tijd: Fava biedt een lijngrafiek voor het vermogen over de tijd (op de pagina “Balans” of “Statistieken”). Deze grafiek toont de som van je activa minus passiva op elk moment (per dag, week of maand). Het is onmisbaar om trends te ontdekken – je kunt de koers van je financiën zien (bijv. geleidelijk omhoog, of dips op bepaalde momenten). Als je investeringen hebt, kun je schakelen tussen weergave van waarde tegen kostprijs versus marktwaarde (als prijsgegevens zijn geregistreerd) – bijvoorbeeld, je ziet je vermogen op marktwaarde schommelen met aandelenkoersen, terwijl het tegen kostprijs vloeiender is. Fava kan ook rekeningbalansen over tijd tonen. Klik je op een rekening (bijv. Activa:Bank:Betalen), dan toont de rekeningpagina een grafiek van de balansgeschiedenis van die rekening. Je kunt direct zien hoe je kaspositie beweegt – wat feitelijk een kasstroomgrafiek is (de helling van de balanslijn geeft de netto kasstroom aan). Als deze naar beneden gaat, weet je dat je meer uitgeeft dan verdient in die periode. Door deze trends te bekijken, kun je patronen ontdekken zoals “elke december daalt mijn spaargeld (vakantie-uitgaven)” of “mijn investeringen groeiden sterk dit kwartaal”.

• Staafdiagrammen voor Periodieke Vergelijking: In de resultatenrekeningweergave heeft Fava tabbladen voor “Maandelijkse Winst”, “Maandelijks Inkomen”, “Maandelijkse Uitgaven” enzovoort. Door deze te selecteren worden staafdiagrammen per maand getoond. Bijvoorbeeld, Maandelijkse Nettowinst toont het maandelijkse overschot/tekort als een staaf, waardoor het gemakkelijk is prestaties tussen maanden te vergelijken. Je kunt snel uitschieters herkennen (bijv. een grote negatieve staaf in april betekent dat die maand een uitzonderlijk verlies/uitgave had). Evenzo stapelt of groepeert de staafdiagram “Maandelijkse Uitgaven” uitgaven per categorie per maand, zodat je kunt zien welke categorieën variëren. Dit is ideaal om trends over de tijd te ontdekken – bijv. dat je “Reiskosten” elke zomer pieken, of dat “Nutsvoorzieningen” hoger zijn in de winter. Fava geeft je hiermee in feite enkele functies van een budgetteringsapp (het volgen van trends) maar met volledige aanpasbaarheid (omdat je zelf de categorieën definieert en hoe ze worden samengevoegd).

• Realtime filteren en data-inspectie: De visualisaties in Fava zijn niet statisch; ze werken samen met de filtering van Fava. Stel dat je een specifiek scenario wilt onderzoeken: “Hoe zien mijn kwartaal-cashflows eruit voor alleen mijn zakelijke rekeningen?” Je kunt het tijdfilter instellen op Q1 2025 en de rekeningen filteren op je zakelijke hiërarchie – Fava zal de grafieken direct bijwerken om het netto-inkomen, de treemap van uitgaven, enz. te tonen, maar alleen voor die subset. Deze interactieve segmentatie betekent dat je heel snel ad-hoc analyses kunt uitvoeren, zonder queries te schrijven. De Journal-weergave ondersteunt ook live filtering: je kunt zoeken op begunstigde of substring in de omschrijving en direct een gefilterde lijst van transacties zien. Als je naar realtime data kijkt (bijvoorbeeld als 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 nog openstaande posten markeert) om te zien wat nog niet verwerkt is. Deze realtime inspectiemogelijkheid helpt ook de datakwaliteit te waarborgen — omdat je anomalieën direct kunt isoleren en oplossen.

• Kasstroomoverzicht (indirect): Hoewel Beancount/Fava niet standaard een formeel kasstroomoverzicht (onderverdeeld in operationeel/investerend/financierend) produceert, kun je dit nabootsen met aangepaste queries of door rekeningstructuren. Zo kun je bepaalde transacties taggen of specifieke rekeningen gebruiken voor investeringen en financiering en dan totalen opvragen. De query-interface van Fava voert BQL uit zoals SELECT sum(position) WHERE account ~ 'Assets:Bank:Checking'. Dit geeft het banksaldo achter de grafieken terug. Het uitgewerkte voorbeeld hieronder laat de volledige cyclus zien. Dat gezegd hebbende vinden de meeste particuliere gebruikers de combinatie van trends in saldo en inkomsten-/uitgavengrafieken voldoende om cashflows te begrijpen.

• Holdings en Portfolio Visualisatie: Op de Holdings pagina toont Fava uw huidige holdings van grondstoffen (bijv. aandelen, obligaties, crypto) met hoeveelheden, kosten, marktwaarde en niet-gerealiseerde winsten. Hoewel dit een tabel is, geen grafiek, is het zeer nuttig voor real-time inspectie van de status van uw portfolio. Sommige community-extensies (zoals fava-investor, later besproken) voegen meer visuals toe voor portefeuilles, zoals allocatie-taartdiagrammen of prestatiegrafieken. Zelfs zonder extensies kunt u bijvoorbeeld zien hoe de waarde van uw aandelenportfolio verandert volgens de laatste prijzen – als u koersinformatie regelmatig bijwerkt (wat dagelijks geautomatiseerd kan worden), zullen Fava’s grafieken de marktwaarde van uw investeringen tot op de minuut nauwkeurig weergeven.

Uitgewerkt voorbeeld: twee maanden uitgaven​

Dit voorbeeld loopt van begin tot eind op Beancount 3.2.3 met beanquery 0.2.0. Sla het grootboek op als example.beancount. Het bevat twee salarisuitkeringen 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 dan de query uit voor uitgaven per categorie.

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 eindigt met exitcode 0 van bea check; fouten worden vermeld met een niet-nul exitcode. De query geeft één regel terug per uitgaverekening.

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

Twee extra queries maken het plaatje compleet. Totale inkomsten en totale uitgaven:

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

Ze geven (-6000.00 USD) en (1350.00 USD) terug. Dus het huishouden verdiende 6.000,00 USD, gaf 1.350,00 USD uit en bespaarde 77,5%. Het saldo van de betaalrekening bevestigt dit:

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

Het geeft (4650.00 USD) terug. Dezelfde queries kunnen ongewijzigd worden uitgevoerd op Fava’s Query-pagina. Fava 1.30.16 toont dezelfde drie uitgavenregels als een interactieve tabel.

In de praktijk werken Fava’s visuele rapporten even snel bij als de onderliggende data. Zodra een nieuwe transactie wordt toegevoegd en de pagina wordt vernieuwd, worden de grafieken opnieuw berekend. Er is geen langdurige herverwerking nodig. Dit betekent dat als u een semi-geautomatiseerde pijplijn heeft die de hele dag door data invoert, u Fava open kunt houden en periodiek op vernieuwen kunt klikken om bijgewerkte grafieken te krijgen – effectief real-time financiële monitoring.

Stel je bijvoorbeeld voor dat je een klein bedrijf runt en je wilt de contante middelen en dagelijkse uitgaven in de gaten houden. Je zou Fava kunnen openen met een aangepast dashboard (mogelijk via een extensie of het queryscherm) dat "Cash account balance today" en "Expenses – Today vs. Yesterday" toont. Elke keer dat je vernieuwt nadat er nieuwe gegevens zijn binnengekomen, zie je die cijfers bijwerken. Dit komt overeen met wat dure realtime dashboards bieden, maar dan met open-source tools. Het verschil is dat je mogelijk handmatig moet vernieuwen of vernieuwingen moet inplannen, terwijl die tools updates automatisch pushen. Maar functioneel gezien krijg je dezelfde inzichten, met het extra voordeel dat je in Fava op elk getal kunt doorklikken (klik erop om onderliggende transacties te zien) – iets wat veel BI-dashboards missen.

Samengevat zet Fava je boekhoudgegevens om in directe visuele inzichten: uitgebreide kasstroomanalyses, trendlijnen, tijdsvergelijkingen en interactieve filtering helpen je het verhaal achter de cijfers te zien. Of je nu de uitgaven van vorige week op afwijkingen inspecteert of meerjarige trends in het vermogen bekijkt, Fava’s grafieken en rapporten bieden helderheid in realtime (zodra je gegevens beschikbaar 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 misschien de data van Beancount integreren met andere business intelligence (BI) of dashboardtools zoals Grafana, Metabase, of aangepaste web-frontends (bijv. een React-app). De reden kan zijn om financiële data te combineren met andere databronnen, geavanceerde grafiekmogelijkheden te gebruiken, of dashboards in een ander formaat te delen met anderen. Dankzij de openheid van Beancount zijn er meerdere manieren om integratie te realiseren:

• Database-integratie (BeanSQL / Beanpost): Een eenvoudige benadering is om je Beancount-boekhouding te exporteren of te synchroniseren naar een SQL-database. Zodra de gegevens in SQL staan, kan elk BI-tool de data opvragen. Leden van de community hebben daar zelfs tools voor gemaakt. Zo is Beanpost een experiment dat een Beancount-boekhouding spiegelend overzet naar een PostgreSQL-database, waarbij een groot deel van de Beancount-logica als SQL-functies wordt geïmplementeerd. Dit biedt “een flexibele backend die kan integreren met andere tools zoals webapps of rapportagesystemen.” Je kunt Beanpost draaien om je tekstboekhouding continu te synchroniseren met Postgres. Vervolgens kan een tool als Metabase of Tableau verbinding maken met die Postgres-database en kun je elk gewenst diagram of dashboard bouwen (live bijgewerkt zodra de database update). Een gebruiker meldde dat hij Postgres + PostGraphile gebruikte om automatisch een GraphQL API voor de boekhouddata beschikbaar te maken en daarna een aangepaste React frontend daarop bouwde – waarbij de boekhouding in wezen als een webservice wordt behandeld. Deze aanpak lost situaties op waarbij de interface van Fava mogelijk niet toereikend is (bijvoorbeeld multi-user toegang, of meer mobielvriendelijke gebruikersinterfaces). Het vereist meer engineering, maar toont de mogelijkheden: je kunt Beancount relatief eenvoudig integreren met moderne web stacks. Een lichtere variant is het exporteren van query-resultaten naar SQLite – het uitvoeren van bea --file ledger.beancount query "SELECT ..." print een tabel die je kunt plakken of doorgeven, en het exporteren van spreadsheet CSV vanuit de CLI wacht op native exportopties voor bea query. Sommige mensen gebruiken SQLite als tussenstap om aan te sluiten op tools zoals Metabase (die SQLite-bestanden via een verbinding kan lezen).

• Grafana (Time-Series Dashboards): Grafana is populair voor monitoring en tijdreeksgegevens. Financiële data over tijd (uitgaven, saldi) kunnen worden behandeld als tijdreeksen. Er is binnen de community gediscussieerd over het koppelen van Beancount aan Grafana. Eén idee was een Grafana Data Source Plugin die BQL-queries on-the-fly kan uitvoeren op een Beancount-bestand. Dit zou Grafana-panelen in staat stellen om direct bijvoorbeeld “Saldo van betaalrekening” als een meter of “Uitgaven over de laatste 30 dagen” als een grafiek te tonen, door het grootboek te query'en. Tot nu toe (2025) is er geen toegewijde plugin gepubliceerd, maar enthousiastelingen hebben ad-hoc oplossingen gebouwd. Zo maakte een Reddit-gebruiker aquilax een eenvoudige server die Ledger CLI-gegevens beschikbaar stelt aan Grafana, en deze gedeeld 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 de Beancount API om gegevens op te vragen) en endpoints aanbiedt die JSON-databestanden teruggeven voor Grafana. Grafana heeft een generieke JSON data source plugin die dan deze API kan aanspreken. In de praktijk betekent dit dat je een Grafana-dashboard kunt ontwerpen met panelen als “Maandelijkse omzet (staafdiagram)” of “Dagelijks kassaldo (lijndiagram)”, waarbij die panelen data ophalen via jouw Beancount-gedreven API. Grafana biedt rijke visualisatiemogelijkheden (annotaties, drempels, combineren met servermetrics, enzovoorts). Andreas Gerstmayr (een van de beheerders van Fava) stelde precies deze aanpak voor en noemde zelfs dat hij een Fava extensie ontwikkelde genaamd fava-dashboards (meer daarover hieronder) om grafieken te renderen vanuit BQL-queries, als alternatief voor een volledige Grafana-installatie. Als je de UI van Grafana prefereert, is integratie haalbaar – het vereist alleen het bouwen van de databrug.

• Metabase (Ad-hoc Queries and 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 met transacties, boekingen, enz. uit te schrijven), kun je Metabase op die database richten. Je kunt aangepaste tabellen maken zoals expenses (date, category, amount) uit je grootboek en vervolgens in Metabase gemakkelijk grafieken genereren (bijv. een taartdiagram van uitgaven per categorie van afgelopen maand). Het voordeel is dat niet-technische gebruikers (of collega’s) dan via de GUI van Metabase met de data kunnen werken zonder het Beancount-bestand aan te raken. Het nadeel is dat je de export/synchronisatie moet onderhouden. Sommige gebruikers hebben een geautomatiseerde nachtelijke conversie van het Beancount-grootboek naar SQLite ingesteld, waarna Metabase SQLite kan uitlezen; anderen gebruiken de genoemde Postgres-aanpak. Het belangrijkste is dat de datadraagbaarheid van Beancount dit mogelijk maakt – je bent vrij om de data te dupliceren in elke vorm die je externe tool nodig heeft.

• Aangepaste Frontends / 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., zodat een Python webframework (Flask, Django, FastAPI) kan worden gebruikt om een op maat gemaakte app te bouwen. Bijvoorbeeld, een kleinbedrijf kan een dashboard maken dat KPI-metrieken (zoals brutomarge, dagelijkse verkopen, enz.) toont door het grootboek te bevragen en mogelijk te combineren met niet-grootboekgegevens (zoals het aantal bediende klanten). Een lid van de community bouwde een mobielvriendelijke webinterface omdat Fava niet intuïtief was voor hun partner – ze maakten gebruik van het grootboek in een database om deze aangepaste UI aan te sturen. Als je JavaScript/TypeScript prefereert, kun je een tool gebruiken om het grootboek naar JSON te converteren en van daaruit verder bouwen. Fava zelf biedt zijn Query-pagina via een JSON query-API, zodat een aangepast frontend BQL kan verzenden en de teruggegeven tabellen kan renderen in plaats van een nieuwe query-backend te bouwen.

• Excel/PowerBI Integratie: Het is het vermelden waard dat je zelfs kunt integreren met Excel of PowerBI. Totdat bea query een native CSV-export krijgt, gebruik je Fava’s Query-pagina-export voor spreadsheetbestanden die Excel direct opent. Een workflow kan zijn: een nachtklus genereert een CSV-bestand van belangrijke financiële gegevens uit Beancount, en PowerBI is ingesteld om dat bestand te importeren. Dit is wat indirect, maar voor organisaties die al veel gebruikmaken van Excel/PowerBI, is het een integratie met weinig wrijving. PowerBI ondersteunt ook Python-databronnen, dus men kan een kort Python-script schrijven dat BQL-query's uitvoert en dit als een databron binnen PowerBI gebruiken, waarmee een directe verbinding wordt bereikt.

Case Study – Grafana Integratie Idee: Josh, een Beancount-gebruiker, vroeg op de mailinglijst naar het doorsturen van Beancount-metrics naar Prometheus en het bekijken in Grafana. De kernontwikkelaars reageerden dat in plaats van data te dupliceren in Prometheus, een betere aanpak is een Grafana-plugin of dienst die rechtstreeks de Beancount-boeking raadpleegt. Andreas deelde zijn fava-dashboards extensie die custom grafieken binnen Fava zelf renderde als voorbeeldoplossing. De conclusie is: je hebt opties – ofwel integreren via bestaande BI-infrastructuur (Prometheus+Grafana of SQL+Metabase) of Fava uitbreiden om aan je wensen te voldoen (de volgende sectie zal daar dieper op ingaan).

Beveiligings- en Meerdere-Gebruikers Overwegingen: Als je integreert in externe tools, wees dan alert op de gevoeligheid van data. Beancount’s platte tekst bevat vaak privé financiële informatie, dus elke server die dit blootstelt moet beveiligd zijn (geauthenticeerd). Als je data verplaatst naar een cloud-BI-tool, kun je wat privacy verliezen. Zelf-gehoste tools (Grafana/Metabase open source versies) kunnen lokaal draaien om dat te beperken. Ook, als meerdere personen dashboards moeten bekijken, kan een externe read-only dashboard beter zijn dan iedereen toegang geven tot Fava (waar ze per ongeluk data zouden kunnen wijzigen). Bijvoorbeeld, een startup kan Beancount intern gebruiken maar Metabase inzetten zodat afdelingshoofden uitgaven versus budget kunnen inzien zonder in de boekingen te hoeven werken.

Samengevat, Beancount en Fava werken goed samen met andere tools. Je kunt het hele ecosysteem van data-tools benutten met een beetje verbindingscode: stuur boekhouddata naar een SQL-database voor BI-tools, bied het aan via API's voor webapps, of gebruik gespecialiseerde bibliotheken om het naar tijdreeksystemen te streamen. Deze flexibiliteit betekent dat je nooit vastzit als de ingebouwde visuals van Fava een specifieke behoefte niet vervullen – je kunt altijd integreren met een ander platform terwijl je Beancount blijft gebruiken als je bron van waarheid. Vervolgens bekijken we hoe je Fava zelf kunt uitbreiden met plugins en aangepaste dashboards, wat vaak een eenvoudigere route is dan externe integratie als je slechts 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 functionaliteiten 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 wegen voor aanpassing: (1) Gebruik of schrijf Fava Extensions, en (2) Stel aangepaste dashboards in via community-plugins zoals fava-dashboards.

Fava Extensions (Aangepaste Plugins)​

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

Om een extensie te activeren, gebruik je de Beancount custom directive in je grootboekbestand:

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

Dit vertelt Fava om de opgegeven 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 parsed dit als een Python-literal, dus "{'option': 'value'}" komt binnen als een dict.

Voorbeeld – Auto-Commit Extensie: De meegeleverde fava.ext.auto_commit commit veranderingen naar git wanneer je het bestand via Fava bewerkt. Wil je het gebruiken, voeg dan toe:

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 draait een git commit in de eigen directory van het grootboekbestand. Dus het grootboek moet al in een git-checkout staan. Het toont hoe extensies inhaken op Fava’s edit-events.

Voorbeeld – Portfoliolijstextensie: De meegeleverde fava.ext.portfolio_list voegt een pagina toe die uw beleggingsrekeningen op een rijtje zet. Het stelt report_title = "Portfolio List" in en levert een template mee. Fava detecteert dit en voegt een nieuwe zijbalkvermelding “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, voegt u toe:

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

(Geen configuratie nodig in dit geval.)

Een Aangepaste Extensie Schrijven: Stel dat u een aangepaste rapportpagina wilt, bijvoorbeeld “Aging van debiteuren” voor facturen. U 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())
        ]

U maakt ook een templates/ReceivablesReport.html naast de module om de HTML voor de pagina te definiëren. In die template kunt u attributen zoals self.overdue lezen die uw hook heeft voorbereid. Zodra deze extensie is geschreven, voegt u aan uw grootboek toe:

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

(ervan uitgaande dat receivables.py in de Beancount-bestandsmap of PYTHONPATH staat, kan Fava het op naam vinden). Bij het starten van Fava ziet u nu een “Receivables Aging” pagina.

Onder de motorkap roept Fava de methoden van uw 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 die gedecoreerd is met @extension_endpoint wordt bovendien een JSON API-eindpunt binnen de extensie. Meestal zijn de meegeleverde hooks plus een template voldoende.

De Fava-documentatie geeft aan dat het extensiesysteem nog in ontwikkeling is, maar het is bruikbaar. Veel geavanceerde functies zijn zelfs al als extensies uitgeprobeerd.

Aangepaste Dashboards met fava-dashboards (Community Extensie)​

In plaats van een extensie helemaal zelf te schrijven, kunt u de third-party fava-dashboards plugin gebruiken die door een Fava-maintainer is gemaakt. Deze extensie laat u willekeurige dashboards definiëren via een YAML configuratiebestand, waarin tekst, tabellen en grafieken worden gemengd, aangedreven door BQL-query’s. Het is in feite een manier om nieuwe “pagina’s” in Fava te maken die meerdere aangepaste panelen bevatten.

Installatie en Setup: Eerst installeert u het pakket (bijv. pip install fava-dashboards). Versie 2.0.2 werkt probleemloos naast Fava 1.30.16. Daarna activeert u het in uw Beancount-bestand met een aangepaste directief die wijst naar uw dashboards-configuratie. 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 om de fava_dashboards-module te laden en je YAML-bestand te lezen voor configuratie.

Dashboards YAML-formaat: In de dashboards.yaml definieer je een of meer dashboards en hun panelen. Twee regels komen uit de pijplijn van de extensie zelf. Aggregatiekolommen hebben een AS alias nodig. En de BQL-tekenconventie is van toepassing: inkomensbedragen zijn negatief, 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 opgetelde positie direct. In het voorbeeld-boekhoudstelsel wordt (-4650.00 USD) weergegeven. Dat is 6.000,00 USD aan inkomen netto van 1.350,00 USD aan uitgaven. Het tweede paneel doorloopt de queryrijen in een tabel. Het project genereert ook grafiekpanelen vanuit dezelfde queries. Zie de gelinkte README voor de grafiekscript-API.

De extensie verzorgt de weergave hiervan wanneer je de dashboardpagina in Fava opent. Je kunt meerdere dashboards maken (elk verschijnt als tabblad of aparte pagina). Dit is uiterst krachtig voor het maken van aangepaste financiële dashboards. Bijvoorbeeld, je kunt een “Budget versus Realisatie” dashboard maken: het ene paneel toont een tabel van budget versus realisatie per categorie (via een query die twee rekeningsets vergelijkt), een ander paneel toont een staafdiagram van uitgaven tot nu toe versus vorig jaar, enzovoort. Dit alles met alleen configuratie en minimale scripting, gebruikmakend van je boekhoudgegevens via BQL.

Codevoorbeeld – fava-dashboards inschakelen: Zoals hierboven getoond is het toevoegen van de extensie één regel in je grootboek. Voor de volledigheid, hier is 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>"

In het voorbeeld-boekhoudstelsel levert dit <div>Net Worth: (4650.00 USD)</div> op. Een echt dashboard zou er netjes uitzien en meer panelen toevoegen.

Met dit op zijn plaats, wanneer je Fava draait en naar het “Overzicht” dashboard gaat, wordt je berekende netto waarde weergegeven. Je kunt dan de template verfijnen of grafieken toevoegen waar nodig.

Andere noemenswaardige extensies: Afgezien van fava-dashboards hebben communityleden plugins gebouwd zoals fava-investor voor beleggingsanalyse en fava-review voor transactiecontrole. Dit zijn pakketten van derden met hun eigen installatiestappen en compatibiliteitsbereiken met Fava. Bekijk hun README-bestanden voor installatie. De community onderhoudt een "awesome-beancount" lijst van plugins en tools. Door deze te bekijken, kun je mogelijk een kant-en-klare extensie vinden die aan je behoeften voldoet.

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

Voorbeeld – Een aangepaste KPI in Fava: Stel je wilt de "Besparingsratio" (percentage van het inkomen dat wordt bespaard) bijhouden. Dit kan met een extensie die het berekent en een klein vakje op de hoofdpagina toont. Of met fava-dashboards kan een paneel een Jinja2 zijn die Savings Rate: X% uitvoert door totaal inkomen en totale uitgaven op te vragen. Dit soort aangepaste maatstaven is zeer eenvoudig te implementeren met deze tools, terwijl het in een gesloten systeem zoals QuickBooks misschien onmogelijk is om een nieuwe maatstaf op het dashboard te creëren.

Dezelfde twee queries voeden een besparingsratio-paneel. Let op de tekens: BQL sum(position) retourneert inkomen als een negatieve positie en uitgaven als positief, en Jinja kan niet de ene positie van de andere aftrekken. Dus toon beide zijden en vermeld de ratio in de sjabloontekst:

- 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 renderen we Savings Rate: 77.5% ((-6000.00 USD) earned, (1350.00 USD) spent). De ratio is (6.000,00 − 1.350,00) / 6.000,00. Bereken dit uit de groottes. Negatief maken of posities aftrekken binnen de sjabloon niet doen.

Het belangrijkste punt: Fava is geen statisch hulpmiddel – het is een uitbreidbaar platform. Met wat 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 aanstaande rekeningen, PDF-facturen genereren uit transacties, of Beancount te integreren met belastingberekeningsbibliotheken. Wanneer je inleert of deze extensies gebruikt, krijg je een zeer op maat gemaakt financieel analysetool zonder helemaal opnieuw te hoeven beginnen.

Gebruikssituaties: Persoonlijke financiën versus klein zakelijk boekhouden​

Beancount en Fava kunnen worden gebruikt voor zowel persoonlijke als kleinzakelijke boekhouding, maar de gebruikssituaties en voordelen verschillen enigszins in klemtoon:

Persoonlijke financiën​

Voor particulieren schitteren Beancount+Fava in het bieden van volledige transparantie en inzicht in de eigen financiën zonder te vertrouwen op propriëtaire apps. Veelvoorkomende toepassingen voor persoonlijke financiën zijn:

• Uitgaven bijhouden en budgetteren: Veel mensen 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, “analyse van financiële data (uitgaven, donaties, belastingen, enz.) triviaal is. Het is makkelijk te doen met Fava, maar ook eenvoudig met scripts... Ik heb een Python-script dat data uit Beancount haalt met behulp van BQL, daarna gebruik ik pandas om een rapport voor te bereiden.”. Dit toont aan hoe particuliere gebruikers profiteren van zowel de ingebouwde interface als de mogelijkheid om aangepaste analyses te automatiseren wanneer dat nodig is.

• Vermogen en doeltracking: Omdat je alle activa (bankrekeningen, investeringen, zelfs fysieke bezittingen als je dat wilt) in één grootboek kunt opnemen, krijg je een enkelvoudig overzicht van je netto waarde. Liefhebbers van persoonlijke financiën gebruiken dit om de voortgang richting doelen bij te houden (bijvoorbeeld het “FI-nummer” of het aflossen van schulden). De grafieken van Fava die het netto vermogen in de tijd tonen zijn motiverend – je kunt letterlijk de groeicurve van je vermogen zien. Het is gebruikelijk om verplichtingen zoals studieleningen of hypotheken in Beancount te volgen en hun saldi bij te werken; het grootboek geeft dan een compleet beeld van de financiële gezondheid.

• Investeringen en Crypto: Persoonlijk gebruik strekt zich vaak uit tot het bijhouden van een portfolio. Beancount kan aandelen, crypto, enz., beheren met kostprijs en gerealiseerde winstberekeningen (via plugins of queries). Het voordeel ten opzichte van de website van een broker is dat je kunt consolideren over alle accounts en de werkelijke assetallocatie kunt zien. Community-plugins zoals fava-investor voegen bijvoorbeeld investeringsanalysepagina's toe aan Fava. Dit is iets wat hobby-investeerders meestal in Excel doen; Beancount biedt een meer rigoureuze, geautomatiseerde manier. Een blogpost getiteld “Beancount: DeFi Accounting For Noobs” illustreert zelfs hoe het gebruikt kan worden om cryptocurrency-transacties en yield farming bij te houden, wat de flexibiliteit in moderne persoonlijke financiële scenario's laat zien.

• Meerdere valuta's in persoonlijke financiën: Als je in het buitenland woont of buitenlandse investeringen hebt, is Beancount zeer nuttig omdat het valuta kan converteren en aggregeren. Gebruikers merken op dat “veel boekhoudsoftware niet goed is met meerdere valuta's… Met Beancount kun je elke gewenste valuta definiëren”, en rapporten krijgen in je voorkeursvaluta. Voor een particuliere gebruiker die bijvoorbeeld een salaris in USD ontvangt maar uitgaven in EUR heeft, is dit een groot voordeel.

• Levensregistratie en Dagboekvoering: Een onconventioneel maar echt gebruiksscenario: sommigen gebruiken het grootboek als een levenslogboek, waarbij transacties worden gelabeld met levensgebeurtenissen (zoals #wedding of #vacation2025) en het vervolgens gebruiken om kosten van gebeurtenissen te berekenen of zelfs als een 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 voor Beancount omdat ze “deze gegevens wilden bezitten en gemakkelijk analyseren, en niet vast wilden zitten aan een abonnement of leverancier”. De recente ondergang van Mint.com (een populaire gratis budgetteringstool) heeft enthousiastelingen naar platte-tekst boekhouding gedreven voor duurzaamheid. Met Beancount weten ze dat ze hun grootboek over 20 jaar nog kunnen openen. Voor de financiën van een individu bieden Beancount’s gegevens (mogelijk gesynchroniseerd via Dropbox of Git) en Fava's webinterface (die lokaal of op een private server kan draaien) een balans tussen gemak en controle die elders moeilijk te vinden is.

Potentiële uitdagingen voor persoonlijk gebruik: de initiële installatie en het leren van double-entry kan voor sommigen een drempel zijn. Maar veel bronnen (zoals de Beancount tutorial en communityforums) helpen nieuwe gebruikers. Eenmaal ingesteld kan het onderhoud grotendeels worden geautomatiseerd zoals beschreven, wat ideaal is voor iemand die de huishoudfinanciën met minimale inspanning beheert.

Kleine Ondernemingsboekhouding​

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

• Boekhouding en financiële overzichten: Een bedrijf kan zijn grootboek bijhouden in Beancount, waarbij facturen, rekeningen, loonadministratie, enz. worden geregistreerd, en balans- en winst- en verliesrekeningen worden opgesteld. Beancount ondersteunt de benodigde accrual accounting (je kunt rekeningen markeren als Debiteuren/Crediteuren en facturen registreren met boekingen naar inkomsten en debiteuren, en later een betaling om de debiteuren te vereffenen). Fava zal deze dan correct onder Activa of Passiva tonen. In een Reddit-discussie werd gevraagd of Beancount geschikt is voor bedrijven en of het juiste financiële overzichten kan genereren – ja, het kan balansen, resultatenrekeningen en (met wat query-ondersteuning) kasstroomoverzichten produceren, aangezien dit slechts weergaven zijn van de dubbele boekhouding. Het punt is dat Beancount geen specifieke boekhoudstandaarden afdwingt (dat hangt af van hoe je het gebruikt). Dus een ervaren gebruiker (of accountant) moet het rekeningschema correct opzetten voor het bedrijf. Er zijn voorbeelden uit de community waarbij Beancount wordt gebruikt voor startups – een HN-commentator zei: “I really enjoy using Beancount + Git for managing the accounting book for my own startup company”, hoewel hij aangaf dat het af en toe wat omslachtig was om periodiek boekingen toe te voegen. Die omslachtigheid kan worden verminderd met importautomatisering, zoals we hebben gezien.

• Realtime financiële monitoring: Voor een klein bedrijf is cashflow koning. Met Fava kan een ondernemer de banksaldi en cashflow bijna realtime monitoren, vergelijkbaar met persoonlijk gebruik – maar hier is het nog belangrijker. Door bankfeeds of importen te automatiseren, kunnen ze zien of een klantbetaling binnenkwam of een grote uitgave is afgeschreven. QuickBooks biedt bankfeeds die “je laten zien hoe je bedrijf er realtime voor staat”; met Beancount dupliceer je dit door je eigen bankintegratie. Het voordeel van Beancount is transparantie – je ziet precies wat is geïmporteerd en hoe het is gecategoriseerd, in plaats van te vertrouwen op QuickBooks’ soms ondoorzichtige matching-logica.

• Facturering en AR/AP: Beancount heeft geen ingebouwd factureringsmodule (zoals het genereren van PDF-facturen of het bijhouden van factuurnummers). Toch hebben creatieve gebruikers dit opgelost met add-ons. Zo kan men bijvoorbeeld een factuur-PDF genereren vanuit een transactie met een Jinja2-sjabloon of zelfs een extern script dat openstaande AR-items uitleest. Er is een project “Beanie” dat fungeert als een lichtgewicht AR-systeem bovenop Beancount. Kleine bedrijven kunnen Beancount gebruiken voor het grootboek en een ander hulpmiddel voor het uitgeven van facturen, waarna ze de factuurgegevens importeren in Beancount. Het is een extra stap vergeleken met QuickBooks (dat facturen kan versturen en ze vervolgens automatisch registreert zodra ze betaald zijn), maar het zorgt ervoor dat alle gegevens in het open grootboek terechtkomen.

• Loonadministratie en Afschrijvingen: Dit zijn boekhoudkundige taken die kleine bedrijven afhandelen. Beancount kan zeker loonboekingen registreren (waarbij het brutoloon, belastingen, inhoudingen, enzovoort worden verdeeld over de juiste rekeningen) – maar normaal bereken je die met externe tools of via je loonadministrateur en voer je ze daarna in. Afschrijvingsschema’s voor vaste activa worden eveneens handmatig ingevoerd (of je kunt een plug-in schrijven om maandelijkse afschrijvingsboekingen te automatiseren). Beancount heeft hier geen magie voor, maar ook veel andere kleine bedrijfssoftware biedt hiernaast alleen sjablonen. Het voordeel is dat je alles ongewoons kunt scripten. Als je bijvoorbeeld een eigen inkomstenverantwoording-schema hebt, kun je die journaalposten in Python scripten en opnemen.

• Transparantie en Controleerbaarheid: Bedrijven waarderen wellicht dat Beancount een duidelijk controlepad biedt. Elke transactie is eenvoudig en kan worden voorzien van aantekeningen met links naar documenten (bonnen, contracten). Bij een controle kun je het grootboekbestand tonen samen met de bijgevoegde documenten, wat vrij simpel is. Ook betekent versiebeheer dat je een controlelog hebt van wie wanneer wijzigingen heeft uitgevoerd (als meerdere personen via Git samenwerken). Vergelijk dit met QuickBooks, waar een accountant mogelijk wijzigingslogboeken moet bekijken die niet makkelijk toegankelijk zijn voor de gebruiker.

• Kosten: Beancount+Fava is gratis, wat aantrekkelijk is voor startups of kleine bedrijven die softwarekosten willen minimaliseren. QuickBooks, Xero, enzovoort, hebben maandelijkse kosten. Het nadeel is dat die gepaard gaan met ondersteuning en eenvoudigere installatie. Een technisch onderlegde ondernemer ruilt graag wat tijd in om kosten te besparen en flexibiliteit te winnen.

Echte voorbeelden: Een andere gebruiker op HN zei dat ze het gebruikten voor een advies-LLC en dat het goed werkte, maar toen het aantal transacties groeide, begonnen ze bestanden jaarlijks te splitsen om de snelheid te behouden. De consensus is: voor een klein bedrijf (zeg tienduizenden transacties per jaar of minder), is Beancount perfect geschikt. Als je een grotere MKB zou zijn met honderdduizenden transacties, kan de prestatie aanleiding geven om een databasebenadering te gebruiken of te kiezen voor een speciaal ontworpen boekhoudsysteem – hoewel we Beanpost hebben om dit te proberen op te lossen door Postgres als backend te gebruiken.

Samenwerking: Een verschilpunt – QuickBooks Online staat meerdere gebruikers (eigenaar, accountant, enz.) toe om gelijktijdig te werken. Bij Beancount kan samenwerking via Git verlopen (meerdere gebruikers committeren wijzigingen). Dit werkt, maar vereist enige kennis van Git 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. Echter, voor een klein team (of een solo boekhouder + eigenaar) is het beheersbaar, en je kunt altijd lees-toegang verlenen via Fava (host het op een interne server en laat anderen rapporten bekijken zonder te bewerken).

Regelgeving 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 data daarop afstemt. Er is geen ingebouwde handhaving van GAAP-regels (bijv. geen ingebouwde vaste-activa module om correcte afschrijving te garanderen). Een externe accountant kan nog steeds met een Beancount-grootboek werken (omdat het in feite een gegeneraliseerd journaal is) – die kan het exporteren naar Excel en aanpassingen doen indien nodig. Sommige bedrijven geven om deze reden de voorkeur aan bekende software, of hebben in ieder geval een accountant die vertrouwd is met platte tekst data.

Wie gebruikt het zakelijk? Waarschijnlijk power-users: tech startups, freelancers met programmeerachtergrond, of bedrijven die veel waarde hechten aan datacontrole (bijv. financiële handelsfirma's die op maat gemaakte rapportage willen). Een Reddit-topic vroeg of Beancount geschikt zou zijn voor een handelsbedrijf – de antwoorden gaven aan dat het dat is, het ondersteunt multi-valuta en kan de benodigde overzichten produceren, maar je bouwt er wel enige tooling omheen.

Om deze sectie af te sluiten: 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 waar ze op kunnen zoeken en van kunnen leren, wat resulteert in zaken zoals het eenvoudig bijhouden van elke uitgave en het berekenen van statistieken die typische budgetteringshulpmiddelen niet kunnen. Kleine zakelijke gebruikers waarderen de transparantie, kostenbesparingen en aanpasbaarheid – ze kunnen de boekhouding integreren met de rest van hun softwaresuite en vermijden vendor lock-in of maandelijkse kosten. Beide gebruiksscenario’s profiteren van realtime analytics: een persoon kan hun maandelijkse budgetvoortgang volgen, een bedrijf kan dagelijkse cashflows bijhouden – in beide gevallen kan Fava actuele informatie presenteren wanneer het voorzien wordt van tijdige data.

Vergelijking met Andere Realtime Analytics Platforms​

Het is nuttig om Beancount+Fava te vergelijken met andere oplossingen die "realtime" financiële analytics bieden, zoals QuickBooks (met live bankfeeds) en Power BI (of soortgelijke BI-dashboards). Elke benadering heeft zijn sterke punten en afwegingen wat betreft transparantie, flexibiliteit en reactievermogen:

Samenvattend, Beancount+Fava vs QuickBooks: Beancount biedt superieure transparantie (je ziet en hebt controle over alles, en je gegevens verdwijnen niet of worden niet vastgezet) en flexibiliteit (je kunt alles modelleren in het grootboek, niet alleen wat QuickBooks verwacht). Het vereist meer zelfwerkzaamheid, vooral voor automatisering en mooie UI-aanpassingen. QuickBooks is een plug-and-play oplossing geoptimaliseerd voor kleine zakelijke behoeften – bankfeeds, facturering, loonadministratie (met add-ons) – en levert vrijwel real-time updates met minimale inspanning van de gebruiker. Toch is het op veel manieren 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 een getal tot stand is gekomen. Veel Beancount-gebruikers zijn mensen die gefrustreerd raakten door die black boxes. Ze ruilen wat gemak in voor duidelijkheid.

Beancount+Fava vs Power BI (of andere BI): Ze kunnen elkaar aanvullen. Power BI is geen boekhoudsysteem; het is voor analyse. In feite kan een geavanceerde setup Beancount gebruiken om te consolideren en datanauwkeurigheid te garanderen, en vervolgens Power BI gebruiken om executive dashboards te maken van die data. Als we direct vergelijken, draait Power BI meer om visuele flexibiliteit en het combineren van databronnen. De grafieken van Fava zijn eenvoudiger van opzet (gericht op boekhoudkundige behoeften) maar vereisen veel minder werk om te starten (ze werken direct vanuit je grootboek, geen modellering nodig). Als je doel puur is om inzichten en mooie visuals te krijgen en je bereid bent de data voor te bereiden, kan een BI-tool geschikt zijn. Maar als je de boeken wilt bijhouden en interactieve rapporten als bijproduct wilt, volstaat Fava vaak alleen.

Je zou ook kunnen vergelijken met andere persoonlijke financiële tools (bijvoorbeeld Mint of YNAB) of ERP-systemen, maar de vraag noemt specifiek real-time analyseplatforms. In het domein van real-time financiële overzichten: Beancount+Fava is als het hebben van een aangepast, open-source “live” financieel dashboard, QuickBooks is een gesloten bron geautomatiseerde boekhouding met live bankkoppeling, en Power BI is een flexibel analyseplatform (niet financieel-specifiek maar kan voor financiën worden gebruikt als je het van data voorziet).

Een sprekende uitspraak die open source tegenover commercieel zet: “Met een beetje inspanning vooraf kan open source tooling eigenlijk veel beter zijn dan commerciële oplossingen, en veel flexibeler en uitbreidbaar.” Dit vat de afweging samen. QuickBooks is gepolijst en werkt direct uit de doos voor veelvoorkomende scenario's met minimale inspanning. Maar zodra je iets wilt wat het niet doet, loop je tegen een muur aan. Met Beancount loop je zelden tegen een muur aan – je hebt de bron en de data, je kunt het uitbreiden of integreren waar nodig. De prijs is dat je bereid moet zijn te knutselen.

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

Tot slot, laten we de voor- en nadelen van Beancount+Fava als oplossing voor financiële analyse helder samenvatten:

Voordelen​

• Transparantie en Vertrouwen: Alle berekeningen (totaalbedragen, saldi) zijn afgeleid van een eenvoudige tekstgrootboek die je kunt inspecteren. Er is geen mysterieuze werking. Dit creëert groot vertrouwen in de cijfers – cruciaal als je beslissingen daarop baseert. Het is "schone, transparante boekhouding" zonder lock-in. Je kunt altijd een gerapporteerd cijfer terugvolgen tot de onderliggende transacties, wat de essentie is van data-gedreven inzicht.

• Reproduceerbaarheid en Controleerbaarheid: Omdat je het grootboek met versiebeheer beheert, heb je een tijdlijn van veranderingen. Als er deze maand iets niet klopt, kun je het grootboek vergelijken om te zien wat er gewijzigd is. Dit betekent ook dat je kunt experimenteren ("wat als ik deze uitgave herclassificeer?") en makkelijk ongedaan maken. Data-gedreven werk omvat vaak iteraties, en een controleerbaar grootboek moedigt dat aan.

• Flexibiliteit in Analyse: Je bent niet beperkt tot vooraf gebouwde rapporten. De combinatie van BQL-query's, Python-scripting en Fava's filters betekent dat je bijna elke financiële vraag kunt beantwoorden. Wil je weten "Hoeveel heb ik elk jaar van de afgelopen 5 jaar bij Starbucks uitgegeven?" – één query verwijderd. Of "Wat is het voortschrijdend gemiddelde van mijn 3-maandelijkse uitgaven versus inkomsten?" – scriptbaar met Python+pandas bovenop een query. Deze flexibiliteit is een groot voordeel voor wie graag in data duikt. Gevorderde gebruikers hebben zelfs extensies gebouwd om financiële indicatoren te berekenen (bijv. portefeuillprestaties) binnen Fava. Kortom, je kunt zeer gedetailleerde inzichten krijgen die veel kant-en-klare software niet kan bieden.

• Integratie en Uitbreidbaarheid: Fava's plugin-systeem en de toegankelijke Beancount API betekenen dat de tools met je behoeften mee kunnen groeien. Als je morgen een nieuw soort activum moet bijhouden of een nieuwe databron wilt integreren, kun je het systeem uitbreiden. De architectuur (platte tekst erin, diverse outputs eruit) is zeer uitbreidbaar. Dit staat in contrast met gesloten systemen waar je een functie moet aanvragen en moet wachten.

• Dataconsolidatie: Voor individuen en zelfs bedrijven is het krachtig om alle rekeningen (meerdere banken, brokers, enz.) in één systeem te consolideren. Veel commerciële oplossingen plaatsen je in silo’s (of rekenen extra voor multi-currency of meerdere entiteiten). Met Beancount kun je alles samenbrengen. Dit geeft een holistisch databeeld, waardoor inzichten over de hele linie mogelijk zijn. Bijvoorbeeld, je kunt je echte totale activaspreiding of netto kasstroom over privé en zaken berekenen als je wilt, omdat het gewoon data-invoer is.

• Kostenbesparing: Het is gratis en open-source. Voor persoonlijk gebruik is dit een groot voordeel (geen abonnement zoals bij veel budgetapps). Voor startups of kleine organisaties kunnen die besparingen oplopen. Maar naast geld bespaart het ook in efficiëntie qua draaien (Fava draait op een kleine server) en portabiliteit (geen kostbare migraties als je groeit – 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 mogelijk iets soortgelijks heeft gedaan. Bijvoorbeeld, meerdere gebruikers hebben bijgedragen aan slimme importtools en zelfs machine learning categorisatie (bijv. de “smartimporter” bibliotheek die scikit-learn gebruikt om automatisch begunstigden te categoriseren op basis van eerdere data). Na verloop van tijd kan het gebruik van Beancount feitelijk _smarter worden als je deze community tools benut – het benadert het gemak van commerciële software terwijl transparantie behouden blijft.

• Verantwoordelijkheid en Leren: Het gebruik van Fava/Beancount dwingt je om op een dieper niveau met je financiële gegevens te werken. Veel gebruikers geven aan dat ze dankzij dit systeem een veel beter inzicht in hun financiën kregen dan ooit met geautomatiseerde apps. Het is een beetje als het verschil tussen zelf 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 deze “eigenaarschap” van het proces leiden tot betekenisvollere ontdekkingen, omdat je gemakkelijk kunt bepalen en herdefiniëren hoe je naar de gegevens kijkt.

Nadelen​

• Initiële installatie en leercurve: Laten we eerlijk zijn – Beancount en Fava zijn niet zo plug-and-play als bijvoorbeeld QuickBooks of Mint. Je moet de basisprincipes van dubbel boekhouden leren (als je die niet kent), de Beancount-bestandsyntax, 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 de interface van Fava veel helpt door een vriendelijkere ervaring te bieden zodra het is ingesteld). Daarentegen verbergen veel commerciële tools boekhoudconcepten achter eenvoudigere interfaces (wat zowel een voordeel als een nadeel kan zijn).

• Geen ingebouwde bankkoppeling: Vanwege het ontwerp wordt er niet automatisch verbinding gemaakt met bank-API's (die vaak eigendom zijn of waarvoor overeenkomsten nodig zijn). Je moet daarom ofwel handmatig afschriften downloaden of je eigen automatisering opzetten (via Python-scripts of services zoals Plaid die vaak kosten met zich meebrengen). Voor degenen die gewend zijn aan bankfeeds die “gewoon werken”, kan dit voelen als een stap terug. Zoals een gebruiker opmerkte, toen ze Beancount probeerden, vonden ze "geen redelijke manier om bankfeeds te krijgen" – dit kan frustrerend zijn tenzij je wilt coderen of derdenoplossingen gebruikt.

• Real-time betekent jouw tijd: Real-time responsiviteit is mogelijk, maar niet standaard. Je moet cronjobs of triggers instellen zoals beschreven. Als er iets stukgaat (bijv. een bank verandert zijn CSV-formaat), moet je je importeur repareren. Met een dienst zoals QuickBooks regelt de aanbieder dit soort wijzigingen. In wezen ben je je eigen IT-support. Dit is de klassieke open-sourceafweging. Voor een hobbyist kan dit prima of zelfs leuk zijn; voor een drukke kleine ondernemer kan het een last zijn.

• Schaalbaarheid en prestatiebeperkingen: Voor zeer grote datasets (veel jaren gedetailleerde transacties) kan Beancount trager worden. Het is over het algemeen efficiënt (mensen hebben tienduizenden boekingen zonder problemen). Maar zoals te zien in de Hacker News-discussie, moest een gebruiker na 3 jaar jaarlijks de boeken "sluiten" omdat het bestand groeide om queries snel te houden. De Beancount v2-code is in Python en kan wat traag zijn voor enorme data, hoewel v3 (onder ontwikkeling met een C++-kern) dit verbetert. Er zijn oplossingen (bestanden splitsen, Beanpost gebruiken om naar DB uit te besteden, enz.), maar het is een punt om rekening mee te houden. QuickBooks heeft waarschijnlijk interne schaalbaarheid en de meeste BI-tools zijn gebouwd op databases die geschikt zijn voor grote datasets – dus die kunnen grote data beter aan.

• Functionaliteitslacunes (ten opzichte van gespecialiseerde software): Beancount+Fava richten zich op boekhouding en analyse. Het mist enkele aanvullende functies: bijv. geen loonadministratie, geen factuurgeneratie (zonder aangepaste scripting), geen geïntegreerde belastingvoorbereidingsformulieren, enz. Als je doel uitgebreid financieel beheer is, moet je waarschijnlijk aanvullen met andere tools. Je kunt bijvoorbeeld loonadministratie doen via een loonservice en alleen de journaalposten importeren. Dat werkt, maar het is niet zo naadloos geïntegreerd als een ERP dat alles in één doet. Voor persoonlijke financiën heeft Beancount geen ingebouwde aflossingsplanners of budgetconveloppen (hoewel je die kunt simuleren). Verwacht wordt dat je inzichten afleidt en dan beslissingen neemt, in plaats van voorschrijvende adviezen of planningsmodules te bieden.

• Gebruikersinterface en afwerking: Hoewel Fava best mooi is, is het niet zo gepolijst of begeleid als sommige commerciële aanbiedingen. Er is geen "wizard" die je door de setup leidt of helpt fouten te voorkomen. Je moet soms documentatie lezen om te weten hoe je X doet. En bepaalde UI-functies die je zou verwachten (drag-en-drop categorisatie, multi-step undo, pushmeldingen op mobiel, enz.) ontbreken. De Fava UI wordt voortdurend verbeterd (met bijdragen), maar het wordt gebouwd door een kleine gemeenschap. Als je gewend bent aan strakke moderne SaaS-UIs, kan Fava wat utilitair aanvoelen (hoewel sommigen juist de cleane eenvoud waarderen). Op mobiel werkt Fava (vooral read-only) maar is niet volledig geoptimaliseerd voor kleine schermen; QuickBooks heeft bijvoorbeeld speciale mobiele apps.

• Afhankelijkheid van de community/onderhouder: Martin Blais (de auteur van Beancount) en bijdragers onderhouden Beancount, en anderen onderhouden Fava. Ontwikkeling kan sporadisch zijn (zoals gebruikelijk bij OSS). Hoewel de software nu zeer bruikbaar is, als je een nieuwe functie wilt of er is een bug, moet je het zelf oplossen of wachten. Met een betaald product heb je ondersteuning die je kunt bellen (kwaliteit varieert, maar die is er tenminste). Toch is de community meestal erg behulpzaam via de mailinglijst of GitHub-issues.

• Vereiste Boekhoudkundige Kennis: Vooral voor zakelijk gebruik moet je weten wat je doet. Beancount voorkomt niet dat je een invoer maakt die vanuit boekhoudkundig oogpunt “verkeerd” is (behalve bij onbalans of niet-gematchte transacties). QuickBooks heeft daarentegen beschermingsmechanismen (en ook verborgen complexiteit zoals automatische verwerking van uitgestelde omzet, enz., als je die inschakelt). Als je niet voorzichtig bent met Beancount, kun je een tussentijdse aanschrijving fout doen en dit pas merken zodra een rapport een probleem vertoont. In essentie gaat Beancount ervan uit dat je basiskennis van boekhouden hebt of bereid bent het te leren. Dit is voor sommigen juist een voordeel (dwingt je om het goed te doen), maar een nadeel als je een systeem zonder nadenken wilt.

Om de voor- en nadelen samen te vatten: Beancount + Fava biedt ongeëvenaarde controle en aanpasbaarheid voor wie zich diep met hun financiële gegevens wil bezig houden, waardoor het een krachtig hulpmiddel is voor datagedreven inzichten. Het verandert je boeken in een doorzoekbare dataset en je rapporten in een uitbreidbare webapplicatie. De prijs voor deze kracht is de tijd die je investeert in het opzetten en onderhouden, en de noodzaak om enigszins zelfredzaam te zijn in het beheren van je systeem. In tegenstelling tot iets als QuickBooks of een BI-suite, die meer begeleiding bieden en bepaalde functies automatisch leveren, geeft Beancount je een gereedschapskist. Als je analytisch ingesteld bent, kan deze gereedschapskist enorm bevrijdend zijn – je kunt inzichten halen die kant-en-klare rapporten misschien nooit tonen. Zoals een gebruiker die zijn Beancount-grootboek over jaren heeft geautomatiseerd schreef: “open-source tools (zoals Beancount) voldoen niet [out-of-the-box] aan al mijn behoeften… Ik ben geobsedeerd door het automatiseren van alles… Ik bouwde wat ik nodig had”. Dit vat de aanpak samen: als je bereid bent te bouwen wat je nodig hebt, hoe klein of groot ook, dan ondersteunen Fava/Beancount je en verbergen ze je gegevens nooit voor je. Voor een datagedreven mentaliteit is dat een enorm voordeel.

Samenvattend is het gebruik van Fava en Beancount voor realtime financiële analyse een beetje alsof je een eigen aanpasbaar laboratorium voor je financiën hebt. Je krijgt helderheid, flexibiliteit en eigenaarschap die moeilijk te evenaren zijn met propriëtaire platforms, wat het ideaal maakt voor degenen die deze aspecten waarderen en bereid zijn wat gemak op te offeren om ze te krijgen. Het moderne landschap laat zelfs hybride benaderingen zien – bijvoorbeeld, sommigen gebruiken een commercieel hulpmiddel maar exporteren periodiek naar Beancount voor diepgaandere analyses, of gebruiken Beancount als primaire tool 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, met vertrouwen verder gaan om de mogelijkheden te benutten voor rijke, realtime 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). Discussie over Grafana-integratie (Josh D. en 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. Diverse discussies (2021-2023) over zakelijk gebruik van Beancount en ledgervisualisatie.
• Fava Extension Documentation – Help: Extensions.
• fava-dashboards GitHub README – Andreas Gerstmayr’s aangepaste dashboards plugin.
• Awesome Beancount lijst – door de community samengestelde bronnen voor Beancount.