78 posts tagged with "accounting"

Hello everyone! In today's blog post, we're diving into the world of Beancount, a double-entry accounting tool that's loved by many for its simplicity and power. More specifically, we're going to talk about two key concepts: Receivables and Payables.

Understanding these terms is crucial to using Beancount (or any double-entry accounting system) effectively. But don't worry if you're a beginner - we're going to break it all down, step by step!

Receivables and Payables: The Basics​

In accounting, "receivables" and "payables" are terms used to track money that is owed. "Receivables" refers to money that others owe to you, while "payables" refers to money that you owe to others.

Let's take an example:

1. Accounts Receivable (A/R): Suppose you own a bookstore and a customer buys a book on credit. The money they owe you for the book is an account receivable.

2. Accounts Payable (A/P): On the flip side, imagine you order a new set of books from a publisher, but you don't pay for them upfront. The money you owe the publisher is an account payable.

In Beancount, these are typically tracked through corresponding accounts. The main benefit here is that it provides you with a clear and accurate picture of your financial position at any point in time.

Setting Up Receivables and Payables in Beancount​

The structure of your Beancount file can be as simple or as complex as you need it to be. For receivables and payables, you'll likely want to create separate accounts under your Assets and Liabilities sections.

Here is a simple example:

1970-01-01 open Assets:AccountsReceivable
1970-01-01 open Liabilities:AccountsPayable

Tracking Transactions​

Payee side​

After setting up your accounts, you can track transactions that involve receivables and payables. Let's look at an example:

2023-05-29 * "Sold books to customer on credit"
  Assets:AccountsReceivable  100 USD
  Income:BookSales          -100 USD

Here, you're adding $100 to your receivables because a customer owes you this amount. Simultaneously, you're reducing your income by the same amount to maintain the balance (since you haven't actually received the money yet).

When the customer eventually pays, you'll record it like this:

2023-06-01 * "Received payment from customer"
  Assets:Bank:Savings        100 USD
  Assets:AccountsReceivable -100 USD

Payer side​

The same principle applies for payables, but with reversed signs:

2023-05-30 * "Bought books from publisher on credit"
  Liabilities:AccountsPayable  200 USD
  Expenses:BookPurchases     -200 USD

And when you pay off your debt:

2023-06-02 * "Paid off debt to publisher"
  Liabilities:AccountsPayable -200 USD
  Assets:Bank:Checking        200 USD

Wrapping Up​

Receivables and payables are at the heart of any accounting system. By accurately tracking these, you gain a comprehensive understanding of your financial health.

This is just a starting point, and Beancount is capable of much more. I hope this blog post helps clarify these important concepts. As always, happy accounting!

In today's blog post, we will be breaking down a Beancount ledger for businesses, which will help you understand the intricacies of this plain text double-entry accounting system.

Let's start with the code first:

1970-01-01 open Assets:Bank:Mercury
1970-01-01 open Assets:Crypto

1970-01-01 open Equity:Bank:Chase

1970-01-01 open Income:Stripe
1970-01-01 open Income:Crypto:ETH

1970-01-01 open Expenses:COGS
1970-01-01 open Expenses:COGS:Contabo
1970-01-01 open Expenses:COGS:AmazonWebServices

1970-01-01 open Expenses:BusinessExpenses
1970-01-01 open Expenses:BusinessExpenses:ChatGPT

2023-05-14 * "CONTABO.COM" "Mercury Checking ••1234"
  Expenses:COGS:Contabo                               17.49 USD
  Assets:Bank:Mercury                                -17.49 USD

2023-05-11 * "Amazon Web Services" "Mercury Checking ••1234"
  Expenses:COGS:AmazonWebServices                  14490.33 USD
  Assets:Bank:Mercury                             -14490.33 USD

2023-03-01 * "STRIPE" "Mercury Checking ••1234"
  Income:Stripe                                   -21230.75 USD
  Assets:Bank:Mercury                              21230.75 USD

2023-05-18 * "customer_182734" "0x5190E84918FD67706A9DFDb337d5744dF4EE5f3f"
  Assets:Crypto                                         -19 ETH {1,856.20 USD}
  Income:Crypto:ETH                                      19 ETH @@ 35267.8 USD

Understanding the Code​

1. Opening Accounts: The code starts by opening a series of accounts on 1970-01-01. These include a mix of asset accounts (Assets:Bank:Mercury and Assets:Crypto), an equity account (Equity:Bank:Chase), income accounts (Income:Stripe and Income:Crypto:ETH), and expense accounts (Expenses:COGS, Expenses:COGS:AmazonWebServices, Expenses:BusinessExpenses, and Expenses:BusinessExpenses:ChatGPT).

2. Transactions: It then progresses to record a series of transactions between 2023-03-01 and 2023-05-18.

   • The transaction on 2023-05-14 represents a payment of $17.49 to CONTABO.COM from Mercury Checking ••1234. This is recorded as an expense (Expenses:COGS:Contabo) and a corresponding deduction from the Assets:Bank:Mercury account.

   • Similarly, the transaction on 2023-05-11 represents a payment of $14490.33 to Amazon Web Services from the same bank account. This is logged under Expenses:COGS:AmazonWebServices.

   • The transaction on 2023-03-01 shows income from STRIPE being deposited into Mercury Checking ••1234, totaling $21230.75. This is recorded as income (Income:Stripe) and an addition to the bank account (Assets:Bank:Mercury).

   • The last transaction on 2023-05-18 represents a crypto transaction involving 19 ETH from a customer. This is tracked under Assets:Crypto and Income:Crypto:ETH. The {1,856.20 USD} shows the price of ETH at the time of transaction, while the @@ 35267.8 USD specifies the total value of the 19 ETH transaction.

In all transactions, the principle of double-entry accounting is maintained, ensuring that the equation Assets = Liabilities + Equity always holds true.

Final Thoughts​

This Beancount ledger provides a straightforward yet robust system for tracking financial transactions. As seen in the final transaction, Beancount is flexible enough to account for non-traditional assets like cryptocurrency, which is a testament to its utility in our increasingly digital financial landscape.

We hope this breakdown helps you better understand the structure and capabilities of Beancount, whether you're a seasoned accountant or a beginner trying to keep track of your personal finances. Stay tuned for our next blog post, where we'll delve further into advanced Beancount operations.

We are thrilled to announce that as of May 1st, 2023, we will be reintroducing the free plan for new customers. This decision comes after making significant improvements to our platform and optimizing our resources in order to better serve all of our customers, both free and paid.

The free plan has always been an essential part of our vision to provide an accessible and user-friendly service for everyone. We believe that the changes we've made over the past months will allow us to deliver an even better experience for our users while maintaining the quality of service for our Pro plan customers.

New customers who register after May 1st, 2023, will have access to the Free plan.

Your support and loyalty have been instrumental in making this reintroduction of the free plan financially possible. It is through your contributions that we have been able to invest in our infrastructure and support systems, ensuring that we can continue to deliver the high-quality service you expect while also expanding access to our platform for new users. Your commitment to our vision has helped us grow and evolve, and we are truly grateful for your ongoing partnership. Together, we are building a thriving community and empowering users from all walks of life to achieve their goals.

If you have any questions or concerns, please don't hesitate to reach out to us. We are always here to listen to your feedback and address any issues you may have. Thank you for your continued support, and we look forward to providing you with the best service possible.

Example Account Name​

Assets:US:BofA:Checking

Account Types​

Assets          +
Liabilities     -
Income          -
Expenses        +
Equity          -

Commodities​

CNY, EUR, CAD, AUD
GOOG, AAPL, RBF1005
HOME_MAYST, AIRMILES
HOURS

Directives​

General syntax

YYYY-MM-DD <Directive> <Parameters...>

Opening & Closing Accounts​

2001-05-29 open Expenses:Restaurant
2001-05-29 open Assets:Checking     USD,EUR  ; Currency constraints

2015-04-23 close Assets:Checking

Declaring Commodities (Optional)​

1998-07-22 commodity AAPL
  name: "Apple Computer Inc."

Prices​

2015-04-30 price AAPL   125.15 CNY
2015-05-30 price AAPL   130.28 CNY

Notes​

2013-03-20 note Assets:Checking "Called to ask about rebate"

Documents​

2013-03-20 document Assets:Checking "path/to/statement.pdf"

Transactions​

2015-05-30 * "Some narration about this transaction"
  Liabilities:CreditCard   -101.23 CNY
  Expenses:Restaurant       101.23 CNY

2015-05-30 ! "Cable Co" "Phone Bill" #tag ˆlink
  id: "TW378743437"               ; Meta-data
  Expenses:Home:Phone  87.45 CNY
  Assets:Checking                 ; You may leave one amount out

Postings​

  ...    123.45 USD                             Simple
  ...        10 GOOG {502.12 USD}               With per-unit cost
  ...        10 GOOG {{5021.20 USD}}            With total cost
  ...        10 GOOG {502.12 # 9.95 USD}        With both costs
  ...   1000.00 USD   @ 1.10 CAD                With per-unit price
  ...        10 GOOG {502.12 USD} @ 1.10 CAD    With cost & price
  ...        10 GOOG {502.12 USD, 2014-05-12}   With date
  ! ...   123.45 USD ...                        With flag

Balance Assertions and Padding​

; Asserts the amount for only the given currency:
2015-06-01 balance Liabilities:CreditCard  -634.30 CNY

; Automatic insertion of transaction to fulfill the following assertion:
2015-06-01pad Assets:Checking Equity:Opening-Balances

Events​

2015-06-01 event "location" "New York, USA"
2015-06-30 event "address" "123 May Street"

Options​

option "title" "My Personal Ledger"

Other​

pushtag #trip-to-peru
...
poptag  #trip-to-peru
; Comments begin with a semi-colon

Discover the Magic of Plain Text Accounting with Beancount

Introduction​

Welcome to a world where accounting is no longer a daunting task. Today, we introduce you to Beancount, a powerful, flexible, and intuitive plain text accounting tool. Beancount empowers you to take control of your finances by providing a transparent and straightforward approach to managing your money.

In this comprehensive guide, we will delve into the basics of Beancount, explain its core concepts, and walk you through its simple yet powerful features. By the end of this blog, you'll have a solid understanding of Beancount and be ready to start using it to organize and analyze your financial life.

What is Beancount?​

Beancount is an open-source, plain text accounting system created by Martin Blais. Inspired by John Wiegley's Ledger system, Beancount aims to provide a robust and reliable method to manage personal and small business finances using plain text files. With Beancount, you can track your income, expenses, investments, and much more with ease.

Why Beancount?​

Plain text accounting offers several advantages over traditional spreadsheet-based or software-based accounting systems:

• Transparency: Beancount files are human-readable, making it easy to understand and audit your financial data.
• Flexibility: Beancount can be easily customized to fit your specific needs, and you can use your favorite text editor and version control system to manage your financial data.
• Portability: Your financial data can be accessed on any device, and it's easy to transfer between systems or share with others.
• Future-proof: Plain text files are universally compatible, ensuring that your financial data will remain accessible, even as technology evolves.

Beancount's Core Concepts​

To use Beancount effectively, it's crucial to understand its core concepts:

• Transactions: Financial events, such as income, expenses, or transfers between accounts, are recorded as transactions.
• Accounts: Transactions involve one or more accounts, such as assets, liabilities, income, or expenses.
• Double-entry bookkeeping: Beancount enforces double-entry bookkeeping, ensuring that every transaction has balanced debits and credits.
• Directives: Beancount uses a set of directives to define transactions, account openings, and other financial events.

Getting Started with Beancount​

To start using Beancount, follow these simple steps:

• Install Beancount: Install Beancount on your system using the provided installation instructions for your operating system.
• Create your Beancount file: Create a new plain text file with the .beancount extension (e.g., my_finances.beancount).
• Define your accounts: Use the "open" directive to define the accounts you'll use in your transactions.
• Record transactions: Use the "txn" directive to record your financial transactions.

Or simply sign up at https://beancount.io. Here are some plain text accounting examples -

Example 1: Basic Transaction

2023-04-01 open Assets:Checking
2023-04-01 open Expenses:Groceries

2023-04-10 txn "Grocery Store" "Buying groceries"
  Assets:Checking         -50.00 USD
  Expenses:Groceries       50.00 USD

In this example, we open two accounts, Assets:Checking and Expenses:Groceries. On April 10, 2023, we record a transaction for buying groceries worth $50. The transaction reduces the balance of Assets:Checking by$50 (debit) and increases the balance of Expenses:Groceries by $50 (credit).

Example 2: Income and Expense Transaction

2023-04-01 open Assets:Checking
2023-04-01 open Income:Salary
2023-04-01 open Expenses:Rent

2023-04-05 txn "Employer" "Salary payment"
  Assets:Checking       2000.00 USD
  Income:Salary        -2000.00 USD

2023-04-06 txn "Landlord" "Monthly rent payment"
  Assets:Checking       -1000.00 USD
  Expenses:Rent          1000.00 USD

In this example, we open three accounts: Assets:Checking, Income:Salary, and Expenses:Rent. On April 5, 2023, we record a salary payment transaction of $2000. The transaction increases the balance of Assets:Checking by$2000 (credit) and decreases the balance of Income:Salary by $2000 (debit). On April 6, 2023, we record a rent payment transaction of$1000. The transaction reduces the balance of Assets:Checking by $1000 (debit) and increases the balance of Expenses:Rent by$1000 (credit).

Example 3: Transfer Between Accounts

2023-04-01 open Assets:Checking
2023-04-01 open Assets:Savings

2023-04-15 txn "Bank" "Transfer from Checking to Savings"
  Assets:Checking       -500.00 USD
  Assets:Savings         500.00 USD

In this example, we open two accounts: Assets:Checking and Assets:Savings. On April 15, 2023, we record a transaction to transfer $500 from the checking account to the savings account. The transaction reduces the balance of Assets:Checking by$500 (debit) and increases the balance of Assets:Savings by $500 (credit).

These examples illustrate the basic concepts of Beancount's double-entry bookkeeping system. By properly recording transactions, users can maintain accurate records of their financial activities and generate reports to gain insights into their financial situation.

Generating Reports and Analyzing Data​

Beancount comes with a set of powerful tools for generating financial reports, including balance sheets, income statements, and more. You can also use Fava, a web-based user interface for Beancount, to visualize and interact with your financial data. https://beancount.io is built upon Fava with MIT license.

Conclusion​

Embrace the power and simplicity of plain text accounting with Beancount. By understanding its core concepts and following the steps outlined in this guide, you'll be well on your way to managing your personal or small business finances with ease and precision. As you grow more comfortable with Beancount, you can explore advanced features and customizations to tailor the system to your unique needs.

Whether you're looking to track your spending, plan for the future, or gain insights into your financial habits, Beancount offers the flexibility and transparency needed to achieve your goals. With its user-friendly approach, Beancount has the potential to revolutionize the way you manage your finances and empower you to take control of your financial future.

Now that you have a solid foundation in Beancount, it's time to embark on your plain text accounting journey. Say goodbye to cumbersome spreadsheets and convoluted software, and welcome the world of Beancount. Happy accounting!

Beancount, the double-entry accounting system beloved by developers and finance nerds alike, is powerful in its simplicity. But for those who want more control and faster navigation inside Fava, Beancount’s web interface, custom sidebar links and SQL queries can take your workflow to the next level.

In this guide, we’ll show you how to:

• Add quick-access links to Fava’s sidebar
• Use SQL queries for advanced filtering and analysis
• Customize your workflow for monthly reviews or anomaly detection

Why Customize Fava?​

Fava is already a beautiful interface for viewing your Beancount ledger, but as your journal grows, so does the need for better shortcuts and smarter queries.

Pain points this solves:​

• Navigating through time ranges repeatedly
• Filtering transactions across nested accounts
• Spotting negative balances or anomalies faster

✨ Custom Sidebar Links​

Let’s start with improving your daily workflow with simple sidebar shortcuts. These links appear in Fava’s left sidebar and can take you directly to filtered views like this month’s transactions or last month’s income.

Add these lines to your Beancount file:

2021-01-01 custom "fava-sidebar-link" "Current Month" "/jump?time=month"
2021-01-01 custom "fava-sidebar-link" "Last Month" "/jump?time=month-1"
2021-01-01 custom "fava-sidebar-link" "Clear All" "/jump?account=&time=&filter="

What They Do:​

• Current Month: Opens the transaction view filtered to the current month.
• Last Month: Instantly jumps to the previous month—great for end-of-month reviews.
• Clear All: Resets filters, showing all entries again.

These shortcuts eliminate manual time input and make your Fava experience feel more fluid and personalized.

🔍 Custom SQL Queries​

For deeper insight, Fava’s SQL interface is incredibly powerful. Here’s a query that finds all negative balances in accounts that match a pattern—perfect for flagging unusual or problematic transactions.

SELECT account, units(sum(position)), sum(position)
WHERE number(units(position)) < 0
  AND account ~ '.*:BCM:.*'
  AND date >= DATE(2021,12,9)
  AND date < DATE(2022,1,9)

Breakdown:​

• account ~ '.*:BCM:.*': Filters accounts containing :BCM: in their name.
• number(units(position)) < 0: Flags negative balances (e.g. overspent budgets).
• Date filters narrow the result to a specific 1-month window.

Use cases:​

• Spot errors like duplicate expenses or incorrect postings
• Audit a specific vendor or category
• Quickly extract actionable insights for budgeting

🛠 Pro Tip: Combine Links + Queries​

While Fava doesn’t allow direct links to custom queries, you can create a monthly review habit by:

• Using the “Current Month” link to start your review
• Opening your saved queries tab in another pane
• Reviewing both simultaneously—filter first, then dig deep

This combo helps you catch anomalies before they spiral and ensure your ledger stays clean.

Final Thoughts​

Beancount is minimal by design, but small enhancements like these bring huge gains in efficiency. Whether you’re reviewing your budget, debugging strange balances, or simply saving clicks, custom links and SQL queries give you more power and less friction.

Bonus: If you're using Fava’s custom reports, you can even build full dashboards tailored to your personal finance rituals.

Ready to take control?

Start small: add the “Current Month” link. Then build your own queries. Your future self will thank you.

Want more tips like this? Subscribe to our newsletter or explore more Beancount recipes at Beancount.io.

There is a plugin for beancount to forecast future recurring transactions. How to apply it in beancount.io? Put the following content into your ledger file.

; import the plugin
plugin "fava.plugins.forecast"

; add a monthly HOA fee
2022-05-30 # "HOA fee [MONTHLY]"
  Expenses:Hoa                                      1024.00 USD
  Assets:Checking                                  -1024.00 USD

And then, you will see the forecast in Net Profit chart.

The tag [MONTHLY] above means it will recur forever. If you have more conditions to apply, try [MONTHLY UNTIL 2022-06-01], [MONTHLY REPEAT 5 TIMES], [YEARLY REPEAT 5 TIMES], or [WEEKLY SKIP 1 TIME REPEAT 5 TIMES].

A plain‑text template, a repeatable workflow, and a single query for “Who still owes me?”

Invoicing can feel like a chore, stuck between the work you've finished and the payment you're waiting for. But a good invoice process is the backbone of healthy cash flow. It pulls double duty: it clearly tells your clients what they owe and when, and it feeds your accounting system the unassailable facts it needs.

While dedicated SaaS apps can send slick, automated PDFs, they often come with monthly fees and lock your data in a proprietary silo. A lightweight, plain-text approach using Beancount offers a powerful alternative. You can turn each invoice into a clear set of accounting entries, giving you all the benefits of version control, powerful metadata, and instant querying—no subscription required.

The Minimum Viable Invoice (Fields You Should Never Skip)​

Before you touch your ledger, you need a professional invoice. The format can be simple, but the contents must be precise. These fields, borrowed from time-tested small-business practice, are non-negotiable.

• Seller details: Your business name and physical address.
• Client details: Your client’s name and (ideally) their address.
• Invoice number: A unique, sequential ID that is never reused. INV-045 follows INV-044.
• Issue & due dates: Clearly state when the invoice was issued and when payment is expected.
• Line items: A clear description of services or products, along with quantity, rate, and the line total.
• Subtotal, tax, and total: Show the math so the client can follow it easily.
• Optional notes: A place for a thank you, wiring instructions, or a client-provided purchase order number.

To get you started, we've created a set of ready-to-edit templates that include all these fields. The spreadsheet versions even pre-calculate the totals for you.

Note: Invoice templates are coming soon! In the meantime, you can create your own using the fields listed above in Google Docs, Word, Sheets, Excel, or any other document format.

Record the Invoice in Your Ledger​

Once you've sent the invoice PDF to your client, you must record it in Beancount. This is a crucial step that recognizes the revenue when it's earned, not just when it's paid. The process involves two distinct transactions.

1. When you issue the invoice:

You create a transaction that moves the total amount from your Income account into Assets:AccountsReceivable. This creates a digital IOU in your books.

; 2025‑07‑21 Invoice #045  Web design sprint for Acme Corp.
2025-07-21 * "Acme Corp" "INV-045 Web design sprint"
  Assets:AccountsReceivable          3500.00 USD  ; due:2025-08-04
  Income:Design:Web
  invoice_id: "INV-045"
  contact_email: "[email protected]"
  link: "docs/invoices/2025-07-21_Acme_INV-045.pdf"

Here, you debit AccountsReceivable and credit your Income account. Notice the rich metadata: the due date, a unique invoice_id, and even a direct link: to the PDF you sent.

2. When the client pays:

When the cash hits your bank account, you record a second transaction to "close out" the IOU. This moves the balance from AccountsReceivable to your checking account.

2025-08-01 * "Acme Corp" "Payment INV-045"
  Assets:Bank:Checking               3500.00 USD
  Assets:AccountsReceivable
  invoice_id: "INV-045"

The balance for INV-045 in Assets:AccountsReceivable is now zero, and your books are perfectly balanced.

Attach the PDF: The link: metadata key is especially powerful when used with Fava, Beancount's web interface. Fava will render a clickable link directly in the transaction view, so the source document is never more than a click away. This workflow was envisioned as early as 2016 in a feature request (GitHub).

One Query to List All Open Invoices​

So, who still owes you money? With this system, you don't need to hunt through emails or spreadsheets. You just need one simple query.

Save the following as a file named open-invoices.sql:

SELECT
  meta('invoice_id') AS id,
  payee,
  narration,
  date,
  number(balance) AS outstanding
WHERE
  account = "Assets:AccountsReceivable"
  AND balance != 0
ORDER BY
  date;

Now, run it from your command line:

bean-query books.beancount open-invoices.sql

In seconds, you'll get a clean, up-to-the-minute aging report of all outstanding invoices, showing the invoice ID, client, date issued, and amount owed. No extra software required.

Automate the Busywork​

The beauty of plain text is scriptability. You can automate the tedious parts of this workflow.

• Template + Pandoc = PDF: Maintain your invoice template in Markdown. A tiny Python script can populate the variables (client name, line items, invoice number), and the command-line tool Pandoc can instantly convert it to a professional PDF.
• Git Pre-commit Hook: If you store your ledger in Git, a simple pre-commit hook can run checks before you save your work. It can verify that every new invoice_id is unique, that the transaction postings balance to zero, and that the file referenced in the link: metadata actually exists.
• Cron Job: Set up a scheduled task (a cron job) to run your open-invoices.sql query every night and email you the summary. You'll start each day knowing exactly who needs a friendly nudge.

A Realistic Caveat​

Beancount is an accounting tool, not an invoicing service. It will not automatically send payment reminders to your clients or process their credit card payments. The workflow is: you create and send the invoice using your chosen method (like the templates above), and then you book the accounting entries in your ledger.

For most freelancers and small shops, this manual step is a small price to pay for a bulletproof, auditable, and free accounting system that you completely own and control (beancount.io).

Next Steps​

Ready to take control of your invoicing? Here’s how to start.

1. Download a template and use it to create your next real invoice, making sure to use a sequential invoice number.
2. Store your sent PDFs in a dedicated folder like docs/invoices/ and use the link: metadata key in your Beancount transaction to reference them.
3. Save the open-invoices.sql query and make running it a part of your weekly financial review.

Plain-text accounting doesn’t mean giving up polish or control—it just means the database is grep-able. With a simple template and the snippets above, you’ll get paid faster and keep your books immaculate.

Accounting isn’t finished when the last sale hits the bank. To get a true picture of your business's health, you need to perform a month-end tune-up. At every period close, you'll make adjusting entries—journal tweaks that correctly place revenues and expenses in the proper time window and keep your balance sheet honest.

In a plain‑text Beancount ledger, these crucial entries are transparent, version‑controlled, and easy to audit, turning a tedious task into a clear and repeatable process.

Why Adjusting Entries Matter​

Making these adjustments is fundamental to sound accounting. They ensure your financial statements are accurate and reliable.

• Accrual Accuracy: Adjusting entries are the engine of accrual accounting. They move income and costs into the period they were actually earned or incurred, regardless of when cash changed hands. This satisfies the core revenue-recognition and matching principles that form the foundation of modern accounting (AccountingCoach.com).

• Reliable KPIs: Key performance indicators are only as good as the data behind them. Metrics like gross margin, net income, and cash-flow forecasts only tell the truth once deferrals, accruals, and estimates are properly posted (Corporate Finance Institute).

• Clean Audit Trail: Explicit month‑end adjustments create a clear record of your financial reasoning. This helps auditors (and your future self) easily trace what changed and why, building confidence in your numbers (Accountingverse).

Six Common Categories (with Beancount Snippets)​

Here are the six most common types of adjusting entries, with examples of how to record them in your Beancount ledger. Notice the use of metadata like adj:"accrual" to make these entries easy to find and analyze later.

1. Accrued Revenue​

This is for revenue you've earned but haven't yet billed or received payment for.

2025-07-31 * "Consulting—July hours"
  Assets:AccountsReceivable       12000.00 USD
  Income:Consulting
  ; adj:"accrual" period:"Jul-25"

2. Accrued Expense​

An expense you've incurred but haven't yet paid, like a utility bill that will arrive next month.

2025-07-31 * "Attorney—July retainer"
  Expenses:Legal                  2500.00 USD
  Liabilities:AccruedPayables
  ; adj:"accrual"

3. Deferred (Unearned) Revenue​

This applies when a client pays you in advance. You recognize a portion of that revenue as it's earned over time.

2025-07-31 * "Annual SaaS prepayment (recognize 1/12)"
  Liabilities:UnearnedRevenue       833.33 USD
  Income:SaaS
  ; adj:"deferral"

4. Prepaid (Deferred) Expense​

When you pay for an expense upfront (like an annual insurance policy), you expense a portion of it each month.

2025-07-31 * "Insurance—1 mo. expense from prepaid"
  Expenses:Insurance                400.00 USD
  Assets:PrepaidInsurance
  ; adj:"deferral"

5. Depreciation & Amortization​

This entry allocates the cost of a long-term asset (like a computer or vehicle) over its useful life.

2025-07-31 * "Mac Studio depreciation"
  Expenses:Depreciation           1250.00 USD
  Assets:Computers:AccumDepr
  ; asset_id:"MAC-03" adj:"estimate"

6. Allowance for Doubtful Accounts​

An estimate of accounts receivable that you don't expect to collect, which is recorded as a bad debt expense.

2025-07-31 * "Bad-debt provision (2% of A/R)"
  Expenses:BadDebt                   700.00 USD
  Assets:AllowanceForBadDebt
  ; basis:"A/R" rate:0.02 adj:"estimate"

A Repeatable Workflow​

To keep your month-end close efficient and error-free, adopt a consistent workflow.

• Use a separate file. Keep all adjustments for a period in one place, like adjustments-2025-07.bean. In your main ledger file, use an include directive to import it last. This ensures adjustments are applied just before you generate final reports.

• Standardize your metadata. Always use consistent metadata keys and values, like adj:"accrual|deferral|estimate" and period:"Jul-25". This makes querying and reviewing specific types of adjustments a breeze.

• Run a pre-flight check. Before committing your changes to Git, run bean-check on your adjustments file to catch any typos or unbalanced postings.

• Perform a one-line sanity check. This query confirms that all your adjustments for the period balance out, giving you confidence that you haven't introduced errors.

  bean-query main.bean "SELECT account, SUM(number) WHERE meta('adj') AND meta('period') = 'Jul-25' GROUP BY account"
  

Quick Troubleshooting Tips 🤔​

• Is your Liabilities:UnearnedRevenue balance climbing? Review your contract milestones. You might be recognizing revenue too slowly compared to the work you're delivering.

• Is your Assets:PrepaidInsurance balance negative? You're likely expensing it faster than the asset's schedule allows. Double-check your amortization schedule.

• Is your Days Sales Outstanding (DSO) getting worse after accruals? Your accrued revenue might be masking underlying collection issues. Pair this KPI with an A/R aging report to spot late-paying clients before it becomes a cash-flow problem.

Closing Thoughts​

Adjusting entries can feel tedious, but their value becomes crystal clear when you compare your "before" and "after" income statements—the difference is often material. With Beancount, these adjustments become small, searchable patches that you can automate and review just like code.

Build the month-end habit, and your numbers will stay as accurate as your engineering.

Happy balancing!

Beancounters traditionally use command-line tools or self-host servers with private networks, where they have to operate through a computer or a general-purpose text editor on mobile. Beancount.io reduces hassles by bringing open-sourced Android and iOS mobile apps and a secured cloud so that your ledger is now a few taps away from your fingerprint.

Beancount is a computer language that enables double-entry bookkeeping in text files. Once you define financial transactions in the file, it will generate various reports. Martin Blais, the designer of this language, argues that command-line bookkeeping has many advantages - It is fast, portable, open, and customized.

We strongly agree with the argument and share the feeling of empowerment brought by beancount language. And we wanted to do more - introducing the technology to more people. It means that we have to improve the usability and make it more accessible to a broader audience.

Not everyone is a command-line enthusiast, and this is why we build Beancount.io - the personal finance manager for everyone. Here is how it works:

For heavy-duty work, beancounters could still use their computers to edit or view the ledger with their browsers visiting https://beancount.io or syncing with Dropbox. This keeps the flexibility of the command-line tools, while not losing the cross-device access of the cloud-based solution.

For daily light-weight operations, such as instantly adding an entry, beancounters could use the mobile app to connect to the secured cloud.

Mike Thrift, a backend engineering working on this product, says

I used to set up a reminder every day for myself to open my laptop and input records to my bean files. Now, with beancount.io, it is way easier for me to modify my ledger whenever I need it, even when I am outdoors purchasing something in the store.

Zhi Li, a software engineer from Facebook, tells us

I have migrated all my beancount files to beancount.io, and now it works perfectly for my day-to-day usage. I have paid for Pro features like automatic data backup, but I feel there are more things you guys could do to improve the service.

You could sign up now at https://beancount.io/sign-up/ or download iOS or Android App. We streamlined the registration to collect as minimal information as we can from you to bootstrap the service. Then you will get a preset empty ledger that is ready for you to add an entry right away.

FAQs​

Would beancount.io sell my ledger data to any third party?​

• No. We are committed to keeping your data secured and private, and we will never sell your ledger data.

Is my data secured?​

• Yes. We protect your email and ledger with AES256, your password with BCrypt, and your network requests with SSL.

Is my ledger data end-to-end encrypted?​

• No. Due to technical constraints, we still have to decrypt your data into memory when indexing the ledger file in production servers. Therefore, we restrict direct access from any of our team members. Unfortunately, we cannot do this in Intel's SGX or any security vault due to high costs.

Is this a reliable service I could trust for the incoming few years?​

• Yes. We initially launched Beancount.io on July 4th, 2019, and it has been more than two years that we have operated the service securely and reliably. Therefore, we have no reason not to continue the service in the future.

Can I request new features and sponsor the project?​

• Yes. Please feel free to reach us at https://t.me/beancount for any feedback and support us by becoming a Pro user at https://beancount.io/pricing.