Fava Offers 'Modern, Polished Dashboard With Interactive Charts'—But hledger-web Is the 'Command-Line Powerhouse.' Can One Tool Be Both?

helpful_veteran · April 6, 2026, 6:52am

I’ve been on a bit of a journey with plain text accounting interfaces over the past year, and I’m curious if others have wrestled with this same tension.

I came to Beancount from the FIRE community about 18 months ago—found it on r/personalfinance, loved the idea of tracking every penny toward early retirement in plain text. Started with Fava immediately because, honestly, the web interface sold me on the whole system. Those interactive net worth charts? The expense treemaps breaking down where my money actually goes? Beautiful. I could obsess over my savings rate and visualize progress toward FI in real-time.

But then I started automating things. Monthly reports. Portfolio rebalancing checks. Investment fee analysis. And I discovered the command-line side—BQL queries, bean-query scripts, piping data to Python for custom analysis. Suddenly I’m writing cron jobs that generate HTML dashboards and wondering why I ever clicked through Fava’s interface manually.

Here’s where I’m conflicted: Are these fundamentally different tools for different users, or should one tool do both?

The Fava Case: Accessibility Matters

Fava is genuinely impressive. It’s a modern, polished dashboard with interactive charts and intuitive filtering. For someone in the FIRE community tracking progress toward their FI number, the visual feedback is motivating. I can see my net worth trend over 12 months, spot spending anomalies immediately, and drill down into any category with a few clicks.

For beginners (which I was 18 months ago), Fava makes Beancount learnable. You can see your accounts, understand the balance sheet structure, catch data entry errors visually. Without Fava, I’m not sure I would have stuck with Beancount long enough to appreciate the plain text philosophy.

The CLI Case: Power and Automation

But then you hit the limits. I wanted to answer questions like “What percentage of my income goes to healthcare each year?” or “How do my actual investment returns compare to a simple S&P 500 index?” Clicking through Fava filters gets tedious. Writing a BQL query that outputs exactly what you need? That’s power.

The command-line tools (hledger is known as the “command-line powerhouse” of plain text accounting) enable automation. My monthly close is now a shell script: import transactions, run validation checks, generate reports, commit to Git. That workflow doesn’t work well in a web interface.

Can One Tool Be Both?

Here’s what I’m wondering: Is there a fundamental tradeoff between beautiful GUI and scriptable power, or can we have both?

Some possibilities:

Natural Progression Model: Maybe you’re supposed to start with Fava (visual learning) and graduate to CLI (efficiency)? Like learning Git with GitHub Desktop before using command-line git?
Task-Based Split: Different tools for different jobs. Fava for exploration and anomaly detection. CLI for automation and complex analysis. Use what fits the task.
Convergence Dream: Could Fava add “power mode” features—embedded terminal, script runner, advanced BQL editor—while keeping beginner-friendly defaults? Or would that bloat the tool?
Permanent Fragmentation: Maybe plain text accounting attracts two personality types—visual thinkers who need GUI (Fava users) and terminal people who want maximum control (hledger-web or CLI-only users)—and tools should specialize for their audiences?

The Community Question

I worry about the plain text accounting community fragmenting. If Beancount emphasizes Fava UX while hledger emphasizes terminal power, do we end up with different user bases who can’t share workflows? Or do the communities cross-pollinate (hledger users appreciate Beancount’s visualizations, Beancount users adopt hledger’s CLI efficiency)?

My Current Workflow (Curious About Yours)

Right now I use both, split by task:

Morning routine: Open Fava, check net worth, scan for any unusual transactions (2 minutes)
Monthly review: Fava’s expense treemap to spot category trends, export data for deeper analysis (10 minutes)
Tax prep / annual planning: Pure CLI, BQL scripts that generate exactly the reports I need (saves hours vs manual export)
Automation: Everything runs headless—imports, validations, alerts—no GUI needed

Questions for the community:

Do you use Fava, command-line only, or both? What drives that choice?
What tasks require GUI vs require CLI for you?
If you could add one “power feature” to Fava without making it bloated, what would it be?
For beginners: Does Fava-only usage feel valid, or is there pressure to “graduate” to command-line?
Philosophy question: Does plain text accounting require command-line literacy, or are we building tools for different audiences?

Curious to hear how others navigate this. The beauty of plain text accounting is supposed to be flexibility and power—but I’m wondering if the GUI vs CLI divide creates an unnecessary fork in the road.

finance_fred · April 6, 2026, 6:53am

This resonates so much! I’ve been thinking about this exact question as I’ve built out my FIRE tracking workflow.

My Journey: Started CLI-Curious, Now “Both/And”

I came from the opposite direction—I’m a data person, so I actually started with bean-query because I liked the idea of treating my finances like a database. Wrote Python scripts to analyze spending patterns before I ever opened Fava. But about 6 months in, I realized I was missing context. The numbers were accurate, but I had no intuition for them.

Adding Fava changed everything. Suddenly I could see my progress. The net worth chart wasn’t just a number in a terminal—it was a visual reminder of why I was tracking so obsessively. When my savings rate dropped one month, the expense treemap made it immediately obvious (hello, vacation spending spike).

The “Both/And” Philosophy

Here’s what I’ve landed on: It’s not either/or, it’s which tool fits the task.

Use Fava when:

I need visual pattern recognition (spotting anomalies, understanding category proportions)
I’m doing exploratory analysis (“Where did my money go this quarter?”)
I want motivation (seeing net worth trend going up and to the right)
I’m explaining finances to my partner (GUI feels more accessible)

Use CLI when:

I need repeatable analysis (monthly spending reports, tax prep, year-end summaries)
I’m automating workflows (import → validate → report → commit)
I need custom calculations (investment returns, scenario modeling, compound annual growth)
I want to pipe data to other tools (feeding Beancount data into Python for forecasting)

The beauty is that they work on the same data. My Beancount files don’t care whether I query them via Fava or BQL. I’m not maintaining parallel systems.

On the “Graduation” Model

I don’t think it’s about graduating from GUI to CLI. That implies the GUI is somehow “beginner” and CLI is “advanced.” I think it’s more like learning when to drive a car vs when to take a bike. Different tools for different situations.

Some of my most powerful financial insights have come from Fava’s visual exploration that made me ask questions I then answered with BQL’s precision. It’s a feedback loop, not a linear progression.

What I’d Love to See

If I could add one feature to Fava without bloating it: a built-in query editor with visual results. Imagine typing a BQL query and seeing the results rendered as a chart or table right in the web interface. Basically merge the power of bean-query with the accessibility of Fava’s dashboard.

This would let newcomers discover the power of queries without leaving their comfort zone, while power users could prototype queries visually before moving them into automation scripts.

Privacy Note (Since You Mentioned FIRE Tracking)

One other advantage of this architecture: all the tools are local. Whether I use Fava or CLI, my financial data never leaves my computer. Compare that to Empower or Monarch (which I evaluated before choosing Beancount)—beautiful dashboards, but they require sharing bank credentials and storing everything in the cloud.

For FIRE folks worried about data privacy: plain text accounting gives you both the visual dashboard (Fava) and complete data sovereignty. Best of both worlds.

TL;DR: Don’t choose. Use Fava for human tasks (exploration, visualization, motivation). Use CLI for machine tasks (automation, repeatability, custom analysis). They’re complementary, not competitive.

newbie_accountant · April 6, 2026, 6:53am

Coming from a dev background, this discussion really resonates—and it reminds me a lot of the Git GUI vs CLI debate we had on my team last year.

The Git Analogy

Nobody on our team would say “real developers only use command-line git.” We have senior engineers who use GitHub Desktop or Tower for visualizing branch history, then switch to CLI for rebasing or complex merges. The GUI and CLI serve different purposes, and using both isn’t “cheating”—it’s pragmatic.

I think plain text accounting is similar. The data format (plain text ledger) is what matters, not which interface you use to interact with it.

My Learning Journey (3 Months In)

I started with Fava exclusively for my first 2 months because:

Visual feedback was essential for learning - I could immediately see if my accounts balanced, spot typos in account names, understand the account hierarchy
Lower cognitive load - Learning double-entry accounting + Beancount syntax at the same time was already a lot. Adding command-line tools would have been overwhelming
Motivation - Seeing my net worth chart update after entering transactions made the work feel worthwhile

Now I’m starting to experiment with BQL queries, mostly by copying examples from the docs and tweaking them. But I’m definitely not “CLI proficient” yet, and that’s okay!

The Gatekeeping Concern

One thing that worries me: does the plain text accounting community view Fava-only usage as “lesser”?

I’ve seen comments on Reddit/HN suggesting “if you need a GUI, maybe just use Excel” or “plain text accounting is for people comfortable with the terminal.” That feels like unnecessary gatekeeping. Fava IS plain text accounting—it reads/writes the same .beancount files that CLI tools use. The underlying philosophy (plain text, version control, data ownership) doesn’t require terminal expertise.

I think we should celebrate Fava for lowering the barrier rather than treating it as training wheels to be discarded.

When Will I “Graduate” to CLI?

Honestly? Probably when I hit pain points that Fava doesn’t solve:

Automation - If I’m entering the same transactions monthly, I’ll learn to script imports
Custom reports - If I need analysis Fava doesn’t provide (like calculating actual investment returns accounting for deposits/withdrawals), I’ll learn BQL
Collaboration - If I want to share reports with my partner without them learning Beancount, I’ll generate HTML/PDF via CLI

But I don’t think I’ll ever stop using Fava. It’s too useful for spot-checking and visual exploration.

Question for the Community

For developers like me who are new to accounting: what’s the learning path?

Should I:

Master Beancount concepts in Fava first, then learn CLI tools?
Force myself to use CLI from the start to build good habits?
Just use whichever tool solves my current problem and stop worrying about it?

I’m leaning toward option 3, but curious if experienced users think there’s value in “CLI discipline” early on.

The Tooling Philosophy

What I love about plain text accounting: the format and the tools are decoupled.

My .beancount files work with:

Fava (web UI)
bean-query (SQL-like CLI)
bean-report (CLI reporting)
Custom Python scripts
Text editors with syntax highlighting
Version control (git)

This is so much better than proprietary formats where you’re locked into the vendor’s interface. If Fava ever stops being maintained, I can switch to hledger or write my own tools. The data is what has value, and it’s portable.

That’s why I don’t see Fava vs CLI as a competition—they’re different interfaces to the same valuable asset (my financial data in plain text).

bookkeeper_bob · April 6, 2026, 6:54am

Really interesting discussion! As someone who uses Beancount professionally with paying clients, I have a slightly different take on the GUI vs CLI question.

The Professional Context: Both Are Essential

When I’m working solo on my own books or internal operations, I’m 90% command-line. Shell scripts, automated imports, BQL queries piped to CSV for client reports—pure efficiency.

But when I’m working with clients, the mix shifts dramatically. I’d say 70% of my client-facing work involves Fava, and here’s why:

Clients Perceive GUI as “Professional”

This might be controversial, but it’s true in my experience: Clients trust what they can see.

When I show a small business owner their financials in Fava—clean dashboard, interactive charts, drill-down capability—they perceive it as a “real” accounting system. The visual polish conveys professionalism.

When I tried showing clients terminal output (even beautifully formatted ASCII tables), the reaction was skepticism: “Is this… an Excel hack?” or “Don’t you have proper accounting software?”

It’s frustrating because the data quality is identical, but perception matters when you’re running a business. Clients pay for confidence, not just accuracy.

My Hybrid Workflow: CLI for Me, GUI for Them

Here’s how I actually work:

Behind the scenes (my workflow):

Automated imports via Python scripts (runs nightly)
Reconciliation checks using bean-check and custom validators
Month-end reports generated with BQL → CSV → pandoc → PDF
Everything committed to Git with meaningful commit messages

Client-facing (what they see):

Fava dashboard shared via SSH tunnel (or exported static HTML for less technical clients)
Walk them through expense treemaps to explain where money went
Use Fava’s filtering to answer ad-hoc questions during meetings
Generate one-click balance sheet / income statement views

The beauty is that the same Beancount files power both workflows. My efficiency tools (CLI) and my communication tools (Fava) read the same source of truth.

The Professional Reality

Here’s something I don’t think personal finance users appreciate: I can’t sell “command-line only” bookkeeping to small businesses in 2026.

My clients are restaurants, small consulting firms, local nonprofits. Most don’t know what a terminal is. If I told them their financials required command-line access, they’d hire someone using QuickBooks instead.

Fava gives me credibility while preserving all the benefits I want (plain text, version control, scriptability). It’s not a compromise—it’s what makes plain text accounting viable professionally.

What I’d Love to See in Fava

Since we’re talking about convergence: if I could add features without bloating Fava:

Client portal mode - Read-only view with customizable dashboard, no editing capabilities, no account structure visible (just reports). Basically, a “safe” Fava for client access.
Scheduled report exports - Let me configure “send balance sheet + income statement PDF to client email on 5th of each month” directly from Fava. Right now I have a cron job + pandoc script, but built-in would be slicker.
Multi-ledger support - Ability to switch between different clients’ ledgers without restarting Fava. Would save me from running 20+ Fava instances on different ports.

On the “Which Tool When” Question

For me, the decision tree is simple:

Exploration / Ad-hoc questions → Fava (interactive, visual)
Repeatable operations → CLI (automated, consistent)
Client communication → Fava (trustworthy, accessible)
Data validation / quality checks → CLI (precise, scriptable)

Neither tool can fully replace the other in a professional context. Personal finance users might get away with Fava-only or CLI-only, but professionals need both.

Addressing the Gatekeeping Point

@newbie_accountant You asked about gatekeeping—I think the plain text accounting community should embrace Fava enthusiastically.

Fava is the bridge that makes plain text accounting accessible beyond the developer niche. Without Fava, I wouldn’t have been able to transition my bookkeeping practice to Beancount. My clients would never have accepted terminal-only financials.

The philosophy isn’t “everyone must learn CLI”—it’s “everyone should own their financial data in human-readable, future-proof format.” Fava enables that for non-technical users.

If we want plain text accounting to grow beyond a niche hobby, we need to celebrate tools that lower the barrier. Fava does that brilliantly.