Aplos and RestrictedBooks Are <$100/Month and Purpose-Built for Nonprofits—Why Would You Choose Beancount Instead?

accountant_alice · April 5, 2026, 3:24am

I’ve been working with a small nonprofit client (annual budget ~$250K) who’s been shopping for accounting software, and we keep coming back to this question: When affordable, purpose-built solutions exist, does Beancount actually make sense for nonprofits?

The Commercial Landscape in 2026

The nonprofit accounting software market has matured considerably:

Aplos ($79-$229/month): Combines fund accounting, donor management, and online giving in one platform. They’ve built everything nonprofits need—restricted fund tracking, Form 990 reports, grant management, donor portals. User ratings are solid (4.5/5), and their support team actually understands nonprofit accounting.

RestrictedBooks ($20-$249/month): Purpose-built for fund accounting with native restriction enforcement, grant tracking, and compliance reporting. Flat-rate pricing means no surprise per-user fees as you grow.

Both are under $100/month for small organizations. That’s $1,200/year, or 0.48% of a $250K budget—basically a rounding error.

The Beancount Value Proposition

So why would I recommend Beancount instead? Here’s what I’m weighing:

Arguments FOR Beancount:

Long-term cost: $100/month = $6,000 over 5 years. Beancount is free (though requires technical time investment).
Data sovereignty: Own your financial records completely. No vendor lock-in, no “our company was acquired and the new owner shut down our product” surprises.
Customization: Commercial software has opinionated workflows. Beancount adapts to YOUR structure, not vice versa.
Longevity: Companies go out of business. Plain text files last forever. Twenty years from now, you can still cat ledger.beancount and read your finances.
Transparency: For nonprofits especially, being able to publish your ledger to GitHub for donor verification is powerful. Try doing that with QuickBooks.

Arguments AGAINST Beancount:

No support: Stuck at 11pm before a board meeting? With Aplos, you call support. With Beancount, you’re Googling forum posts.
Auditor unfamiliarity: CPA firms know QuickBooks and Aplos. Showing them plain text files might trigger “this is weird, I’m charging extra” responses.
Board risk perception: “We use open-source accounting software” sounds risky to conservative board members who expect “industry-standard solutions.”
Technical dependency: If the person who set up Beancount leaves, can the replacement maintain it? With commercial software, any bookkeeper can jump in.
Missing features: Aplos has donor portals, online giving forms, event registration. You’re not building those with Beancount.

The Math Doesn’t Favor Beancount…Or Does It?

Here’s what’s nagging at me: At the $200K-$500K budget level, $1,200/year for software is negligible. A nonprofit at this scale should just pay for Aplos and focus on their mission, right?

But then I think about:

The nonprofit software graveyard (how many vendors have disappeared over the years?)
Vendor lock-in costs (switching software later = data migration nightmare)
Customization limits (what if your grant reporting needs don’t fit their templates?)
The value of transparency (donors verifying your books themselves via published ledger)

My Question for the Community

For those who’ve worked with nonprofits using Beancount:

What made Beancount the right choice over commercial software?
How did you convince the board/auditors?
What features are you missing that commercial software provides?
Has the technical investment been worth it?

And the broader philosophical question:

At what organization size does Beancount make sense for nonprofits? Only for large orgs where enterprise software costs ($10K+/year) are painful? Or is there a case for it even at the small nonprofit level?

I’m genuinely torn on this one. The software engineer in me loves Beancount’s elegance and transparency. The CPA in me sees $79/month Aplos and thinks “this is a solved problem, don’t overthink it.”

What am I missing?

References:

Aplos Pricing & Features - $79-$229/month with 15-day free trial
RestrictedBooks Overview - $20-$249/month flat-rate
Beancount for Transparency - Nonprofits publishing ledgers for donor verification

helpful_veteran · April 5, 2026, 3:24am

Great question, Alice! I’ve been through this decision-making process myself, though from the donor side rather than as an accountant.

My Experience as a Donor

I serve on the board of a small environmental nonprofit (annual budget ~$180K), and three years ago we faced exactly this choice. We went with Beancount, and here’s why it worked for us:

The transparency argument actually mattered. We publish our ledger (with sensitive donor info redacted) on GitHub. Our largest funder—a family foundation that gives us $50K/year—explicitly told us this was a deciding factor in their continued support. Being able to git clone our books and verify the numbers themselves gave them confidence that no commercial software “trust us” dashboard could match.

The technical dependency risk is real, but manageable. Yes, our bookkeeper (who knows Beancount) leaving would be painful. But here’s the thing: our Beancount setup is 3 files—ledger.beancount, accounts.beancount, and a simple Python importer for our bank. If she got hit by a bus tomorrow, I could maintain it with my rusty Python skills. Compare that to QuickBooks where we’d be locked into finding someone who knows their specific nonprofit edition.

The cost savings matter more than you think. You said $1,200/year is negligible for a $250K budget, and mathematically you’re right. But psychologically? When we eliminated our $89/month software subscription, that money went directly into program expenses. Our exec director literally said “that’s 3 months of food for our school lunch program.” Every dollar counts differently in the nonprofit world.

Where Beancount Falls Short

You’re absolutely right about the missing features. We don’t have:

Donor portal (we email quarterly reports instead—old school, but donors say they appreciate the personal touch)
Online giving forms (we use a separate service—Donorbox—which is fine)
Event registration (we use Eventbrite)

So we’re using multiple tools instead of one integrated platform. Is that ideal? No. But each tool costs $0-$30/month and does its ONE job really well.

The Scale Question

Here’s my controversial take: Beancount makes MOST sense for small nonprofits ($100K-$500K budgets), not large ones.

Why? Because:

Large nonprofits ($5M+ budgets) need enterprise features and can afford enterprise software. They should use Intacct or Sage.
Tiny nonprofits (<$100K) can use QuickBooks Self-Employed or even spreadsheets—their needs are simple.
Mid-size nonprofits ($100K-$500K) are in no-man’s land. Too complex for simple tools, too small for enterprise solutions. This is where Aplos/RestrictedBooks target—and where Beancount shines if you have technical capacity.

The Board Conversation

How did we convince our board? Our bookkeeper did something brilliant: she ran BOTH systems in parallel for 3 months (Aplos trial + Beancount), then showed the board:

Identical financial reports (balance sheet, P&L, cash flow)
The Beancount Git history showing every change
A demo of querying the ledger with BQL
The cost comparison ($1,068/year saved)

The board vote was unanimous. The transparency + cost savings + “we can fire our bookkeeper if she’s terrible and still access our books” argument won.

Bottom Line

You’re not missing anything—the tension you’re feeling is REAL. For most nonprofits, Aplos is the smart, safe choice. But if you have:

A board that values radical transparency
Technical capacity (or willingness to learn)
Funders who appreciate open books
Customization needs that commercial software doesn’t handle

Then Beancount is worth considering. It’s not for everyone, but when it fits, it really fits.

P.S. Our three-year Beancount anniversary is next month, and we’re celebrating by publishing our full financial history (2014-2026) to GitHub. Feel free to check it out if you want to see a real nonprofit Beancount setup in action.

bookkeeper_bob · April 5, 2026, 3:25am

This hits close to home—I just LOST a nonprofit client over this exact issue.

The Client I Lost

Church with $120K annual budget. I pitched them on Beancount because I genuinely believed it was the right technical solution:

Better audit trail than QuickBooks
Metadata tags for tracking 5 different designated funds
Git history for accountability
Free software means more money for ministry

Their response? “We want what the church down the street uses—Aplos. It has training videos. Our volunteers can learn it. And if you’re not available, any bookkeeper can help us.”

I lost the client to someone who charges MORE than me but offers Aplos setup. Brutal lesson learned.

What I Should Have Led With

Here’s what I got wrong: I led with technical superiority instead of risk mitigation.

Nonprofits—especially small ones—are TERRIFIED of accounting mistakes. They worry about:

IRS audits (losing tax-exempt status)
Funder audits (grant money must be tracked perfectly)
Board liability (mismanagement of donor funds)

When I said “use Beancount,” they heard “use this unconventional thing that our auditor has never seen and might flag as risky.”

When my competitor said “use Aplos,” they heard “use the industry-standard tool that 10,000+ other nonprofits trust.”

Perception of safety mattered more than actual capability.

Where Beancount Actually Won

I DO have one nonprofit client successfully using Beancount: community arts organization, $200K budget, managing 8 different grants simultaneously.

Why it worked:

Technical board member: Their treasurer is a retired software engineer who LOVES that he can git diff to review changes before board meetings.
Complex reporting needs: They have one funder who requires custom expense allocation reports that don’t fit standard templates. With Beancount + Python, we generate exactly what they need. With Aplos, we’d be exporting to Excel anyway.
Prior bad experience: They got burned by a vendor (different nonprofit software) that shut down with 60 days notice. Now they’re allergic to vendor lock-in.
Engaged bookkeeper: Their part-time bookkeeper (20 hrs/month) was willing to learn Beancount. She came from a GnuCash background, so plain text made sense to her.

That’s a LOT of stars aligning, though.

My Honest Advice

Alice, for your $250K client, I’d ask:

Does the client have technical leadership? If yes (board member who codes, exec director comfortable with Git), Beancount is viable. If no, you’re setting them up for failure.

Do they have weird reporting needs? If they’re managing federal grants with SF-425 reports, state grants with different formats, AND foundation grants with custom requirements—Beancount’s flexibility might be worth the complexity. If they just need standard balance sheet + P&L for one funder, Aplos is fine.

What’s their risk tolerance? Conservative board that wants “industry standard”? Go with Aplos. Progressive board that values transparency and data ownership? Pitch Beancount.

Can you commit to long-term support? This is the big one. If you set them up on Beancount and then they can’t find anyone to maintain it when you move on, you’ve done them a disservice.

The Ecosystem Gap

What the Beancount community REALLY needs for nonprofit adoption:

“Beancount for Nonprofits” package: Pre-configured chart of accounts, account structure templates, common fund accounting patterns, sample ledger for a small nonprofit.
Form 990 report generator: Even if it’s just generating the supporting schedules (990 Schedule A, Schedule O), that would be huge.
Auditor education materials: One-page PDF explaining “What is plain text accounting and why it’s actually MORE auditable than commercial software.”
Migration tools: QuickBooks-to-Beancount converter that actually works for nonprofit fund accounting.

Without these, we’re asking every nonprofit to reinvent the wheel.

My Recommendation

For your client? If they asked me, I’d say: “Start with Aplos for 6 months. If you hit limitations (weird reporting needs, high costs at scale, vendor lock-in concerns), THEN we talk about Beancount.”

Don’t make them beta testers for plain text accounting unless they’re genuinely excited about it. The missionary zeal we have for Beancount isn’t necessarily what they need—they need safe, reliable bookkeeping that lets them focus on their mission.

Harsh reality: most small nonprofits should probably use commercial software. Beancount is for the 10% who have specific needs that commercial software doesn’t meet.

finance_fred · April 5, 2026, 3:25am

Different perspective from someone who’s not an accountant but DOES track nonprofit donations obsessively:

Why I Care About This as a Donor

I’m on the FIRE journey (aiming for $1.2M and early retirement at 45), and part of my philosophy is strategic giving—donating to effective nonprofits that align with my values. This year I’m giving ~$15K to 5 organizations.

I WISH every nonprofit I donate to used Beancount.

Here’s why from the donor side:

The Donor Trust Problem

When I donate $3K to an environmental org, I have ZERO visibility into how it’s spent. I get:

A thank-you email
A year-end tax receipt
Maybe a quarterly newsletter with vague “your support funded 200 trees” claims

But what I WANT is:

Actual transaction-level transparency
Ability to verify my donation shows up in their books
Understanding of overhead vs program spending AT THE TRANSACTION LEVEL
Proof that restricted donations go to restricted purposes

Beancount enables this. Commercial software doesn’t.

The Transparency ROI

Helpful_veteran mentioned their nonprofit publishing ledgers to GitHub—that’s EXACTLY what I want to see. If a nonprofit said “here’s our complete financial history, git clone it and verify for yourself,” I would:

Increase my donation (transparency earns trust = bigger gifts)
Tell other donors (word-of-mouth is huge in EA/FIRE circles)
Commit to multi-year giving (I know they’re legit)

The “cost” of implementing Beancount ($0 software + setup time) gets PAID BACK in donor confidence that translates to larger gifts.

The Hidden Cost of Commercial Software

You’re framing this as “$1,200/year for Aplos vs $0 for Beancount,” but that’s not the full picture:

Aplos Total Cost of Ownership (5 years):

Software: $1,200/year × 5 = $6,000
Training: ~$500 (staff time learning new system)
Data migration if you switch later: $2,000-$5,000 (consultant fees, data cleanup)
Total: ~$8,500-$11,500

Beancount Total Cost of Ownership (5 years):

Software: $0
Initial setup: ~$1,500 (consultant time to design account structure, write importers)
Ongoing maintenance: ~$200/year (debugging, updates) = $1,000
Total: ~$2,500

Savings: $6,000-$9,000 over 5 years.

For a $250K budget nonprofit, that’s 2.4-3.6% of ONE year’s budget freed up for programs. Or, framed differently, that’s 30-45 hours of program coordinator salary.

When Beancount Makes Financial Sense

Here’s my spreadsheet analysis (yes, I built a model for this):

Break-even calculation:

Aplos cost: $1,200/year
Beancount setup: $1,500 one-time + $200/year maintenance
Break-even: Year 2 ($1,500 + $400 = $1,900 < $2,400 Aplos cost)

By Year 5:

Aplos cumulative cost: $6,000
Beancount cumulative cost: $2,500
Net savings: $3,500 (58% cost reduction)

For a nonprofit that’s constantly scraping by, that’s not nothing.

The “Technical Dependency” Risk Is Overblown

Bob mentioned the risk of “if your Beancount person leaves, you’re screwed.” But let’s be real:

With Aplos: If your bookkeeper leaves, you need to find someone who knows Aplos specifically. In a small town, good luck.

With Beancount: If your bookkeeper leaves, you need someone who can read plain text files and run Python scripts. ANY developer can do this. Actually, a CS college student could do this.

In the FIRE community, we have tons of software engineers looking for meaningful volunteer work. I’d HAPPILY volunteer 5 hours/month to help a nonprofit maintain their Beancount setup in exchange for… nothing. Just because it’s interesting and helps a cause I believe in.

Try finding someone to volunteer QuickBooks support. Not happening.

My Donor Decision Framework

If I’m evaluating nonprofits to donate to, and I see:

Nonprofit A (uses Aplos):

“We spent 85% on programs, 15% on overhead” (unverifiable claim)
Annual report with pie charts (looks nice, proves nothing)
Audited financials (great, but I’m reading summaries, not transactions)

Nonprofit B (uses Beancount + published ledger):

git clone their repo and verify every transaction myself
Search for my donation: grep "Frederick Chen" ledger.beancount
See exactly how “program expenses” break down by transaction
Verify restricted donations went to restricted purposes

I’m giving to Nonprofit B. Even if they’re slightly less efficient, the transparency is worth it.

Alice’s Question: What Are You Missing?

What you’re missing is the signaling value of radical transparency.

In 2026, donors (especially younger donors like me) are SKEPTICAL. We’ve seen too many nonprofit scandals, too much overhead creep, too many vague impact reports.

Saying “we use Beancount and publish our books to GitHub” signals:

We have nothing to hide
We’re technically sophisticated (attracts tech donors)
We respect donor intelligence (you can verify us yourself)
We’re committed to long-term sustainability (no vendor lock-in)

That signal is worth MORE than $1,200/year in software costs.

Bottom Line for Your Client

Ask them: “Would you rather save $3,500 over 5 years AND attract more donations through radical transparency, or pay for software that looks professional but keeps donors at arm’s length?”

If they’re optimizing for trust and long-term donor relationships (which is smart!), Beancount is a no-brainer.

If they’re optimizing for “what everyone else does” and avoiding perceived risk, go with Aplos.

Just don’t pretend the cost difference is negligible. Over time, it’s material.