Industry-Specific Setups

Example Configurations for Freelancers, Small Businesses, and Personal Finance

In this guide, we explore how to tailor a Beancount ledger for different needs: a freelance professional, a boutique small business, and personal household finance. Each scenario comes with unique account structures and considerations. We'll explain the rationale behind each setup, provide example Beancount snippets, and highlight useful features (like custom tags and automated imports) that make tracking easier. The tone is instructional yet approachable – whether you're a developer, tech-savvy professional, or finance enthusiast, these examples will help you apply Beancount in the real world.

Freelancers

Freelancers (like software developers or graphic designers) often juggle multiple clients and project expenses. A simple Beancount setup can help track income from each client, business expenses (including any subcontractors hired), and money set aside for taxes. The goal is to keep it straightforward so it scales as your freelance business grows, without unnecessary complexity.

Key Accounts for a Freelancer: A freelance ledger typically separates business finances from personal finances. For example, you might use:

• Assets:Business:Checking – A business bank account for all client payments and business expenses.
• Assets:Business:TaxSavings – A savings account to set aside a portion of income for tax payments (since no employer is withholding taxes for you).
• Income:Client:Name** – Income accounts for client payments. You can create sub-accounts per major client (e.g., Income:Client:ACME), or use a single Income:Freelance account with client names tagged in transactions.
• Expenses:Business:Contractors – For payments to any subcontractors or outsourced work.
• Expenses:Business:Software (and other categories like Travel, Supplies) – For regular business expenses (software subscriptions, equipment, travel to client sites, etc.).
• Equity:OwnerDraw – (Optional) To record transfers of profit from the business to yourself personally. This helps distinguish business funds from personal funds when you pay yourself.

Rationale: This structure ensures all business-related money is tracked in dedicated accounts. Income from each client is recorded (making it easy to see who your top clients are), and expenses are categorized for tax time deductions. Setting aside taxes in a separate asset account (or recording a liability for taxes owed) prevents accidentally spending money that will be due to the government. The ledger remains simple: if you acquire new clients or expense categories, you can add new accounts or use tags without reorganizing everything. A common pitfall is mixing personal and business transactions in one account; by maintaining a dedicated business checking (and corresponding asset account), reconciliation and reporting become cleaner. Another pitfall to avoid is forgetting to record cash transfers for taxes or owner’s draws – by using accounts like TaxSavings and OwnerDraw, every dollar is accounted for.

Beancount Features to Highlight: Tags and metadata are extremely useful to freelancers. For instance, you might tag transactions with a project or invoice number, or use a metadata field to note the client name if you choose not to use separate income accounts per client. This makes it easy to filter or query transactions for a specific client or project (e.g., summing all expenses tagged #ProjectX). Additionally, Beancount’s automated importers can simplify data entry – for example, you could set up an importer for your bank or credit card statements to ingest transactions into your ledger, then just add the appropriate expense or income account names. This saves time when you have many small transactions (like software subscriptions or travel expenses).

Freelancer Example Ledger Snippet

Below is a simplified Beancount snippet for a freelance developer. It shows opening a few key accounts, an incoming payment from a client, a payment out to a subcontractor, a typical business expense, and moving money into a tax savings account. (In practice, you would also record other expenses like travel or equipment purchases similarly.)

1970-01-01 open Assets:Business:Checking
1970-01-01 open Assets:Business:TaxSavings
1970-01-01 open Income:Client:ACME
1970-01-01 open Expenses:Business:Contractors
1970-01-01 open Expenses:Business:Software

; Client income – payment for an invoice
2025-08-15 * "Invoice payment from ACME Corp"
  invoice: "INV-2025-08-15"
  Assets:Business:Checking       5000 USD
  Income:Client:ACME           -5000 USD

; Regular expense – e.g. software subscription for the business
2025-08-05 * "GitHub Subscription"
  Expenses:Business:Software       15 USD
  Assets:Business:Checking       - 15 USD

; Contractor expense – paying a subcontractor for help
2025-08-20 * "Contractor payment – Jane Doe"
  Expenses:Business:Contractors   2000 USD
  Assets:Business:Checking      -2000 USD

; Tax withholding – moving money to tax savings
2025-08-31 * "Set aside Q3 taxes"
  Assets:Business:TaxSavings     1500 USD
  Assets:Business:Checking     -1500 USD  #tax

Let’s break down what’s happening:

• We open the necessary accounts at the top (with a start date). This isn’t strictly required for Beancount (accounts are created on first use if not opened), but it’s good practice to declare them. The Assets:Business:Checking and Assets:Business:TaxSavings accounts will hold USD balances; income and expense accounts can be left without a currency in the open directive as they’ll inherit transaction currencies (USD in this case).
• Invoice payment from client: On 2025-08-15, an income transaction records a client payment of $5,000 for an invoice. We credit Income:Client:ACME (income increases with a negative amount in double-entry) and debit the checking account. A metadata field invoice: "INV-2025-08-15" is included to note the invoice number – this is optional but shows how you can attach extra information to a transaction. You could also tag this transaction with #ACME or #client-ACME for quick filtering. If you had multiple clients, you might use a general Income:Clients account and rely on such metadata or the Payee field to distinguish clients, instead of creating many subaccounts.
• Business expense (software): On 2025-08-05, we record a $15 expense for a GitHub subscription (perhaps for private repositories or other services). The posting goes to Expenses:Business:Software and reduces the business checking account. Small recurring expenses like this could be tagged (for example, we added #tax on the tax transaction below; similarly you might tag certain expenses as #recurring if they occur monthly, etc.). In this case, the account name itself (Software) makes it clear.
• Contractor payment: On 2025-08-20, the freelancer paid a subcontractor (Jane Doe) $2,000. This is logged as an expense in Expenses:Business:Contractors and cash out of the checking account. You could include the contractor’s name in the narration (as we did) or as a metadata field (e.g., contractor: "Jane Doe"). This keeps an audit trail of whom you paid and why (useful if you need details during tax filing or budgeting).
• Tax savings transfer: On 2025-08-31, the freelancer transfers $1,500 from the main checking to a dedicated tax savings account. We’ve tagged this transaction with #tax for visibility. This isn’t an expense (you’re just moving your own money), so it goes between two asset accounts. By doing this each month or quarter, you accumulate funds to cover estimated taxes. When it’s time to actually pay the taxes to the government, you would record an expense (say, Expenses:Taxes) and a deduction from the TaxSavings (or Checking) account. A common pitfall is to treat this transfer as an expense in your reports – remember, it’s not an expense, just a precautionary allocation. Only the actual tax payment to the IRS/Tax authority would be an expense (or reduction of an accrued tax liability if you track it that way).

Summary: A freelancer’s Beancount ledger emphasizes simplicity and clarity. All income and outflows tied to the business are recorded methodically. By using meaningful account names and occasional tags/metadata, you can generate reports per client or per expense category easily (e.g., total income per client, total spent on contractors this year, etc.). This setup is scalable – you can add new clients or expense categories as your business evolves. With features like automated imports (to pull in bank transactions) and custom tagging for projects or invoices, Beancount can greatly reduce bookkeeping overhead for freelancers while providing a clear picture of finances at any time.

Small Businesses

Next, consider a small boutique e-commerce business – for example, an online store that sells handcrafted goods. This scenario adds complexity such as inventory management, cost of goods sold (COGS), and handling online payment processors. Beancount can accommodate these with a thoughtful account structure and transaction recording method. We'll use a case where the business keeps track of products in inventory, records sales through an online platform (like Shopify with Stripe for payments), and logs typical business expenses.

Key Accounts for a Boutique E-commerce Business: In addition to basic bank and expense accounts, a retail business ledger will include accounts to track inventory and sales flows:

• Assets:Bank:Checking – The business’s checking account (for paying suppliers, operating expenses, and receiving transfers from payment processors).
• Assets:Stripe:Balance (or Assets:PayPal, etc.) – A clearing account for funds collected via online payments that haven’t yet hit the bank. For instance, when a customer pays via Stripe, the money might sit in a Stripe account before being deposited in your bank in batches.
• Assets:Inventory:Product** – Inventory accounts for your products. You can treat each product (or category of products) as a commodity in Beancount to track quantities on hand. For example, Assets:Inventory:Widgets might hold the quantity of “Widget” items currently in stock, valued at their cost price.
• Income:Sales – Records revenue from product sales. You might use subaccounts for different sales channels (e.g., Income:Sales:Online vs Income:Sales:InStore) if the business had multiple channels, but we’ll keep it simple with one sales income account.
• Expenses:COGS – Cost of Goods Sold, to capture the cost basis of inventory items when they are sold. This account will effectively show how much the sold inventory cost you (as the business owner) over a period. It’s a key component for calculating gross profit.
• Expenses:Fees – For payment processing fees and platform fees (Stripe charges, Shopify fees, PayPal fees, etc. all can be recorded here). You could separate this into more detailed accounts (e.g., Expenses:Fees:Stripe and Expenses:Fees:Shopify) if desired, but one account may suffice for all transaction fees.
• Expenses:Operating – General business expenses not directly tied to COGS, such as marketing, web hosting, software, shipping supplies, etc. These could be broken into subaccounts (e.g., Expenses:Marketing, Expenses:WebHosting, Expenses:Shipping) to analyze different cost centers.
• Liabilities:SalesTax – (Optional, if applicable) If the business needs to collect sales tax or VAT on sales, this liability account tracks taxes collected but not yet remitted to the government. Each sale would then split out the tax portion into this account. This ensures taxes collected are not counted as income and are earmarked for payment to tax authorities.
• Equity:OwnerEquity – (Optional) Represents owner’s investment and retained earnings. When the business was started, any initial funding by the owner would be credited here (with a debit to the bank or inventory if they contributed cash or inventory). Also, if the owner takes profit out (distributions), that could be recorded against this equity account. This keeps the balance sheet balanced but for day-to-day operations, it doesn’t come into play often.

Rationale: This setup segregates the flow of goods and money. Inventory purchases are initially recorded on the balance sheet (as assets) rather than immediately as expenses. Only when you sell products do you expense their cost (COGS), matching revenue with the related expense for proper profit calculation. Income from sales is recorded at the gross sale price, while fees are recorded separately so you can see both gross revenue and fees paid (and thus net revenue). Using a clearing account like Assets:Stripe:Balance helps in reconciling deposits – money moves from Stripe to your bank in lumps, and you can record those transfers without confusion. A common pitfall for new shop owners is to neglect recording inventory properly – for example, expensing all inventory purchases immediately. That might be fine for cash flow tracking, but it skews your profit: you’ll look less profitable in months when you stock up, and more profitable in months when you sell, even though the inventory was bought earlier. By using an inventory asset account and COGS, you align the cost with the sale. Another pitfall is not accounting for fees or refunds, which can cause your bank or Stripe balances to not match your recorded income. We avoid that by explicitly recording fees and using the Stripe asset account to track what Stripe owes or has paid out.

Beancount Features to Highlight: Inventory tracking in Beancount leverages its ability to handle commodities and costs. Each product can be a commodity symbol (e.g., WIDGET), allowing you to record both quantity and unit cost. When you sell items, Beancount’s inventory logic (FIFO by default) can automatically pick the right cost from your inventory lots. We’ll see this in the example. You can also use metadata or links to tie sales and their corresponding COGS entries (for example, using the same order number in both transactions, or a shared tag like #order1001 on the sale and the inventory reduction, making it easy to query or double-check that each sale has a matching COGS entry). Additionally, automated imports can help here: you might use a script to import sales data from Shopify or Stripe payout reports, or import your bank statements to catch expense transactions and payouts. Automating these repetitive data entry tasks means you spend more time analyzing and less time typing numbers.

Small Business Example Ledger Snippet

Below is a condensed Beancount example for our boutique e-commerce business. We illustrate purchasing inventory, recording a sale (with the payment processor fee netted out), and recording the cost of goods sold for that sale. In practice, you would also record other expenses (like platform fees, advertising costs, etc.) similarly to the fee example shown. We assume USD as the currency and a product called “Widget” that we track as a commodity in inventory.

1970-01-01 open Assets:Bank:Checking
1970-01-01 open Assets:Stripe:Balance
1970-01-01 open Assets:Inventory:Widgets WIDGET
1970-01-01 open Income:Sales
1970-01-01 open Expenses:COGS
1970-01-01 open Expenses:Fees

; Purchase inventory (50 units of Widget at $10 cost each)
2025-03-10 * "Bought 50 Widgets from SupplierCo"
  Assets:Inventory:Widgets      50 WIDGET {10 USD}
  Assets:Bank:Checking        -500 USD

; Sale to customer (Order #1001 via online store, 2 Widgets sold)
2025-04-05 * "Sale Order #1001 (2x Widget via Shopify)"
  Assets:Stripe:Balance         58 USD   ; net payment received after fees
  Expenses:Fees                  2 USD   ; processing fee (Stripe)
  Income:Sales                 -60 USD   ; revenue for 2 Widgets (@ $30 each)

; Cost of goods sold for the above sale (2 Widgets at $10 cost each)
2025-04-05 * "COGS for Order #1001 (2x Widget)"
  Expenses:COGS                 20 USD
  Assets:Inventory:Widgets     -2 WIDGET {10 USD}

Here’s what’s happening step by step:

• Opening accounts: We open the checking account, the Stripe balance account, an inventory account for Widgets (declared with commodity WIDGET to track units), and the core income and expense accounts (Sales, COGS, Fees). By declaring Assets:Inventory:Widgets WIDGET, we signal that this account will hold quantities of the commodity "WIDGET". This ensures Beancount knows to expect commodity units there, and we can attach cost to those units.

• Inventory purchase: On 2025-03-10, we buy inventory – 50 units of Widget from a supplier at $10 each, costing a total of $500. The transaction debits Assets:Inventory:Widgets with 50 WIDGET {10 USD}. This means 50 units of commodity WIDGET, each with a recorded cost of 10 USD, are added to the inventory account. The credit is Assets:Bank:Checking -500 USD (cash outlay). Notice we didn’t directly touch an expense account here; we’re capitalizing the purchase as inventory asset. Now our balance sheet has 50 Widgets valued at $500 total in inventory. (If you were to run a balance report, the Inventory account would show 50 WIDGET units with $500 worth.)

• Recording a sale (Order #1001): On 2025-04-05, we record a sale of 2 Widgets through our online store. The narration includes an order number for clarity. This transaction involves three postings:

  • Assets:Stripe:Balance 58 USD: money received from the sale, but currently in Stripe (net of fees). Suppose the customer paid $60 in total; Stripe took a $2 fee, and $58 is now in our Stripe account (to be transferred to our bank later). We record the $58 as an asset in Stripe.
  • Expenses:Fees 2 USD: the $2 fee is recorded as a business expense. This ensures our income statement will reflect that cost, and our Stripe asset plus fee expense together equal the total customer payment.
  • Income:Sales -60 USD: we record $60 of income from sales. (Income accounts increase with credits, hence the negative amount in Beancount’s notation).

  After this transaction, the net effect is: Income:Sales up by 60, an extra $58 asset (receivable from Stripe), and $2 expense for the fee. If Stripe later deposits the $58 to our bank, we would record a simple transfer like Assets:Bank:Checking 58 USD / Assets:Stripe:Balance -58 USD on the date of payout – this moves the asset from the Stripe account to the bank, with no impact on income or expense (just shifting assets). We haven’t shown that transfer above, but it’s an important step in real bookkeeping to keep your Stripe account at $0 once everything is transferred out.

• Recording COGS for the sale: Also on 2025-04-05, we have a separate transaction to record the cost of the 2 Widgets sold. We debit Expenses:COGS 20 USD and credit Assets:Inventory:Widgets -2 WIDGET {10 USD}. What this does is remove 2 units from inventory (each had a cost of $10 as recorded earlier, so $20 total). We specify {10 USD} to tell Beancount which cost lot to draw from – in this case, it matches the lot we added on 2025-03-10. Now the inventory account will have 48 Widgets remaining, and an associated cost of $480. The $20 is moved into the COGS expense, which will appear on the income statement, reducing gross profit by the cost of those goods. (If we did not record this, our income would be overstated relative to expenses.) We use a separate transaction for clarity, but it’s also possible to combine the sale and COGS in one multi-line transaction. Some prefer splitting them as shown for readability and reconciliation (you can clearly tie each COGS entry to an order). We also echoed the order number in the narration to easily see that this COGS entry corresponds to Order #1001. A good practice is to ensure every sale has a matching COGS entry when inventory is involved – missing one would mean your inventory counts are off. A pitfall to avoid is forgetting to remove inventory for a sale, which would leave your balance sheet with phantom stock and your expenses understated. Using Beancount’s inventory features (the {} cost notation) helps catch if you try to remove more units than you have on hand (the software will error out in that case).

Summary: A small business using Beancount can maintain a surprisingly robust accounting system. By structuring accounts to track where money is, where it comes from, and how costs flow, you get an accurate picture of profitability. Our example showed how to handle inventory and sales; you would similarly record other transactions like paying an internet bill (Expenses:Operating:Internet vs. Assets:Bank:Checking), receiving a loan or investment (Assets:Bank vs. Liabilities:Loan or Equity:OwnerEquity), or paying sales tax (Liabilities:SalesTax vs. Assets:Bank when remitted). The key is consistency: record each type of transaction with the same pattern, and Beancount will keep the books balanced. With features like automated data import (for instance, pulling in monthly Stripe fees or bank transactions) and custom tags/links (to correlate related transactions like sales and refunds), the system can be both flexible and efficient. The result is an organized ledger that can scale as the business grows – you can add new product inventory accounts, new expense categories, or additional income streams (say a new online marketplace) without reworking the whole system.

Personal Finance

Finally, let's consider using Beancount for personal or household finances. This setup is for an individual or family managing daily expenses, bank accounts, credit cards, loans, and investments. The emphasis here is on tracking where your money goes (expenses), where it comes from (income), and how it's saved or invested (assets and liabilities). Beancount can replace or augment budgeting apps by providing a transparent and customizable view of your finances, with the rigor of double-entry accounting ensuring nothing is double-counted or forgotten.

Key Accounts for Personal Finance: A personal finance ledger will typically include a variety of asset, liability, income, and expense accounts:

• Assets:Bank:Checking – Your main checking account for income deposits and bill payments.
• Assets:Bank:Savings – Savings account for emergency fund or specific goals. (You might have multiple savings or investment accounts – each can be an asset account).
• Assets:Cash – If you use cash for expenses, you might have a cash account to track withdrawals and cash spending.
• Assets:Investments:Broker** – Investment accounts, such as a brokerage, retirement 401(k)/IRA, etc. These might further break down by investment types or just be lumped as one account per institution. For example, Assets:Investments:VanguardIRA or Assets:Investments:Robinhood. Tracking investments may also involve commodities for stocks or funds, but if this is too detailed, you can simply track contributions and account balances.
• Liabilities:CreditCard:Name** – One account per credit card (e.g., Liabilities:CreditCard:Visa or by bank name). All purchases on the card are recorded here (with an equal expense), and payments to the card are transfers that reduce this liability.
• Liabilities:Loan:Name** – Any loans (student loan, mortgage, car loan) can be tracked with a liability account. You’d record the principal balance and each payment splitting interest (expense) and principal (liability reduction). This is an advanced aspect, but important for a complete financial picture.
• Income:Salary (and/or Income:Bonus, Income:Interest, etc.) – To record paychecks, bonuses, interest income, dividends, etc. Income accounts let you see your total earnings from various sources. (If your paycheck already has taxes taken out, you might record the net deposit to checking as income, or record gross and tax withholdings as an expense or liability – different approaches exist, but many just record net pay as income for simplicity in personal books.)
• Expenses: Typically numerous, divided into categories meaningful to you. For example: Expenses:Housing:Rent, Expenses:Food:Groceries, Expenses:Food:DiningOut, Expenses:Utilities:Electricity, Expenses:Entertainment, Expenses:Travel, Expenses:Taxes, Expenses:Misc – whatever categories reflect your spending habits. You can be as granular or general as you like. The account hierarchy helps aggregate (e.g., Expenses:Food will total both groceries and dining out). Common practice is to have a hierarchy for major groups (Housing, Food, Transportation, Healthcare, etc.).
• Equity:Opening-Balances – Used to initialize account balances when you start your ledger (so that all assets minus liabilities equal your starting net worth recorded in equity). After starting, you might also use Equity:Retained-Earnings or similar to represent accumulated net profit (though in personal finance, you typically just let income minus expenses roll into net worth). Equity accounts are less visible day-to-day but ensure the accounting equation balances.

Rationale: The personal finance setup is about capturing your financial life in one coherent system. Each account above serves to separate different kinds of finances so you can answer questions like "How much did I spend on food this month?" (by summing Expenses:Food:*), "How much debt do I have left?" (by looking at Liabilities accounts), or "What's my net worth?" (Assets minus Liabilities). A big advantage of double-entry here is accuracy: for example, when you charge a $100 grocery bill to your credit card, you record it as an expense and a liability increase. Later, when you pay the credit card, you record a transfer from your bank to the card – this pays down the liability but does not double-count the grocery expense (which was already recorded). A common pitfall without double-entry is to treat the credit card payment as an expense itself, effectively counting the $100 twice. Beancount prevents that by design. Another pitfall to avoid is failing to reconcile accounts: with Beancount, you can use balance assertions or the balance directive to ensure, for instance, your checking account balance in the ledger matches the actual bank statement. This catches missing or duplicate entries.

Beancount Features to Highlight: For personal finance, automated imports are especially helpful because of the volume of transactions. You can use Beancount's importer framework or community scripts to import bank transactions, credit card statements, and even investment transactions from CSV, OFX, or API sources. This means you spend less time manually typing out every coffee purchase. Custom tags are useful for slicing data in ways accounts might not. For example, tag all vacation-related expenses with #vacation2025 regardless of whether they’re flights, hotels, or dining – then you can query the total cost of that vacation easily. Or tag certain expenses as #deductible if you need to track tax-deductible items for later reference. You could also tag recurring bills (e.g., #monthly) to review all your subscriptions and fixed costs annually. Metadata can be used to attach notes or receipts (for instance, receipt: "path/to/file.jpg" to note you have a saved receipt image, or category: "Work Expense" if tracking reimbursable items). The flexibility of tags and metadata means you can adapt the system to your personal tracking needs without creating dozens of extra accounts.

Personal Finance Example Ledger Snippet

Below is an example snippet of a personal Beancount ledger capturing a few typical transactions: a daily expense charged to a credit card, a recurring bill paid from checking, and a contribution to a retirement investment account. (For brevity, we assume an initial setup has been done to open accounts and record any salary income; here we focus on the spending and saving side.)

1970-01-01 open Assets:Bank:Checking
1970-01-01 open Liabilities:CreditCard:Visa
1970-01-01 open Expenses:Food:Coffee
1970-01-01 open Expenses:Housing:Rent
1970-01-01 open Assets:Investment:401k

; Daily spending example (coffee on a credit card)
2025-09-10 * "Starbucks Coffee"
  Expenses:Food:Coffee       5.50 USD
  Liabilities:CreditCard:Visa   -5.50 USD  #daily

; Recurring monthly bill (rent paid from checking)
2025-09-01 * "Apartment Rent September"
  Expenses:Housing:Rent    1200 USD
  Assets:Bank:Checking    -1200 USD  #recurring

; Retirement contribution (transfer from checking to 401k investment)
2025-09-15 * "401(k) Contribution"
  Assets:Investment:401k    500 USD
  Assets:Bank:Checking     -500 USD  #retirement

Let’s interpret these transactions:

• Opening accounts: We open the checking account, a Visa credit card account, a Coffee expense account (as an example of a sub-category of Food expenses), a Rent expense account, and a 401k investment account. In a real ledger, you’d open all the accounts you plan to use (savings, other expense categories, income, etc.). We keep it to just what's needed for the snippet.
• Daily expense – coffee: On 2025-09-10, a $5.50 coffee purchase is recorded. The expense is categorized under Expenses:Food:Coffee, and since it was paid with a Visa credit card, we credit (increase) Liabilities:CreditCard:Visa. The tag #daily is added to indicate this was a day-to-day spending item – maybe later you want to filter all daily discretionary spends. Notice that after this, the credit card account will show a balance of $5.50 (meaning you owe $5.50 to Visa). If you had paid cash for this coffee, the transaction would instead credit Assets:Cash (reducing the cash you have on hand). If it was a debit card purchase, it would credit Assets:Bank:Checking. The mechanics are similar, just different accounts.
• Recurring bill – rent: On 2025-09-01, we record paying the monthly rent of $1200. This comes out of the checking account (crediting Assets:Bank:Checking) and is categorized as Expenses:Housing:Rent. We tagged it #recurring to mark that this is a repeating bill. In a full ledger, you might have an entry just like this every month. (Beancount doesn’t have an automatic recurring transaction feature built-in, but you could achieve it with scripts or simply copy-paste each month. Tags help to later ensure you haven’t missed a month or to sum up a year’s rent quickly.) Some users use the periodic transaction feature via the Beancount importer framework to generate these automatically, but that’s an advanced usage beyond the scope here. The key is that this transaction clearly shows where your money went – an expense for housing – and your reduced bank balance. A pitfall to watch: if you share expenses or have roommates, you might only pay part of the rent; in that case, you could split the transaction into your portion and the portion someone else pays (possibly recording the other portion as Income:Reimbursements if they pay you). In our simple case, we pay the full amount.
• Retirement contribution: On 2025-09-15, $500 is moved from checking to a 401(k) investment account. This is not an expense but rather transferring assets from one form (cash) to another (retirement fund). The transaction debits Assets:Investment:401k and credits Assets:Bank:Checking. We tag it #retirement for clarity. After this, your checking account balance will drop by 500, and your 401k account balance in the ledger will increase by whatever 500 USD represents (depending on how you track investments, you might subsequently buy mutual fund units with that cash – that would be another transaction in the investment account, e.g., buying X shares of a fund at Y price, with the cash going out of the 401k asset). In a basic personal ledger, you might simply treat the 401k like a savings account and update its balance periodically or record contributions like this and maybe use price quotes for growth. The important thing is this transaction is a transfer, not an expense – it’s building your assets. Many budgeting tools would count retirement contributions as “expenses” (since it leaves your checking), but in accounting terms, it’s just moving money to a different pocket. This distinction helps you understand savings rate versus spending.

If we had a transaction for paying the credit card bill, it would look like transferring money from Checking to the CreditCard liability (e.g., Liabilities:CreditCard:Visa 100 USD / Assets:Bank:Checking -100 USD). That would bring the credit card balance back down (perhaps to zero if you paid it in full) and reduce your bank balance accordingly, with no effect on expense accounts – because you already recorded the expenses at the time of purchase. Remembering to handle credit cards this way is crucial for accurate personal finance tracking. You might tag the payment as well (some use #cc-payment or similar) or include the statement period in narration for clarity.

Summary: A personal finance ledger in Beancount helps impose discipline and structure on your money tracking. By categorizing transactions with accounts (and optionally tags), you can produce insightful reports: monthly spending by category, yearly totals, how much you saved, and so on. The double-entry approach means every dollar is accounted for: if an account’s balance goes down, it went somewhere (another account goes up). This catches errors and prevents the common “missing money” problem in simpler tracking tools. With automation, you can import most transactions and then just review & classify them, making maintenance quite feasible. Over time, you build a financial diary that’s comprehensive – it can even handle things like splitting bills with friends (using equity accounts or payable/receivable accounts), tracking loan amortization, or investment performance, if you choose to expand into those areas. Even at its most basic (as shown in the snippet), Beancount gives you clarity on daily spending, recurring obligations, and progress towards long-term goals (like retirement savings). And since it’s plain text, you have full control: you can script it, query it, or integrate it with other tools (like the web interface Fava for a friendly view). In short, this setup turns your personal finances into data that you can analyze and trust, while remaining simple enough to not be a chore.

---

By tailoring your Beancount ledger to your situation – whether you're freelancing, running a small business, or managing personal funds – you get the benefit of a systematic, double-entry approach to financial tracking with the flexibility of a plain-text system. These example configurations demonstrate core patterns you can build on. As you grow your business or your financial life gets more complex, you can extend the chart of accounts or use advanced features (like budgets, variance analysis, or multi-currency handling) as needed. The key is to start with a clean, logical structure (like the ones shown) and consistently record transactions. With that in place, Beancount will be a powerful ally in understanding and managing your finances, across industries and personal scenarios alike. Happy accounting!