25 posts tagged with "small business"

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).
• 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).
• 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.

Small business owners spend an average of 11 hours per month manually categorizing expenses - nearly three full workweeks annually devoted to data entry. A 2023 QuickBooks survey reveals that 68% of business owners rank expense tracking as their most frustrating bookkeeping task, yet only 15% have embraced automation solutions.

Plain text accounting, powered by tools like Beancount, offers a fresh approach to financial management. By combining transparent, programmable architecture with modern AI capabilities, businesses can achieve highly accurate expense categorization while maintaining full control over their data.

This guide will walk you through building an expense automation system tailored to your business's unique patterns. You'll learn why traditional software falls short, how to harness Beancount's plain text foundation, and practical steps for implementing adaptive machine learning models.

The Hidden Costs of Manual Expense Management​

Manual expense categorization drains more than just time—it undermines business potential. Consider the opportunity cost: those hours spent matching receipts to categories could instead fuel business growth, strengthen client relationships, or refine your offerings.

A recent Accounting Today survey found small business owners dedicate 10 hours weekly to bookkeeping tasks. Beyond the time sink, manual processes introduce risks. Take the case of a digital marketing agency that discovered their manual categorization had inflated travel expenses by 20%, distorting their financial planning and decision-making.

Poor financial management remains a leading cause of small business failure, according to the Small Business Administration. Misclassified expenses can mask profitability issues, overlook cost-saving opportunities, and create tax season headaches.

Beancount's Architecture: Where Simplicity Meets Power​

Beancount's plain-text foundation transforms financial data into code, making every transaction trackable and AI-ready. Unlike traditional software trapped in proprietary databases, Beancount's approach enables version control through tools like Git, creating an audit trail for every change.

This open architecture allows seamless integration with programming languages and AI tools. A digital marketing agency reported saving 12 monthly hours through custom scripts that automatically categorize transactions based on their specific business rules.

The plain text format ensures data remains accessible and portable—no vendor lock-in means businesses can adapt as technology evolves. This flexibility, combined with robust automation capabilities, creates a foundation for sophisticated financial management without sacrificing simplicity.

Creating Your Automation Pipeline​

Building an expense automation system with Beancount starts with organizing your financial data. Let's walk through a practical implementation using real examples.

1. Setting Up Your Beancount Structure​

First, establish your account structure and categories:

2025-01-01 open Assets:Business:Checking
2025-01-01 open Expenses:Office:Supplies
2025-01-01 open Expenses:Software:Subscriptions
2025-01-01 open Expenses:Marketing:Advertising
2025-01-01 open Liabilities:CreditCard

2. Creating Automation Rules​

Here's a Python script that demonstrates automatic categorization:

import pandas as pd
from datetime import datetime

def categorize_transaction(description, amount):
    rules = {
        'ADOBE': 'Expenses:Software:Subscriptions',
        'OFFICE DEPOT': 'Expenses:Office:Supplies',
        'FACEBOOK ADS': 'Expenses:Marketing:Advertising'
    }
    
    for vendor, category in rules.items():
        if vendor.lower() in description.lower():
            return category
    return 'Expenses:Uncategorized'

def generate_beancount_entry(row):
    date = row['date'].strftime('%Y-%m-%d')
    desc = row['description']
    amount = abs(float(row['amount']))
    category = categorize_transaction(desc, amount)
    
    return f'''
{date} * "{desc}"
    {category}                               {amount:.2f} USD
    Liabilities:CreditCard                  -{amount:.2f} USD
'''

3. Processing Transactions​

Here's how the automated entries look in your Beancount file:

2025-05-01 * "ADOBE CREATIVE CLOUD"
    Expenses:Software:Subscriptions            52.99 USD
    Liabilities:CreditCard                   -52.99 USD

2025-05-02 * "OFFICE DEPOT #1234 - PRINTER PAPER"
    Expenses:Office:Supplies                  45.67 USD
    Liabilities:CreditCard                   -45.67 USD

2025-05-03 * "FACEBOOK ADS #FB12345"
    Expenses:Marketing:Advertising           250.00 USD
    Liabilities:CreditCard                  -250.00 USD

Testing proves crucial—start with a subset of transactions to verify categorization accuracy. Regular execution through task schedulers can save 10+ hours monthly, freeing you to focus on strategic priorities.

Achieving High Accuracy Through Advanced Techniques​

Let's explore how to combine machine learning with pattern matching for precise categorization.

Pattern Matching with Regular Expressions​

import re

patterns = {
    r'(?i)aws.*cloud': 'Expenses:Cloud:AWS',
    r'(?i)(zoom|slack|notion).*subscription': 'Expenses:Software:Subscriptions',
    r'(?i)(uber|lyft|taxi)': 'Expenses:Travel:Transport',
    r'(?i)(marriott|hilton|airbnb)': 'Expenses:Travel:Accommodation'
}

def regex_categorize(description):
    for pattern, category in patterns.items():
        if re.search(pattern, description):
            return category
    return None

Machine Learning Integration​

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
import re
from typing import List, Tuple

class ExpenseClassifier:
    def __init__(self):
        self.vectorizer = TfidfVectorizer()
        self.classifier = MultinomialNB()
    
    def parse_beancount_entries(self, beancount_text: str) -> List[Tuple[str, str]]:
        """Parse Beancount entries into (description, category) pairs."""
        entries = []
        for line in beancount_text.split('\n'):
            # Look for transaction descriptions
            if '* "' in line:
                desc = re.search('"(.+)"', line)
                if desc:
                    description = desc.group(1)
                    # Get the next line which should contain the expense category
                    next_line = next(filter(None, beancount_text.split('\n')[beancount_text.split('\n').index(line)+1:]))
                    if 'Expenses:' in next_line:
                        category = next_line.split()[0].strip()
                        entries.append((description, category))
        return entries
        
    def train(self, beancount_text: str):
        """Train the classifier using Beancount entries."""
        entries = self.parse_beancount_entries(beancount_text)
        if not entries:
            raise ValueError("No valid entries found in training data")
            
        descriptions, categories = zip(*entries)
        X = self.vectorizer.fit_transform(descriptions)
        self.classifier.fit(X, categories)
        
    def predict(self, description: str) -> str:
        """Predict category for a new transaction description."""
        X = self.vectorizer.transform([description])
        return self.classifier.predict(X)[0]

# Example usage with training data:
classifier = ExpenseClassifier()

training_data = """
2025-04-01 * "AWS Cloud Services Monthly Bill" 
    Expenses:Cloud:AWS                         150.00 USD
    Liabilities:CreditCard                   -150.00 USD

2025-04-02 * "Zoom Monthly Subscription"
    Expenses:Software:Subscriptions            14.99 USD
    Liabilities:CreditCard                    -14.99 USD
    
2025-04-03 * "AWS EC2 Instances"
    Expenses:Cloud:AWS                         250.00 USD
    Liabilities:CreditCard                    -250.00 USD

2025-04-04 * "Slack Annual Plan"
    Expenses:Software:Subscriptions           120.00 USD
    Liabilities:CreditCard                   -120.00 USD
"""

# Train the classifier
classifier.train(training_data)

# Test predictions
test_descriptions = [
    "AWS Lambda Services",
    "Zoom Webinar Add-on",
    "Microsoft Teams Subscription"
]

for desc in test_descriptions:
    predicted_category = classifier.predict(desc)
    print(f"Description: {desc}")
    print(f"Predicted Category: {predicted_category}\n")

This implementation includes:

• Proper parsing of Beancount entries
• Training data with multiple examples per category
• Type hints for better code clarity
• Error handling for invalid training data
• Example predictions with similar but unseen transactions

Combining Both Approaches​

2025-05-15 * "AWS Cloud Platform - Monthly Usage"
    Expenses:Cloud:AWS                        234.56 USD
    Liabilities:CreditCard                   -234.56 USD

2025-05-15 * "Uber Trip - Client Meeting"
    Expenses:Travel:Transport                  45.00 USD
    Liabilities:CreditCard                    -45.00 USD

2025-05-16 * "Marriott Hotel - Conference Stay"
    Expenses:Travel:Accommodation             299.99 USD
    Liabilities:CreditCard                   -299.99 USD

This hybrid approach achieves remarkable accuracy by:

1. Using regex for predictable patterns (subscriptions, vendors)
2. Applying ML for complex or new transactions
3. Maintaining a feedback loop for continuous improvement

A tech startup implemented these techniques to automate their expense tracking, reducing manual processing time by 12 hours monthly while maintaining 99% accuracy.

Tracking Impact and Optimization​

Measure your automation success through concrete metrics: time saved, error reduction, and team satisfaction. Track how automation affects broader financial indicators like cash flow accuracy and forecasting reliability.

Random transaction sampling helps verify categorization accuracy. When discrepancies arise, refine your rules or update training data. Analytics tools integrated with Beancount can reveal spending patterns and optimization opportunities previously hidden in manual processes.

Engage with the Beancount community to discover emerging best practices and optimization techniques. Regular refinement ensures your system continues delivering value as your business evolves.

Moving Forward​

Automated plain-text accounting represents a fundamental shift in financial management. Beancount's approach combines human oversight with AI precision, delivering accuracy while maintaining transparency and control.

The benefits extend beyond time savings—think clearer financial insights, reduced errors, and more informed decision-making. Whether you're technically inclined or focused on business growth, this framework offers a path to more efficient financial operations.

Start small, measure carefully, and build on success. Your journey toward automated financial management begins with a single transaction.

Picture this: You receive an IRS audit notice. Instead of panic, you calmly run a single command that generates a complete, organized financial trail. While most small business owners spend weeks gathering documents for tax audits, Beancount users can produce comprehensive reports in minutes.

Plain-text accounting transforms financial record-keeping from a scattered mess into a streamlined, automated process. By treating your finances like code, you create an immutable, version-controlled record that's always audit-ready.

The Hidden Cost of Disorganized Financial Records​

Traditional record-keeping often leaves financial data scattered across spreadsheets, emails, and filing cabinets. During an audit, this fragmentation creates a perfect storm of stress and inefficiency. One tech startup learned this lesson the hard way – their mixed digital and paper records led to inconsistencies during an audit, resulting in prolonged investigation and substantial fines.

Beyond the obvious time waste, disorganization introduces subtle risks. Missing documentation, data entry errors, and compliance gaps can trigger penalties or extend audit durations. Small businesses face an average of $30,000 in penalties annually due to preventable tax mistakes.

Building an Audit-Proof Financial System with Beancount​

Beancount's plain-text foundation offers something unique: complete transparency. Every transaction is stored in a readable format that's both human-friendly and machine-verifiable. The system employs double-entry accounting, where each transaction is recorded twice, ensuring mathematical accuracy and creating an unbreakable audit trail.

The open-source nature of Beancount means it adapts as tax laws evolve. Users can customize the system for specific regulatory requirements or integrate it with existing financial tools. This flexibility proves invaluable as compliance requirements grow more complex.

Automated Audit Trail Generation with Python​

Rather than manually compiling reports, Beancount users can write Python scripts that instantly generate IRS-compatible documentation. These scripts can filter transactions, calculate taxable income, and organize data according to specific audit requirements.

One developer described their first audit with Beancount as "surprisingly pleasant." Their automatically generated ledger impressed the IRS inspector with its clarity and completeness. The system's ability to track modifications and maintain a complete transaction history means you can always explain when and why changes were made.

Beyond Basic Compliance: Advanced Features​

Beancount shines in handling complex scenarios like multi-currency transactions and international tax requirements. Its programmability allows users to create custom reports for specific tax situations or regulatory frameworks.

The system can integrate with AI tools to help predict tax liabilities and flag potential compliance issues before they become problems. From our firsthand experience, automated tax reporting delivers substantial time savings.

Future-Proofing Your Finances with Version Control​

Version control transforms financial record-keeping from periodic snapshots into a continuous, traceable history. Every change is documented, creating an immutable timeline of your financial activities. This granular tracking helps quickly resolve discrepancies and demonstrates consistent record-keeping practices.

From our firsthand experience, adopting continuous audit readiness reduces stress during audits and cuts the time spent on compliance tasks. The system acts like a financial time machine, allowing you to examine any point in your financial history with perfect clarity.

Conclusion​

Plain-text accounting with Beancount transforms tax audits from a source of anxiety into a straightforward process. By combining immutable records, automated reporting, and version control, you create a financial system that's always audit-ready.

The real value isn't just in surviving audits – it's in building a foundation for financial clarity and confidence. Whether you're a small business owner or financial professional, Beancount offers a path to stress-free tax compliance and better financial management.

Great therapy for your business is a calm, balanced ledger. The following tips condense the latest small‑business guidance into a Beancount‑friendly routine.

Maintaining a pristine set of books isn't just about surviving tax season; it's about understanding the financial health of your business in real time. For users of a plain-text accounting system like Beancount, good habits are the engine that transforms a simple ledger into a powerful tool for insight and growth. The following ten tips are designed to refine your process, save you time, and keep your financial data clean, auditable, and ready for action.

1. Separate Business and Personal Money​

This is the golden rule of business finance for a reason. Maintaining a dedicated checking account and credit card for your practice is the cleanest way to draw a line between your business and personal life. It drastically simplifies tax preparation, provides a clear audit trail, and helps protect your personal assets from business liabilities. In Beancount, this means your transactions are cleanly sorted from the start—no more trying to remember if that coffee purchase was a client meeting or a personal expense.

2. Pick Cash or Accrual Early—Then Stick to It​

Your accounting method determines when you record income and expenses. The IRS allows most small businesses to choose between the cash or accrual method.

• Cash basis: You record income when money hits your account and expenses when money leaves it. It’s simple and ideal for businesses with straightforward, immediate transactions.
• Accrual basis: You record income when you earn it (e.g., when you provide a service) and expenses when you incur them, regardless of when cash changes hands. This provides a more accurate picture of profitability, especially if you manage invoices or insurance claims with delayed payments.

The key is to choose one method early and apply it consistently. You can even declare your choice in your ledger using Beancount's options block to formalize the decision.

3. Reconcile on a Cadence​

Reconciliation is the process of matching the transactions in your Beancount ledger against your official bank and credit card statements. Performing this check on a regular cadence—whether weekly or monthly—is a crucial habit. It allows you to catch bank fees, spot potential fraud, and identify any data import errors before they compound into a major headache. A quick command can show you the balance to check against your statement.

bean-balance books.bean "Assets:Bank" -e 2025-07-31

4. Automate Imports Wherever Possible​

Your time is better spent serving clients than manually typing transaction data. Beancount’s ecosystem shines here. Use tools like bean-extract to create configurations that read CSV files from your bank, payment processor (like Stripe or Square), or EHR system. Once set up, these scripts can automatically convert raw data into formatted Beancount entries, dramatically reducing typos and freeing up hours of administrative work.

5. Categorize Immediately—Not at Tax Time​

Procrastinating on categorization is a recipe for stress and inaccuracy. When a transaction enters your ledger, assign it to the correct account immediately (e.g., Income:Therapy:SelfPay, Expenses:Software:EHR, Expenses:CEU). Doing this in real-time ensures you correctly remember the context of each expense. A well-defined chart of accounts makes this process fast and consistent, turning your ledger into a rich, real-time report on your business operations.

6. Save Digital Copies of Every Receipt & EOB​

Paper receipts fade and get lost. A digital-first approach is more resilient and efficient. Scan paper receipts or save PDF invoices and Explanations of Benefits (EOBs) to a secure, organized folder on your computer. With Beancount, you can link directly to these files from within your ledger using metadata.

2025-07-15 * "CEU webinar"
  Expenses:CEU            79.00 USD
  Assets:Bank:Practice
  document: "docs/ceu/2025-07-15-trauma-webinar.pdf"

This creates an unimpeachable, self-contained record that is invaluable during a tax audit.

7. Monitor Cash-Flow Trends, Not Just Balances​

Knowing your current bank balance is good; understanding the flow of money in and out of your business is better. Use Beancount's powerful query language to analyze your financial trends. Chart your monthly income versus expenses, identify your most profitable services, or forecast potential cash crunches during slower months. This proactive approach, recommended by top bookkeeping guides, allows you to make strategic decisions rather than reacting to financial surprises.

8. Back Up & Version-Control Your Ledger​

Since your Beancount ledger is a simple text file, you can use Git—a powerful, free version control system—to manage it. By keeping your ledger in a private Git repository (on a service like GitHub or GitLab), you get two critical benefits for free:

1. A complete history: You can see every change ever made to your ledger.
2. An off-site backup: Your data is safe from local hardware failure.

Make it a habit to "push" your changes after every reconciliation session.

9. Review Financial Statements Monthly​

Don't wait for your accountant to tell you how your business is doing. At the end of each month, use Beancount's reporting tools to generate key financial statements like an income statement and a balance sheet. Compare them to the previous month or the same month last year. This regular review helps you spot spending leaks, evaluate your pricing, and build the financial literacy needed to answer questions from lenders or investors with confidence.

bean-report books.bean income_statement -e 2025-07-31

10. Budget for Taxes Year‑Round​

For a self-employed professional, tax day should never be a surprise. Treat your future tax bill as a recurring expense. Create liability accounts in Beancount (e.g., Liabilities:Tax:Federal, Liabilities:Tax:State) and regularly transfer a percentage of every payment you receive into these virtual buckets. When it's time to make your quarterly estimated tax payments, the money will be set aside and waiting, making the process entirely painless.

Quick‑Start Checklist​

• Open separate practice bank accounts.
• Choose cash or accrual and record it in your options.
• Script your bank & EHR CSV imports with bean-extract.
• Tag every transaction with a category upon arrival.
• Reconcile weekly; back up to your private Git repo after.
• Run monthly statements & cash-flow queries.
• Transfer a tax buffer to a separate high-yield savings account.

Ready to calm your books?

Install Beancount, commit your first entry, and let these ten habits provide the structure needed to keep your therapy practice financially grounded and insight-rich. Happy bean-keeping!

Hand-stitched ledgers beat tangled spreadsheets—especially when every cent counts.

For the artists, makers, and curators on Etsy, passion drives the business. But as your shop grows, financial clarity becomes just as important as creative vision. Juggling fees, tracking material costs, and preparing for taxes can feel overwhelming, pulling you away from the workbench.

What if you could manage your shop’s finances with the same care and precision you put into your products? This guide introduces a plain-text accounting workflow using Beancount, an open-source engine designed for accuracy and control. It’s a method that helps you master your numbers so you can focus on your craft.

Why Etsy Bookkeeping Is Different​

An Etsy shop has a unique financial fingerprint, with complexities that generic accounting software often misses.

• Marketplace fees everywhere: Your final payout is what's left after Etsy takes its share. Listing fees, transaction fees, payment processing fees, and advertising costs all nibble away at every sale. Without tracking them individually, you can't know your true profit margins.
• Platform-controlled sales tax: In a huge win for sellers, Etsy now automatically calculates, collects, and remits sales tax on your behalf in most states. However, if you sell on other channels or have a physical presence in certain states, you might still have your own sales tax obligations due to "nexus" rules.
• Flexible payout cadence: Depending on your settings and account history, Etsy can deposit your funds daily, weekly, bi-weekly, or monthly. This flexibility can make cash flow feel unpredictable, especially when funds are held in reserve or delayed. (Etsy Help)
• Lower 1099-K thresholds: The days of flying under the tax radar are over. The IRS reporting threshold for Form 1099-K, which reports your gross sales, is set at $5,000 for 2024 and is planned to drop to just$600 by 2026. This means nearly every shop will receive an IRS form, and your books must be able to reconcile with it perfectly. (IRS)

Beancount Blueprint in Seven Quick Steps​

This plain-text blueprint will help you build a clear, accurate, and stress-free bookkeeping system.

1. Separate Channels Up Front​

If Etsy isn't your only sales channel, create separate income and expense accounts for each one. This simple separation at the top level of your chart of accounts keeps your analytics clean and makes tax time much easier.

2025-07-22 open Income:Etsy               USD
2025-07-22 open Expenses:Etsy:ListingFee   USD
2025-07-22 open Assets:Etsy:Payout         USD

2. Explode Every Payout​

Never record an Etsy deposit as a single line of income. Instead, download your monthly Payment Account CSV from your Shop Manager. Use this report to create a single Beancount transaction that "explodes" each deposit into its gross sales and individual fee components.

; weekly payout from the Etsy Payment Account CSV
2025-07-15 * "Etsy Deposit #2025-28"
  Assets:Bank:Operating             1842.77 USD
  Income:Etsy:Sales               -2100.00 USD
  Expenses:Etsy:TransactionFee        136.50 USD  ; 6.5 %
  Expenses:Etsy:PaymentProcessing      66.00 USD  ; 3 % + $0.25 per order
  Expenses:Etsy:ListingFee             14.00 USD  ; $0.20 x 70 renewals
  Assets:Etsy:Reserve                -75.73 USD

3. Track Inventory & COGS with Lots​

For sellers of physical goods, Beancount's "lots" feature is a game-changer for tracking Cost of Goods Sold (COGS). When you buy raw materials, you record them as inventory at a specific cost. When you sell a finished product, you can expense the exact cost of the materials used.

; Purchase bulk materials for inventory
2025-07-01 * "Bulk yarn purchase | Supplier XYZ"
  Assets:Inventory:ScarfBlue     500 ScarfBlue {@ 3.45 USD}
  Assets:Bank:Operating

; Record the COGS when an item sells
2025-07-20 * "Sold Blue Scarf | Order #1234"
  Expenses:COGS                  1 ScarfBlue {3.45 USD}
  Assets:Inventory:ScarfBlue

4. Pick Your Accounting Method Early​

You have two main choices:

• Cash basis: Simple and easy. You record income when the money lands in your bank and expenses when you pay for them. This works well for small, hobby-scale shops.
• Accrual basis: Provides a truer picture of profitability. You record revenue when you make the sale (not when you get paid) and expenses when you incur them. This is better for shops that buy supplies in bulk or sell made-to-order items.

5. Automate Imports​

Save time by automating data entry. The plain-text ecosystem offers several options:

• Use bean-extract with custom rules to parse the Etsy CSV files.
• Configure a bank CSV importer to catch ad charges or shipping labels paid by credit card.
• For advanced users, write a Python script to pull reports directly from the Etsy API.

6. Reconcile Weekly​

Set aside a few minutes each week to check your numbers. Use Beancount's command-line tools to quickly validate your balances and spot any issues like released reserves, refunds, or fee adjustments before the month ends.

# Check the balance of your Etsy holding account
bean-balance books.bean "Assets:Etsy:Payout" "2025-07-21"

# Generate an income statement for the last period
bean-report books.bean income_statement -e 2025-07-21

7. Attach Source Docs​

Create a completely self-contained and auditable record by linking to source documents directly in your transaction metadata. This is perfect for supplier receipts, shipping label PDFs, or purchase orders.

2025-07-12 * "Etsy shipping label for order #4321"
  Expenses:ShippingLabel         4.25 USD
  Assets:Bank:Operating
  document: "docs/labels/2025-07-12-order4321.pdf"

Know Your Etsy Fees (U.S.)​

To get a true picture of your profit, track each fee type in its own expense account:

• Listing fee: $0.20 per item, which automatically renews every 4 months or after a sale. (Etsy)
• Transaction fee: 6.5% of the total order amount (including item price, shipping, and gift-wrapping). (Etsy)
• Payment processing fee: Varies by country, but for the U.S. it's typically 3% + $0.25 per order processed through Etsy Payments. (Etsy Help)
• Subscription (Etsy Plus): An optional $10/month for additional tools.

Sales-Tax & Compliance Tips​

• While Etsy remits sales tax for most U.S. states, be aware that selling on other platforms or having a physical workshop can create additional tax obligations ("nexus"). Track your sales thresholds carefully.
• Once the 1099-K thresholds apply to your shop, ensure your Income:Etsy:Sales total in Beancount reconciles to the gross amount on the form to the cent. (IRS)

Common Pitfalls (and Fixes)​

• Pitfall: Net-deposit accounting.
  • Fix: Always use the payment CSV to break deposits into gross sales, fees, and reserves.
• Pitfall: Stale inventory costs.
  • Fix: Record your supply and material purchases as inventory the moment you buy them. Don’t wait until the finished product sells.
• Pitfall: Refund blind spots.
  • Fix: When issuing a refund, log the expense and also reverse the original COGS entry to move the cost back into your inventory account.
• Pitfall: Ignoring reserve holds.
  • Fix: Open an Assets:Etsy:Reserve account to track money that Etsy is holding. This keeps your cash-flow statements honest.

Quick-Start Checklist​

• In your Shop Manager, set up monthly statements and download your first CSV.
• Clone the Beancount starter repository and sketch out your shop's chart of accounts.
• Decide on cash or accrual accounting and commit to it.
• Write a basic importer script or rules file and schedule a weekly sync.
• Reconcile your payouts, inventory levels, and bank balance every Monday.
• Generate an income statement each month and review your gross margin trends.
• Back up your .bean files using Git and an off-site storage solution.

Ready to stitch bookkeeping into your creative workflow? Install Beancount, commit your first entry, and let plain-text clarity free up more time at the workbench. Happy bean-keeping!