55 posts tagged with "accounting"

Choosing a personal accounting system involves trade-offs between performance, data architecture, and extensibility. For engineers and other technical users, the choice often comes down to which system provides the most robust, predictable, and programmable foundation.

Drawing from a detailed comparative report, let's analyze the technical specifics of Beancount versus its popular open-source counterparts: Ledger-CLI, hledger, and GnuCash.

Speed and Performance: Quantitative Benchmarks 🚀​

For any serious dataset, performance is non-negotiable. Beancount is architected to handle decades of transactional data without compromising on speed. Despite being implemented in Python (v2), its highly optimized parser is remarkably efficient.

• Beancount: Real-world usage shows it can load and process ledgers with hundreds of thousands of transactions in approximately 2 seconds. Memory usage is modest; parsing ~100k transactions converts the source text into in-memory objects using only tens of megabytes of RAM.
• The 1M Transaction Stress Test: A benchmark using a synthetic ledger of 1 million transactions, 1,000 accounts, and 1 million price entries revealed significant architectural differences:
  • hledger (Haskell): Successfully completed a full parse and report in ~80.2 seconds, processing ~12,465 txns/sec while using ~2.58 GB of RAM.
  • Ledger-CLI (C++): The process was terminated after 40 minutes without completion, likely due to a known regression causing excessive memory and CPU usage with highly complex ledgers.
  • Beancount: While not included in that specific 1M test, its performance curve suggests it would handle the task efficiently. Furthermore, the upcoming Beancount v3, with its new C++ core and Python API, is expected to deliver another order-of-magnitude improvement in throughput.
• GnuCash (C/Scheme): As a GUI application loading its entire dataset into memory, performance degrades noticeably with size. A ~50 MB XML file (representing 100k+ transactions) took 77 seconds to open. Switching to the SQLite backend only marginally improved this to ~55 seconds.

Conclusion: Beancount provides exceptional performance that scales predictably, a crucial feature for long-term data management. It avoids the performance cliffs seen in Ledger and the UI-bound latency of GnuCash.

Data Architecture: Plain Text vs. Opaque Databases 📄​

The way a system stores your data dictates its transparency, portability, and durability. Beancount uses a clean, human-readable plain text format that is superior for technical users.

• Compact & Efficient: A 100,000-transaction Beancount file is only ~8.8 MB. This is more compact than the equivalent Ledger file (~10 MB) partly because Beancount's syntax allows for the inference of the final balancing amount in a transaction, reducing redundancy.
• Structurally Enforced: Beancount mandates explicit YYYY-MM-DD\ open\ Account directives. This disciplined approach prevents account name typos from silently creating new, incorrect accounts—a common pitfall in systems like Ledger and hledger which create accounts on-the-fly. This structure makes the data more reliable for programmatic manipulation.
• Version Control Ready: A plain text ledger is perfectly suited for version control with Git. You get a complete, auditable history of every financial change you make.
• Contrast with GnuCash: GnuCash defaults to a gzip-compressed XML file, where data is verbose and wrapped in tags with GUIDs for every entity. While it offers SQLite, MySQL, and PostgreSQL backends, this abstracts the data away from simple, direct text manipulation and versioning. Editing the raw XML is possible but far more cumbersome than editing a Beancount file.

Conclusion: Beancount's data format is not just text; it's a well-defined language that maximizes clarity, enforces correctness, and integrates seamlessly with developer tools like git and grep.

The Killer Feature: A True Python API and Plugin Architecture 🐍​

This is Beancount's defining technical advantage. It is not a monolithic application but a library with a stable, first-class Python API. This design decision unlocks limitless automation and integration possibilities.

• Direct Programmatic Access: You can read, query, and manipulate your ledger data directly in Python. This is why developers migrate. As one user noted, the frustration of trying to script against Ledger's poorly documented internal bindings evaporates with Beancount.
• Plugin Pipeline: Beancount's loader allows you to insert custom Python functions directly into the processing pipeline. This enables arbitrary transformations and validations on the data stream as it's being loaded—for instance, writing a plugin to enforce that every expense from a specific vendor must have a certain tag.
• Powerful Importer Framework: Move beyond clunky CSV import wizards. With Beancount, you write Python scripts to parse financial statements from any source (OFX, QFX, CSV). Community tools like smart_importer even leverage machine learning models to automatically predict and assign posting accounts, turning hours of manual categorization into a seconds-long, one-command process.
• How Others Compare:
  • Ledger/hledger: Extensibility is primarily external. You pipe data to/from the executable. While they can output JSON/CSV, you cannot inject logic into their core processing loop without modifying the C++/Haskell source.
  • GnuCash: Extensibility is handled via a steep learning curve with Guile (Scheme) for custom reports or via Python bindings (using SWIG and libraries like PieCash) that interact with the GnuCash engine. It's powerful but less direct and "Pythonic" than Beancount's native library approach.

Conclusion: Beancount is architected for the programmer. Its library-first design and deep integration with Python make it the most flexible and automatable system of the four.

Philosophy: A Strict Compiler for Your Finances 🤓​

Beancount's learning curve is a direct result of its core philosophy: your financial data is a formal language, and it must be correct.

Beancount's parser functions like a strict compiler. It performs robust syntactical and logical validation. If a transaction doesn't balance or an account hasn't been opened, it will refuse to process the file and will return a descriptive error with a line number. This is a feature, not a bug. It guarantees that if your file "compiles," the underlying data is structurally sound.

This deterministic approach ensures a level of data integrity that is invaluable for building reliable automated systems on top of it. You can write scripts that consume Beancount's output with confidence, knowing the data has already been rigorously validated.

Who is Beancount For?​

Based on this technical analysis, Beancount is the optimal choice for:

• Developers and Engineers who want to treat their finances as a version-controlled, programmable dataset.
• Data Tinkers who want to write custom queries, build unique visualizations with tools like Fava, or feed their financial data into other analytical models.
• Anyone who values demonstrable correctness and automation over the convenience of a GUI or the leniency of a less-structured format.

If you desire raw C++ performance for standard reports, Ledger is a contender. For exceptional scalability in a functional programming paradigm, hledger is impressive. For a feature-packed GUI with minimal setup, GnuCash excels.

But if you want to build a truly robust, automated, and deeply customized financial management system, Beancount provides the superior technical foundation.

Running a small business is already a constant juggle of cash flow, suppliers, and customers—tax surprises shouldn’t be another bowling pin in the air. The good news: with a simple framework and a few Beancount tricks, you can translate “I hope the tax bill isn’t huge” into a predictable monthly transfer.

1. Know What You’re Really Paying For​

Before you can set money aside, you need to know where it’s going. For most U.S. small businesses (especially sole proprietorships and partnerships), the total tax liability is a combination of several distinct obligations.

• Federal Income Tax: This is a progressive tax, meaning the rate increases as your income does. For 2025, brackets go up to 37% for single incomes above $626,350 and married-filing-jointly (MFJ) incomes above $751,600.
• Self-Employment (SE) Tax: This is the entrepreneur's version of FICA taxes (Social Security and Medicare) that W-2 employees pay. It’s a flat 15.3% on your first chunk of net earnings. The 12.4% Social Security portion stops once your profit hits the annual wage base, which is projected to be $176,100 in 2025. The remaining 2.9% for Medicare continues on all profits.
• State & Local Income Tax: This varies wildly by location, ranging from 0% in states like Wyoming and Texas to over 13% in California's top bracket.
• Quarterly Underpayment Penalties: The IRS wants its money throughout the year, not all at once. To avoid penalties, you generally must pre-pay at least 90% of your current year's tax liability or 100% of your previous year's tax bill (this threshold rises to 110% if your adjusted gross income, or AGI, is over $150,000).

Quick heuristic: Most U.S. solopreneurs who live in an average-tax state end up owing 25% - 30% of net profit once federal, SE, and state taxes are combined.

2. A Three-Step Estimate You Can Update Monthly​

You don’t need complex software to get a handle on this. A simple, repeatable process is all it takes.

1. Project Annual Profit: Look at your year-to-date performance and make a reasonable forecast for the full year. The basic formula is your friend: Projected Revenue - Projected Deductible Expenses = Projected Profit.
2. Apply an Effective Tax Rate: Start with a reasonable percentage. If you have last year’s tax return, you can calculate your effective rate from that. If you're new to this, the 30% heuristic is a safe starting point.
3. Divide by 12 (or 52): Take your total estimated annual tax and divide it by the number of pay periods you want to use. We recommend monthly. Move that amount into a dedicated tax-reserve bank account every month. If your cash flow is more volatile, a weekly transfer might feel more manageable.

3. Implement It in Beancount​

Plain-text accounting makes this process transparent and auditable. Here’s how to manage your tax savings in Beancount.

First, create a routine transaction to move your monthly savings from your primary checking account to a separate, dedicated savings account for taxes.

; Reserve July's taxes
2025-07-31 * "Tax reserve transfer"
  Assets:Bank:Checking          -3000 USD
  Assets:Bank:TaxReserve         3000 USD
  Equity:Opening-Balances

When you make a quarterly estimated payment to the government, you record the actual liability. The payment comes directly from your reserve account.

; Record liability when you file the quarterly payment
2025-09-15 * "Q3 estimated tax payment"
  Assets:Bank:TaxReserve        -9000 USD
  Liabilities:Taxes:Federal      6000 USD
  Liabilities:Taxes:State        3000 USD

This simple system buys you three powerful advantages:

• Immediate Visibility: Your Assets:Bank:TaxReserve balance always shows what’s already “spoken for.” You know at a glance that this cash isn't available for other business expenses.
• Accurate Profit: Because the reserve is treated as a transfer between asset accounts, your Profit & Loss statement isn’t distorted. You only record the tax liability when you actually file and pay it.
• Audit Trail: Every payment to the IRS or your state treasury ties back to a clearly tagged movement from your reserve account, creating a clean paper trail.

4. Fine-Tuning Your Percentage​

The initial 25% - 30% estimate is a great start, but you should adjust it based on your specific business model.

• High-Margin Consultants / Agencies: If you clear well above the Social Security wage base ($176,100), your effective tax rate will climb. A rate of 30% - 35% is likely more accurate.
• Product Businesses with Heavy Deductions: If you have significant costs of goods sold (COGS), inventory, or other deductions, your net profit margin is lower. A rate of 20% - 25% may suffice. Use Form 1040-ES worksheets each quarter to confirm.
• S-Corp Owners: Your situation is different. The "reasonable salary" you pay yourself is subject to standard payroll withholding (FICA and income taxes). Your distributions (profits paid out beyond salary) still require quarterly estimated payments, but often at a lower marginal rate since they aren't subject to SE tax.
• Multi-State Sellers: If you have "nexus" (a significant business presence) in multiple states, you may owe income tax in each. This can stack your liabilities. For clarity, create separate liability accounts in Beancount, such as Liabilities:Taxes:State:CA and Liabilities:Taxes:State:NY.

5. Automate, Review, Repeat​

A system only works if you use it. Make it effortless.

• Automate: Link your main operating account to a high-yield savings account named something like "TaxReserve." Schedule an automatic transfer to occur right after you close your books each month.
• Review: Re-forecast your annual profit quarterly. If Q2 sales blew past expectations, increase your monthly reserve amount immediately. Don't wait until January to discover you've under-saved.
• Repeat: Keep key documents organized within your Beancount directory. Saving last year’s final tax return (document: "2024/Taxes/Form1040.pdf") gives you one-click context when discussing numbers with your CPA or planning for the next year.

Closing Thoughts​

Tax bills feel random only when the set-aside process is. By baking a percentage-based reserve directly into your double-entry accounting flow, you trade anxiety for algebra—and Beancount makes the math (and the audit trail) trivial. Review your rate each quarter, keep Assets:Bank:TaxReserve funded, and April 15th turns back into just another day of business as usual.

Disclaimer: This article is for educational purposes only and isn’t tax advice. Always confirm numbers with a qualified professional for your jurisdiction and entity type.

When you're running a business or managing your personal finances, the terms bookkeeping and accounting often blur together. But understanding their differences—especially when using a plain-text tool like Beancount—can help you build better systems and make smarter financial decisions.

In this guide, we’ll explore the roles of bookkeeping and accounting, and how Beancount supports both (yes, really).

📘 Bookkeeping: The Art of Daily Tracking​

Bookkeeping is the foundational layer of financial management. It’s about recording what actually happened—no assumptions, no forecasts.

Bookkeeping includes:

• Recording income and expenses
• Keeping track of assets and liabilities
• Tagging transactions for later use
• Maintaining a general ledger

In Beancount, this looks like:

2025-06-27 * "Stripe Payout"
  Assets:Bank:Checking     1,200.00 USD
  Income:Sales

Each transaction is a building block. You’re not analyzing yet—you’re simply recording the truth, one line at a time.

If you're just starting out, Beancount encourages good bookkeeping habits through its explicit structure and readable syntax. You’ll be forced (in a good way!) to track every cent and explain every transaction.

📊 Accounting: Turning Data Into Insight​

Accounting builds on your bookkeeping records to answer deeper questions:

• Are we profitable?
• How much cash runway do we have?
• Should we prepay for that software or expense it monthly?
• How do we minimize taxes?

In accounting, you:

• Reconcile accounts and adjust entries
• Generate reports like profit/loss statements
• Depreciate assets
• Plan for taxes and future expenses

With Beancount, you can analyze your records using tools like beancount.io:

• Navigate balance sheets, income statements, and cash flow charts
• Visualize income by category
• Annotate decisions using metadata (e.g., tag:business-trip)

Want to track that annual Zoom subscription?

2025-01-15 * "Zoom Annual Plan"
  Expenses:Software     149.90 USD
  Assets:Bank:Checking
  tag:business-tools

You can later amortize it monthly or analyze it during budgeting sessions.

👩‍💼 Bookkeeper vs. Accountant: Who Does What?​

• Bookkeeper: Focuses on precision. Records, categorizes, and organizes.
• Accountant: Adds interpretation. Advises, plans, and models outcomes.

Beancount empowers you to be both, or to cleanly hand off one layer to a professional.

For example:

• As a founder, you may do your own bookkeeping with Beancount.
• At tax season, you export reports or raw data for your accountant to finalize.

🛠️ Bookkeeping and Accounting Software: Where Does Beancount Belong?​

Most mainstream tools (e.g., QuickBooks, Xero) blur the line between bookkeeping and accounting. Beancount takes a different approach:

• You manage everything through plain text, stored in version control if you like.
• There's no hiding of transactions or behind-the-scenes magic.
• You're encouraged to understand your own books.

Beancount is ideal for those who value transparency, data integrity, and automation through open-source tools.

🧠 Why This Distinction Matters​

Knowing the difference between bookkeeping and accounting helps you:

• Stay compliant and audit-ready
• Understand where to invest time (daily tracking vs. monthly insights)
• Communicate clearly with financial professionals
• Scale your financial systems without drowning in complexity

🪄 Final Thought: Your Ledger, Your Rules​

Whether you're a solo creator or a small business owner, Beancount gives you the power to manage your books with precision—and eventually make strategic decisions like a CFO.

Remember:

• Bookkeeping = what happened
• Accounting = what it means

With Beancount, you’re building both layers with clarity and confidence.

Let me know if you'd like a printable version or a tutorial follow-up.

Every financial transaction your business makes needs to be recorded—and in the world of plain-text accounting, this starts with journal entries. If you're using Beancount, understanding journal entries is key to building accurate, auditable, and clean financial records.

This guide will walk you through:

• What a journal entry is
• Why journal entries matter
• How to write them in Beancount syntax
• How to use them effectively
• Examples of real-world transactions (client payments, purchases, loans, etc.)

🧾 What is a Journal Entry in Beancount?​

In Beancount, a journal entry is a dated transaction written in a human-readable plain-text format. Each entry follows the principles of double-entry accounting—you record where money comes from (credit) and where it goes (debit), ensuring your books always balance.

Example:

2024-06-01 * "Client payment for invoice #123"
  Assets:Bank:Checking     600.00 USD
  Income:Sales

• The * indicates a cleared transaction.
• The description shows context for the entry.
• Assets:Bank:Checking is debited.
• Income:Sales is credited (value implied).

Every entry lives inside a .beancount file—just a text file you can version, back up, and even edit in Vim or VSCode.

📒 Why Journal Entries Matter​

Journal entries are the atomic unit of your ledger.

They:

• Feed into your General Ledger and Account Balances
• Drive all reports: Income Statements, Balance Sheets, Cash Flows
• Let you trace every dollar, line by line, to its source

With the right tools, you'll see these transactions rendered in a UI—categorized, searchable, and filterable. But it all starts with that simple plain-text entry.

📚 How Double-Entry Works in Beancount​

Beancount enforces double-entry accounting. Every transaction must be balanced: total debits = total credits.

Quick rule:

• Debit assets and expenses (you gain cash or incur a cost)
• Credit income and liabilities (you earn money or take on debt)

Example – Office Supplies Purchase:

2024-06-02 * "Bought printer ink"
  Expenses:OfficeSupplies   100.00 USD
  Assets:Bank:Checking

🧠 Visualizing Entries​

Once you save, on the left side navigation of https://beancount.io/ledger/0/income_statement/ you will see ...

• Journal View: See transactions with search, tags, and filtering
• Account Filter Dropdown: See running balances and per-account entries
• Income Statement: Sum of your Income:* and Expenses:* accounts
• Balance Sheet: Your assets minus liabilities

Fava helps turn your raw Beancount entries into actionable reports—with zero database setup.

💡 Common Journal Entry Examples​

✅ You get paid by a client​

2024-06-05 * "Payment for invoice #456"
  Assets:Bank:Checking     1,200.00 USD
  Income:Consulting

Optional: If you use Accounts Receivable:

2024-05-20 * "Invoice #456 sent"
  Assets:AccountsReceivable   1,200.00 USD
  Income:Consulting

2024-06-05 * "Payment for invoice #456"
  Assets:Bank:Checking        1,200.00 USD
  Assets:AccountsReceivable  -1,200.00 USD

🖨️ You buy office supplies​

2024-06-07 * "Staples run"
  Expenses:OfficeSupplies     85.00 USD
  Assets:Bank:Checking

🏦 You make a loan payment​

Let’s say you pay $1,000, with $200 in interest and $800 toward principal:

2024-06-10 * "Loan repayment"
  Liabilities:Loan           -800.00 USD
  Expenses:LoanInterest       200.00 USD
  Assets:Bank:Checking      -1,000.00 USD

🔒 Closing Entries at Year-End​

To “close the books,” you typically transfer all Income and Expenses accounts into Equity.

2024-12-31 close Income:*
2024-12-31 close Expenses:*

Or, manually:

2024-12-31 * "Close books"
  Equity:RetainedEarnings     45,000.00 USD
  Income:Consulting          -45,000.00 USD

🛠️ Adjusting Entries​

If you're doing accrual accounting, you’ll want to add adjusting entries—for prepaid expenses, accrued revenue, etc.

Example: $100 monthly software subscription paid annually

2024-01-01 * "Annual software payment"
  Assets:Prepaid             1,200.00 USD
  Assets:Bank:Checking      -1,200.00 USD

2024-01-31 * "Monthly amortization"
  Expenses:Software           100.00 USD
  Assets:Prepaid             -100.00 USD

Automate with scripts or available Beancount tools.

🧰 Beancount: Lightweight, Auditable, Powerful​

Beancount isn't just an accounting tool—it's an idea: transparent, plaintext financial truth. It's a modern ledgering system that's:

• Easy to version-control (Git!)
• Fully portable (no proprietary database)
• Great for devs, freelancers, and small businesses

Ready to Start?​

Start your Beancount file with:

option "title" "My Business Ledger"
option "operating_currency" "USD"

2024-01-01 open Assets:Bank:Checking USD
2024-01-01 open Income:Sales USD
2024-01-01 open Expenses:OfficeSupplies USD
2024-01-01 open Equity:OpeningBalances USD

2024-01-01 * "Initial balance"
  Assets:Bank:Checking     10,000.00 USD
  Equity:OpeningBalances

Then load your file with your preferred visualization tool to see the magic.

Want an easier start? Try templates, importers, or community tools like bean-extract.

With Beancount, your books are finally your own—simple, scriptable, and audit-proof.

Let me know if you’d like a downloadable PDF version or small business–specific variations of the examples.

Bookkeeping Basics You Can Actually Understand—and Own​

Managing your own books doesn’t have to mean spreadsheets, stress, or expensive software. Beancount gives you a minimalist, auditable, and powerful way to do bookkeeping using just plain text and a double-entry accounting system.

This guide is your complete introduction to getting your small business books in order with Beancount—with real examples and step-by-step direction.

🧾 What Is Beancount?​

Beancount is an open-source plain-text accounting system built around double-entry bookkeeping. You write your transactions in .beancount files and use tools like bean-doctor, bean-report, or Fava to analyze and visualize your books.

Here’s a basic transaction:

2025-06-01 * "Client Payment: Invoice #123"
  Assets:Bank:Business:Checking      1,200.00 USD
  Income:Consulting                 -1,200.00 USD

It's readable, scriptable, and version-controllable—perfect for business owners who want transparency and control.

📌 Why Bookkeeping Matters (and Why Beancount)​

• You need it for taxes
• You need it for clarity
• You need it for funding
• You need it to catch mistakes early

And with Beancount, you can do all of this with just a text editor and a few tools.

🪜 8 Steps to Start Doing Your Own Bookkeeping with Beancount​

1. Separate Business & Personal Finances​

Open a separate business checking account and credit card. Reflect that in Beancount:

2025-06-01 open Assets:Bank:Business:Checking USD
2025-06-01 open Liabilities:CreditCard:Business USD

This keeps your books clean and protects you legally (especially if you're an LLC or corporation).

2. Use Double-Entry Bookkeeping​

Every financial event affects two accounts. Beancount forces this balance by design:

2025-06-05 * "Web hosting payment"
  Expenses:Hosting                  15.00 USD
  Assets:Bank:Business:Checking    -15.00 USD

This guarantees mathematical integrity across your ledger.

3. Choose Cash or Accrual Basis​

• Cash Basis: Only record income/expenses when money is received/spent.
• Accrual Basis: Track obligations (Accounts Payable/Receivable).

Cash basis example:

2025-06-10 * "Client payment received"
  Assets:Bank:Business:Checking     800.00 USD
  Income:Sales                     -800.00 USD

Accrual basis example (invoice sent, then payment received):

2025-06-01 * "Invoice #2001 issued"
  Assets:AccountsReceivable         800.00 USD
  Income:Sales                     -800.00 USD

2025-06-15 * "Payment received for Invoice #2001"
  Assets:Bank:Business:Checking     800.00 USD
  Assets:AccountsReceivable        -800.00 USD

4. Set Up Your Chart of Accounts​

Define your categories clearly. A minimalist example:

2025-01-01 open Income:Sales USD
2025-01-01 open Expenses:Software USD
2025-01-01 open Expenses:Meals USD
2025-01-01 open Equity:Owner USD

Tailor these to your business. Keep it consistent and descriptive.

5. Categorize Transactions (with Metadata)​

Use metadata to track context. This helps with deductions, audits, and clarity.

2025-06-18 * "Team lunch after Q2 milestone"
  Expenses:Meals                    90.00 USD
  Assets:Bank:Business:Checking    -90.00 USD
  ; business_purpose: Q2 celebration
  ; attendees: Alice, Bob, Tian

Add tags or links to receipts:

  ; receipt: ./receipts/2025-06-18-lunch.jpg

6. Store Supporting Documents​

Use Dropbox, Google Drive, or a receipts/ folder. Then link them in Beancount like:

2025-06-02 * "Domain Renewal - GoDaddy"
  Expenses:Hosting                  20.00 USD
  Assets:Bank:Business:Checking    -20.00 USD
  ; receipt: ./receipts/domain-godaddy.pdf

Auditors and tax professionals will love you.

7. Organize for Deductions​

Mark deductible expenses clearly:

2025-06-03 * "Adobe Creative Cloud Subscription"
  Expenses:Software                60.00 USD
  Assets:Bank:Business:Checking   -60.00 USD
  ; deductible: true
  ; usage: 100% business

Use custom metadata or tags like #deductible to track potential write-offs.

8. Make It a Habit​

Create a workflow. Example:

# Weekly bookkeeping routine
git pull origin main
bean-extract transactions.csv >> ledger.beancount
bean-doctor ledger.beancount
bean-check ledger.beancount
fava ledger.beancount

Or just commit to a "Beancount Friday" and reconcile everything weekly.

💼 DIY or Hire Help?​

You can do it all yourself with Beancount. But even power users should:

• Consult a CPA during setup
• Hire an accountant at tax time if needed
• Use Fava for monthly reports

You get all the power of an accounting system without vendor lock-in or subscription fees.

🛠️ Recommended Tools for Beancount Users​

• Fava – beautiful web dashboard for Beancount files
• bean-doctor – health checks for your ledger
• bean-query – run SQL-like reports
• beancount-import / beanie – automated bank import
• Version control – use Git to track changes to your books

✅ Final Example: Complete Transaction Flow​

2025-06-20 * "Consulting payment from Acme Inc."
  Assets:Bank:Business:Checking        3,000.00 USD
  Income:Consulting                  -3,000.00 USD
  ; invoice: 2025-06-acme
  ; project: "Backend API redesign"

2025-06-21 * "Notion Pro Plan"
  Expenses:Software                     10.00 USD
  Assets:Bank:Business:Checking        -10.00 USD
  ; purpose: project documentation
  ; receipt: ./receipts/notion-june.pdf

🎯 Summary​

Beancount is perfect for small business owners who want to:

• Keep costs low
• Stay fully in control of their finances
• Avoid the bloat of legacy software
• Embrace transparency and plain-text simplicity

Would you like a downloadable .bean starter template for your business? Let me know your business type, and I’ll build one tailored for you.

In today's world, Environmental, Social, and Governance (ESG) metrics are no longer just buzzwords; they're essential indicators of a company's health and future viability. But how do you integrate these crucial sustainability insights with traditional financial accounting? Enter Beancount, an open-source, plain-text double-entry ledger that offers a surprisingly powerful and flexible solution for bridging this gap.

Imagine transforming your fragmented sustainability reporting into a streamlined, automated system that tracks everything from carbon emissions to supplier diversity, all within your existing financial workflow. Beancount makes this possible by treating ESG data as "first-class citizens alongside financial transactions."

Modeling ESG Data: The Beancount Way​

Beancount's inherent flexibility is its superpower when it comes to ESG. Instead of siloed spreadsheets, you can embed sustainability metrics directly into your financial structure using a few key techniques:

• Dedicated Accounts and Commodities: Think of your environmental footprint like another currency. You can create accounts like Metrics:Emissions:CO2e to track carbon emissions. These emissions can even be treated as a commodity (e.g., a unit of CO2 equivalent, tCO2e), allowing you to record specific quantities in your transactions. For instance, a flight purchase could credit an Emissions:CO2e account with +0.3 tCO2e alongside the monetary cost.
• Custom Metadata Tags: Beancount's key-value metadata is perfect for adding context. You can tag a transaction with CO2e: 0.3 t or Scope: 3 to denote its carbon impact or GHG Protocol scope. This links financial outlays directly to their environmental consequences, providing a richer, more complete picture.
• Structured Tags for Categories: Aligning with standards like the Greenhouse Gas Protocol (GHGP) is crucial. You can use consistent tags or account naming conventions, such as Metrics:Emissions:Scope1, Metrics:Emissions:Scope2, and Metrics:Emissions:Scope3 to easily categorize and report on direct, energy-related, and value chain emissions.

This adaptable approach means that as ESG standards evolve, you can adjust your ledger structure without a complete overhaul.

Beancount vs. Specialized ESG Tools: A Strategic Choice​

While dedicated ESG platforms like Persefoni or SAP Green Ledger offer highly automated, purpose-built solutions, Beancount presents a compelling alternative, particularly for those seeking transparency and control.

Beancount is a DIY powerhouse: It gives you unparalleled flexibility and transparency, making it ideal for individuals or technically savvy small organizations. You own your data completely, avoiding vendor lock-in.

Specialized tools offer turnkey solutions: They excel at automated data collection, built-in emission factor databases, and ready-made compliance reports, often at a higher cost and with less flexibility.

A hybrid approach is also viable: use Beancount for detailed internal tracking and reconciliation, then export summary data to an external platform for high-level stakeholder reporting.

Real-World Applications: ESG in Action with Beancount​

Beancount’s versatility makes it suitable for several key ESG use cases:

• Tracking Scope 3 Emissions: The most challenging emissions to track (from your value chain) can be integrated by linking supplier emissions data to purchase transactions. Beancount provides a clear audit trail for these complex figures, enabling better analysis and pinpointing data sources.
• Sustainability Audits and Assurance: Like financial data, ESG figures need to be verifiable. Beancount allows you to link each ESG entry to source documents (e.g., utility bills, third-party verification statements), providing a meticulous audit trail for transparency and assurance.
• EU CSRD/ESRS Compliance Reporting: For companies facing stringent regulations like CSRD, Beancount can serve as a central repository for quantitative disclosures. While it won't automatically format reports into XBRL, it provides the granular, auditable data needed to generate compliance-ready figures.
• Carbon Footprint Analysis & Management Accounting: Treat carbon as another dimension of management accounting. By allocating emissions to profit centers or product codes, you can calculate metrics like "emissions per dollar of revenue" and identify carbon hotspots, driving more informed sustainability decisions.

Best Practices for Your Beancount ESG Ledger​

To maximize the effectiveness of Beancount for ESG, consider these best practices:

1. Design a Clear Chart of Accounts for ESG: Structure your ESG accounts thoughtfully (e.g., Metrics:Emissions:Scope1:Fuel), just like your financial accounts.
2. Use Metadata Consistently: Leverage tags (e.g., Scope: 3, FactorSource: EPA2024) for consistent context and easier querying.
3. Balance Granularity with Manageability: Focus on material metrics to avoid overwhelming your ledger with unnecessary detail.
4. Automate with Caution: Use Python scripts for data import and validation, but ensure robust error checking and clear documentation of your automation processes.
5. Leverage Version Control: Use Git to track every change to your ledger, providing a transparent and auditable history of your ESG data.
6. Connect to Documents and Evidence: Link source files (e.g., PDFs of utility bills) to ledger entries for easy verification during audits.
7. Utilize Fava for Insights: Configure Fava to display custom ESG charts and reports, making your sustainability data actionable and accessible to non-technical stakeholders.
8. Stay Updated on Standards: ESG reporting is dynamic; be prepared to adapt your Beancount structure as new regulations and frameworks emerge.

The Future is Green, and Plain-Text​

While Beancount currently lacks native ESG intelligence or plug-and-play reporting, its open-source nature presents immense opportunities for enhancement. Community-driven plugins for carbon accounting, standardized ESG ledger templates, and better integration with emission factor APIs could significantly boost its capabilities.

As the corporate world increasingly embraces "green ledgers," Beancount stands ready as a flexible, transparent, and auditable solution. By integrating ESG data with the same rigor as financial data, Beancount empowers organizations to not only meet compliance demands but also drive meaningful sustainability initiatives.

Are you ready to bring your ESG data into the plain-text revolution?

Beancount version 3, released in mid-2024, marks a significant architectural evolution for the popular plain-text accounting tool. While it maintains backward compatibility for user ledger files, the underlying structure and accompanying tools have undergone substantial changes. Here’s a breakdown of what’s new in Beancount v3.

A More Modular and Streamlined Architecture​

The most significant change in Beancount v3 is the move to a more modular ecosystem. Several key functionalities that were previously bundled with the core have been spun off into separate, independent projects. This makes the core of Beancount leaner and allows for more focused development on individual components.

The key components that are now separate packages include:

• beanquery: The powerful SQL-like query tool for your ledger files is now in its own package.
• beangulp: This is the new home for the data importing framework, replacing the former beancount.ingest module.
• beanprice: A dedicated tool for fetching prices of commodities and stocks.

This separation means that users will need to install these packages in addition to beancount itself to retain the full functionality they were used to in version 2.

Changes to Command-Line Tools and Workflows​

Reflecting the new modular architecture, there are some notable changes to the command-line tools:

• bean-report is gone: This tool has been removed. Users are now encouraged to use bean-query (from the beanquery package) for their reporting needs.
• New Importer Workflow: The bean-extract and bean-identify commands have been removed from the core. The new approach with beangulp is script-based. Users will now create their own Python scripts to handle the importing of data from external sources like bank statements.

Syntax and Feature Enhancements​

While the core accounting principles remain the same, Beancount v3 introduces some welcome flexibility to its syntax:

• More Flexible Currency Codes: The previous restrictions on the length and characters for currency names have been relaxed. Single-character currency symbols are now supported.
• Expanded Transaction Flags: Users can now use any capital letter from A to Z as a flag for transactions, allowing for more granular categorization.

Importantly, these changes are backward-compatible, so your existing Beancount v2 ledger files will work without any modifications.

The C++ Rewrite and Performance​

One of the long-term goals for Beancount has been a rewrite of its performance-critical components in C++. While this work is ongoing, the initial release of Beancount v3 does not include the C++-based core. This means that for now, the performance of v3 is comparable to v2. The C++ code remains in a separate development branch for future integration.

Migrating from v2 to v3​

For most users, the migration from Beancount v2 to v3 is relatively straightforward:

1. Ledger Files: No changes are needed for your .beancount files.
2. Installation: You will need to install the new, separate packages like beanquery and beangulp using pip.
3. Importer Scripts: If you have custom importers, you will need to update them to use the new beangulp API. This mainly involves changing the base class your importers inherit from and adjusting some method signatures.
4. Fava: The popular web interface for Beancount, Fava, has been updated to be compatible with v3. Ensure you have the latest version of Fava for a seamless experience.

In essence, Beancount v3 is a foundational release that streamlines the project's architecture, making it more modular and easier to maintain and extend in the long run. While it requires some adjustments to user workflows, especially around data importing, it sets the stage for the future development of this powerful accounting tool.

Financial technology company Puzzle.io offers an accounting platform driven by artificial intelligence. Positioned as an "AI-native" system, it aims to provide an alternative to traditional bookkeeping software. The company states its mission is to "build the next generation of accounting software – a system of financial intelligence that helps founders make better business decisions." Puzzle.io targets startup founders, finance teams, and accounting firms, focusing on delivering real-time financial insights and automation.

Enterprise Accounting Challenges Addressed​

Puzzle.io utilizes AI and conversational technologies to address several common challenges in enterprise finance and operations:

• Automation of Repetitive Accounting Tasks: The platform seeks to automate tasks such as transaction categorization, reconciliations, data entry, and validation. Puzzle.io reports its AI can automatically categorize approximately 90% of transactions, aiming to reduce manual effort and errors, allowing accounting professionals to focus on analytical and strategic work.
• Real-Time Financial Insights and Decision Support: Addressing delays associated with traditional month-end close processes, Puzzle.io provides real-time data and instant financial statements. Its general ledger updates continuously from integrated banking and fintech tools. This allows users to access up-to-date dashboards on metrics like cash flow and burn rate. The system also includes monitoring for financial anomalies.
• Employee Support via Conversational Interfaces: Puzzle.io integrates with chat platforms like Slack, enabling employees to query financial information and handle accounting tasks through a conversational assistant. A case study indicated a partner company developed an AI-powered Slackbot using Puzzle.io’s APIs, allowing users to ask for data like current cash balances directly in Slack.
• Enhanced Collaboration and Client Service: The platform incorporates communication tools within the accounting workflow, allowing users to tag colleagues or clients on specific transactions. An "AI Categorizer" feature is designed to help accountants obtain faster client responses by formulating simple questions about transactions.
• Compliance and Knowledge Management: Puzzle.io’s AI is intended to support compliance by focusing on data completeness and accuracy. It uses natural language processing (NLP) to ingest and interpret unstructured data from documents like PDFs and invoices, extracting relevant information. The platform features anomaly detection and a month-end review report highlighting potential inconsistencies. It maintains an immutable, append-only ledger as an audit trail.

AI-Powered Features and Conversational Capabilities​

Puzzle.io's platform incorporates several AI-driven features:

• AI-Native General Ledger: The general ledger is described as being "rebuilt from scratch." It ingests data from various sources and uses algorithms for automatic posting of entries. AI-Powered Categorization learns from historical data, with a reported accuracy of up to 95% that improves over time. Anomaly detection is also a feature.
• Natural Language Processing (NLP) for Accounting Data: The platform utilizes LLMs and NLP for interpreting financial information. This includes "Document and Receipt Understanding," where the system extracts data from PDFs and statements. NLP is also applied to transaction categorization by understanding descriptions and memos. The AI can also generate natural language queries for users when more information is needed.
• Conversational Interface and Chatbot Integration: Puzzle.io’s APIs allow integration with chat platforms. The aforementioned Slackbot built by partner Central allows users to query financial data and resolve bookkeeping tasks conversationally. Users have described this as having "an entire accounting back office based in Slack."
• Use of ChatGPT and Large Language Models: The Slack-based accounting assistant mentioned in the Central case study was built "using ChatGPT and Puzzle." LLMs like ChatGPT are indicated to handle natural language understanding and response generation, while Puzzle.io provides the financial data and executes accounting actions. The company's CEO noted that advancements like GPT-4 passing the CPA exam were an "inflection point" for the platform's development.
• Real-Time Integrations and APIs: The platform integrates with various fintech and enterprise tools (e.g., Stripe, Gusto, Rippling) through real-time APIs. It also offers an Embedded Accounting API for developers to incorporate accounting automation into their own applications, as demonstrated by Central.
• Human-in-the-Loop Controls: AI-generated categorizations and statements can be reviewed by human accountants. Items categorized by AI are tagged for review, and feedback is used to train the AI. A month-end "AI review" report flags anomalies for human attention.

Use Cases and Industry Applications​

Puzzle.io's solutions have been applied in several enterprise contexts:

• Finance & Accounting Departments: The platform is used to reduce time spent on monthly close and transaction processing. Accounting firms using Puzzle.io have reported time savings of about 25% on month-end close for startup clients.
• All-in-One Back-Office Platforms: Central, an HR/fintech startup, partnered with Puzzle.io to power the accounting component of its unified platform for payroll, benefits, compliance, and bookkeeping. This integration enables bookkeeping tasks to be handled via a Slack assistant alongside HR tasks.
• IT and Employee Support (Finance Chatbot as a Service): Similar to IT support chatbots, a Puzzle.io-powered chat assistant can field finance-related employee queries (e.g., expense policies, invoice status) in platforms like Microsoft Teams or Slack.
• Industry-Specific Financial Automation: The platform can compute startup-specific metrics (e.g., ARR, MRR) and handle multiple accounting bases. Professional services firms can use it for auto-categorizing expenses by project or client.

Comparison with Competing AI Chat Solutions​

Puzzle.io focuses specifically on accounting and finance, differentiating it from broader enterprise AI solutions. Here's a brief comparison:

Comparative Perspective: Puzzle.io's specialization is in finance, offering domain-specific accounting intelligence. Platforms like Moveworks, Forethought, and Aisera address broader support scenarios across IT, HR, and customer service. While all leverage advanced AI including LLMs, Puzzle.io applies it to automate accounting workflows, whereas the others generally focus on automating support interactions or customer service. These solutions could be complementary within an enterprise.

Puzzle.io’s AI Stack and Technical Architecture​

Puzzle.io's technical foundation includes:

• Rebuilt Accounting Core: The platform uses an immutable, append-only ledger system designed for audit trails and AI processing, enabling real-time analysis.
• Multiple AI Models for Accuracy: According to Puzzle.io's CEO, Sasha Orloff, "different machine learning models and AI models for different competence levels" are used. This includes models for classification, anomaly detection, and a two-stage generative and validation process for financial statements.
• Natural Language and LLM Integration: LLMs are integrated for tasks like parsing textual data and powering conversational interfaces (e.g., ChatGPT in Slack). The company has indicated that LLM advancements were key to its development. Data is likely managed to ensure privacy and accuracy when interacting with general-purpose language models.
• API-Centric and Microservices Design: The platform appears to use a microservices architecture with features accessible via APIs, such as its "Embedded Accounting API." It is described as "an event driven system, trained on strict accounting standards," suggesting real-time processing of transaction events.
• Security and Data Privacy Measures: Puzzle.io emphasizes "data security, accuracy, auditability and product transparency." This likely involves data encryption, access controls, and secure practices for handling sensitive financial data, especially when interacting with external AI models. The append-only ledger also supports auditability and explainability.

In summary, Puzzle.io applies AI and chat technology to enterprise accounting with a focus on automation, real-time insights, and enhanced collaboration. Its architecture is built around an AI-native general ledger, NLP, and integrations, with human oversight mechanisms.

Why the humble budget morphs into multi-currency treasury as an organisation grows

Personal-finance apps promise seven core jobs: seeing everything in one place, budgeting, tracking income and spend, paying debt, saving for big purchases, managing money with a partner and monitoring investments. The same needs re-appear in business—then multiply as head-count, regulators and investors enter the picture.

Micro & small businesses (solo-founder → ±50 employees)​

Extra jobs unique to small firms

• Payroll & benefits compliance (accurate, on-time filings).
• Sales-tax / VAT collection & remittance across states or countries.
• Basic risk cover (liability, cyber, key-person insurance).

Lower- & mid-market companies (≈ 50 – 500 employees, often multi-entity)​

• Department-level budgets plus rolling forecasts for FP&A.
• 13-week and 12-month cash-flow forecasting to protect covenant headroom ([eventusag.com][3]).
• Debt & equity portfolio management (term loans, venture debt, cap-table dilution).
• Multi-entity consolidation—inter-company eliminations and live FX re-measurement ([picus-capital.medium.com][4]).
• Internal controls & audit readiness (segregation of duties, SOX-lite).
• Vendor procurement & contract lifecycle monitoring.
• KPI dashboards for investors and lenders (EBITDA, ARR, DSO, working-capital days).

Large enterprise & global groups (500 + employees)​

Key take-aways for product builders​

• Same instincts, bigger stage – “show me everything” grows from a Mint-style dashboard into multi-ledger consolidation and treasury views.
• Cash is king at every tier – but the tooling jumps from spreadsheets to dedicated forecasting engines.
• Compliance balloons – payroll, tax, audit and ESG appear only in business contexts and dominate enterprise workloads.
• Stakeholders multiply – individuals coordinate with a partner; businesses juggle employees, suppliers, bankers, investors and regulators.

Understanding where a customer sits on this growth curve lets you prioritise features that move the needle—whether that’s instant cash-flow visibility for a café owner or cross-border liquidity pooling for a multinational.

Modern finance teams typically dedicate 65% of their time to manual reconciliation and data validation, according to McKinsey's 2023 research. At Beancount.io, we're witnessing teams slash their weekly review time from 5 hours to just 1 hour through AI-assisted workflows, while maintaining rigorous accuracy standards.

Plain text accounting already offers transparency and version control. By integrating advanced AI capabilities, we're eliminating tedious transaction matching, discrepancy hunting, and manual categorization that traditionally burden reconciliation processes.

Let's explore how organizations achieve substantial time savings through AI-powered reconciliation, examining technical foundations, real implementation stories, and practical guidance for transitioning to automated workflows.

The Hidden Cost of Manual Reconciliation​

Manual reconciliation resembles solving a puzzle with scattered pieces. Each transaction demands attention, discrepancies require investigation, and the process consumes valuable time. The Institute of Financial Operations and Leadership reports that 60% of accounting professionals spend over half their week on manual reconciliation.

This creates a cascade of challenges beyond just lost time. Teams face mental fatigue from repetitive tasks, increasing error risks under pressure. Even minor mistakes can propagate through financial reports. Additionally, outdated processes hamper collaboration as teams struggle to maintain consistent records across departments.

Consider a mid-sized tech firm whose monthly close dragged on for weeks due to manual reconciliation. Their finance team was perpetually verifying transactions across platforms, leaving minimal bandwidth for strategic work. After adopting automation, we saw reconciliation time drop by roughly 70%, allowing more focus on growth initiatives.

How AI + Plain Text Transform Bank Statement Matching​

AI algorithms analyze transaction patterns within plain text accounting systems, automatically proposing matches between bank statements and accounting records. Natural language processing enables AI to interpret unstructured bank statement data - for example, recognizing "AMZN Mktp US" as an Amazon Marketplace purchase.

Here's a real-world example of how AI assists with bank statement matching in Beancount:

# Original bank statement entry:
# "AMZN Mktp US*IF8QX0QS3" -29.99 USD

# AI-suggested Beancount transaction:
2025-05-20 * "Amazon" "Office supplies - keyboard wrist rest"
  Expenses:Office:Supplies            29.99 USD
  Assets:Bank:Checking              -29.99 USD
  
# Original bank statement entry:
# "UBER *TRIP HELP.UBER.COM" -24.50 USD

# AI-suggested Beancount transaction:
2025-05-21 * "Uber" "Client meeting transportation"
  Expenses:Transportation:Taxi       24.50 USD
  Assets:Bank:Checking             -24.50 USD

The AI system:

1. Recognizes common merchant patterns (e.g., "AMZN Mktp US*" → "Amazon")
2. Suggests appropriate account categories based on transaction history
3. Extracts meaningful descriptions from transaction data
4. Maintains proper double-entry format
5. Tags business-related expenses automatically

For more complex scenarios, like split payments or recurring transactions, the AI excels at pattern recognition:

# Original bank statement entries:
# "POPEYES #1234" -80.00 USD
# "ALICE SMITH" +20.00 USD
# "BOB JONES" +20.00 USD
# "CHARLIE BROWN" +20.00 USD

# AI-suggested Beancount transaction with split payments:
2025-05-22 * "Popeyes" "Team lunch - split with Alice, Bob, and Charlie"
  Expenses:Food                      20.00 USD
  Assets:Receivables:Alice          20.00 USD
  Assets:Receivables:Bob            20.00 USD
  Assets:Receivables:Charlie        20.00 USD
  Liabilities:CreditCard           -80.00 USD

# AI automatically reconciles repayments:
2025-05-23 * "Alice Smith" "Team lunch repayment"
  Assets:Bank:Checking              20.00 USD
  Assets:Receivables:Alice         -20.00 USD

2025-05-23 * "Bob Jones" "Team lunch repayment"
  Assets:Bank:Checking              20.00 USD
  Assets:Receivables:Bob           -20.00 USD

2025-05-23 * "Charlie Brown" "Team lunch repayment"
  Assets:Bank:Checking              20.00 USD
  Assets:Receivables:Charlie       -20.00 USD

FinTech Insights reports that 70% of finance professionals experienced significant error reduction using AI-driven tools. The plain text format enhances this efficiency by enabling easy version control and auditing while remaining highly compatible with AI processing.

Real-World Results from Beancount.io Teams​

A mid-sized accounting firm previously spent five hours reconciling each client account manually. After implementing AI-powered plain text accounting, they completed the same work in one hour. Their financial controller noted, "The system catches discrepancies we might have missed while freeing us to focus on analysis."

A fast-growing tech startup faced mounting transaction volumes that threatened to overwhelm their finance team. After adopting AI reconciliation, processing time fell by around 75%, allowing resources to be redirected toward strategic planning.

From our firsthand experience, AI-driven accounting solutions lead to significantly fewer errors, thanks to robust automated detection and correction features.

Implementation Guide for Automated Reconciliation​

Start by selecting AI tools that integrate smoothly with Beancount.io, such as OpenAI's GPT models or Google's BERT. Prepare your data by standardizing transaction formats and categories – in our experience, proper data standardization greatly improves AI performance.

Develop automation scripts leveraging Beancount's flexibility to identify discrepancies and cross-reference data. Train AI models specifically for anomaly detection to catch subtle patterns human reviewers might miss, like recurring late payments that could indicate systemic issues.

Establish regular performance reviews and feedback loops with your team. This iterative approach helps the AI system learn from experience while building trust in the automated process.

Beyond Time Savings: Enhanced Accuracy and Audit-Readiness​

AI reconciliation minimizes human error through automated cross-verification. Deloitte's research shows companies using AI for financial processes achieve 70% fewer accounting discrepancies. The system maintains detailed audit trails, making it easier for auditors to verify transactions.

A technology company struggling with frequent reconciliation errors saw audit costs decrease after implementing AI tools. The system's continuous learning capabilities meant accuracy improved over time as it processed more transactions.

Conclusion​

AI-powered reconciliation fundamentally transforms financial operations, offering both efficiency gains and enhanced accuracy. Organizations using Beancount.io demonstrate that automated workflows reduce reconciliation time while strengthening data integrity.

As financial complexity increases, manual reconciliation becomes increasingly unsustainable. Organizations that embrace AI-powered plain text accounting gain advantages in speed, accuracy, and strategic capability.

Consider starting with a single account in Beancount.io to experience how modern tooling can enhance your financial workflows.