Federal Funding Cuts of 41-55% Proposed for 2026—How Do Nonprofits Model 'What If Our Biggest Grant Disappears?' in Beancount?

accountant_alice · April 5, 2026, 1:00am

I need to share something that’s been keeping me up at night. Three of my nonprofit clients are in a state of near-panic right now, and honestly, I can’t blame them.

The Numbers Are Staggering

The FY2026 federal budget initially proposed cuts of roughly 40% to NIH and up to 57% to NSF. While Congress pushed back and the final numbers aren’t that extreme, the damage is already done in terms of planning uncertainty. The NSF cuts alone would have dropped the number of supported researchers from over 330,000 to just 90,000. Even the reconciled figures mean an estimated 970 fewer new grants in fiscal 2026.

For my nonprofit clients, the question isn’t theoretical anymore: “What happens if our $500K federal grant gets cut by 50%?” And more urgently: “Can you model that scenario RIGHT NOW so we can present it to the board on Friday?”

The Modeling Challenge in Beancount

Here’s where I think our community can help each other. I’ve been building out grant-tracking structures in Beancount using metadata extensively, and I want to share what’s working and get feedback on what could be better.

My current account structure for a typical nonprofit:

; Revenue accounts tagged by funding source
Income:Grants:Federal:NSF:ProjectAlpha
Income:Grants:Federal:NIH:ResearchBeta
Income:Grants:State:HealthDept
Income:Grants:Foundation:CommunityFund
Income:Donations:Individual
Income:EarnedRevenue:ProgramFees

; Expense accounts by program and function
Expenses:Programs:DirectServices:Salaries
Expenses:Programs:DirectServices:Supplies
Expenses:Programs:Research:Equipment
Expenses:Administration:General
Expenses:Fundraising

Using metadata to tag grant attributes:

2026-01-15 open Income:Grants:Federal:NSF:ProjectAlpha
  funder: "NSF"
  grant-period: "2024-2028"
  total-award: "500000"
  annual-amount: "125000"
  status: "at-risk"
  restriction: "research-only"

The Three Scenarios Every Board Needs

When I sit down with a nonprofit ED, I walk through three scenarios using BQL queries against our Beancount data:

Scenario 1 — Maintain Current Programs: Federal funding cut by 50%. Need $250K in replacement revenue. What combination of foundation grants, earned revenue, and individual donations fills the gap? How quickly?

Scenario 2 — Scale Back to Core Mission: Which programs are 100% federally funded vs. diversified? Cut the fully-dependent ones first. What’s the minimum operating budget to keep doors open?

Scenario 3 — Pivot to Fee-for-Service: If federal grants disappear entirely, can program services generate earned revenue? What’s the bridge funding needed for 12 months of transition?

I can run BQL queries to answer questions like:

SELECT account, sum(position) WHERE account ~ "Income:Grants:Federal" 
  AND year = 2025 GROUP BY account

This gives me the federal grant dependency ratio instantly. Combined with expense queries by program, I can show exactly which staff positions are grant-funded and at risk.

The Compliance Angle

Here’s something my nonprofit clients don’t always appreciate until it’s too late: Uniform Guidance (2 CFR 200) continues to reshape compliance expectations. Having every grant transaction tagged with funder, restriction type, and reporting period in Beancount means we have an audit trail that some commercial grant management software can’t match. Git history shows exactly when every allocation decision was made.

But I’m running into limits. Specifically:

Cross-fiscal-year grants — A 4-year NSF grant that starts mid-fiscal-year. How do you model the carry-forward and year-specific allocations cleanly?
Indirect cost rates — Tracking negotiated indirect cost rate agreements (NICRA) and applying them consistently across grants
Budget-to-actual by grant — Generating funder-specific reports that match their required formats (SF-425 for federal, custom templates for foundations)

What I’m Asking the Community

Has anyone used Beancount for real nonprofit grant management? Not personal budgets—actual restricted fund accounting with multiple grant sources?
What account structures work for multi-dimensional tracking? I need to slice by grant, program, function, and time period simultaneously.
How do you handle restricted vs. unrestricted funds? The distinction matters enormously for nonprofits—donor-restricted funds can’t be reallocated without legal consequences.
Has anyone modeled budget scenarios using Beancount scripts? I’m thinking Python scripts that generate projected Beancount entries under different revenue assumptions.

The 34% of nonprofits reporting federal funding declines isn’t a statistic to me—it’s three panicked phone calls this week. The more sophisticated our tools are for modeling these scenarios, the better we can serve organizations doing critical work.

What are you all seeing out there?

helpful_veteran · April 5, 2026, 1:01am

Alice, this is incredibly timely. I’ve been watching the federal funding situation closely because my wife works at a small environmental nonprofit that receives about 40% of its budget from a single federal agency. The anxiety is real.

I want to address your cross-fiscal-year grants question directly because I’ve worked through this problem for her organization.

My Approach to Multi-Year Grants

I use a combination of accounts and metadata that tracks the grant lifecycle separately from the fiscal year reporting. Here’s the pattern I settled on after a lot of trial and error:

; Track the full grant award as a liability (obligation to perform services)
2024-07-01 open Liabilities:DeferredRevenue:NSF:ProjectAlpha
  grant-id: "NSF-2024-1234"
  total-award: "500000"
  period-start: "2024-07-01"
  period-end: "2028-06-30"

; When grant money is received
2024-07-15 * "NSF award received - Year 1"
  Assets:Bank:Operating          125,000 USD
  Liabilities:DeferredRevenue:NSF:ProjectAlpha  -125,000 USD

; As qualifying expenses are incurred, recognize revenue
2024-08-15 * "Recognize revenue for August research expenses"
  Liabilities:DeferredRevenue:NSF:ProjectAlpha  12,500 USD
  Income:Grants:Federal:NSF:ProjectAlpha        -12,500 USD
    grant-id: "NSF-2024-1234"
    fiscal-year: "FY2025"
    reporting-period: "Q1"

The deferred revenue pattern handles the cross-fiscal-year problem nicely. You can query the liability account at any point to see how much unrecognized grant revenue remains, and you can filter by fiscal year or reporting period using the metadata.

Scenario Modeling Script

For the “what if our grant disappears” question, I wrote a Python script that reads the Beancount file and generates scenario projections. The basic idea:

Parse current ledger to find all federal grant income accounts
Apply a cut percentage (25%, 50%, 100%) to each
Generate projected entries for the next 12 months under each scenario
Calculate the resulting cash position month by month
Flag the month where cash hits zero (the “runway” number)

The board doesn’t need to understand Beancount—they need ONE number: “If we lose 50% of federal funding and change nothing else, we run out of cash in 8 months.” That’s what the script produces.

One Important Caveat

Beancount is great for modeling scenarios AFTER your data is clean and structured. But I’ve seen my wife’s org struggle because the REAL challenge isn’t the modeling—it’s that they haven’t been tracking grant expenses with enough granularity to answer these questions in the first place. If your expense transactions aren’t tagged by grant source, no amount of BQL magic will help.

My advice for anyone starting this: get the tagging right first, model second. Even if it means going back through the last 12 months of transactions and adding metadata retroactively. The scenario modeling is only as good as the underlying data.

Has anyone built something similar? I’d love to compare approaches.

bookkeeper_bob · April 5, 2026, 1:01am

I’m going to be the practical voice here and share a cautionary tale from the trenches.

I serve two small nonprofits—a community literacy program and a youth mentoring organization. Combined budget under $400K each. When my clients heard about the proposed NSF and NIH cuts earlier this year, the ripple effects hit them too, even though they don’t receive NIH or NSF money directly. Why? Because their state grants are funded by federal pass-through dollars, and when federal agencies tighten budgets, state agencies pass the pain downstream.

The Real Problem: Nobody Knows Their Numbers

Here’s what I discovered when the panic started. I asked both EDs: “What percentage of your revenue comes from government sources?” One said “maybe 30%?” The actual number from our books was 62%. The other said “about half”—it was actually 71%.

This is the fundamental problem Alice is trying to solve, and I agree Beancount is a great tool for it. But I want to add a ground-level perspective.

What Works for Small Nonprofits in Beancount

For organizations at the sub-$500K level, I’ve found that a simpler structure works better than the full account hierarchy Alice described. Here’s what I use:

; Keep accounts simpler, use metadata for grant tracking
Expenses:Personnel
Expenses:ProgramSupplies
Expenses:Occupancy
Expenses:Professional
Expenses:Other

; Tag EVERY transaction with the funding source
2026-03-15 * "Staff salary - March" #program-director
  Expenses:Personnel                    4,500 USD
    grant: "StateDHS-2025"
    program: "YouthMentoring"
    allocation: "0.60"
  Expenses:Personnel                    3,000 USD
    grant: "CommunityFoundation"
    program: "YouthMentoring"
    allocation: "0.40"
  Liabilities:Payroll

The key insight: for small nonprofits, splitting by allocation percentage at the transaction level is more honest than having separate accounts per grant. A program director doesn’t spend 60% of their time on Grant A and 40% on Grant B in neat blocks—they’re doing both all day. Recording allocations explicitly is more auditable than pretending the work is siloed.

The Dashboard That Calmed a Board

Last month I built a simple Python script that reads our Beancount files and generates a one-page summary:

Revenue concentration chart: Pie chart showing % from each source (government, foundation, earned, individual)
Runway calculation: Months of cash remaining at current burn rate, with and without government funding
Grant timeline: When each grant expires, with 90-day advance warnings
Scenario table: 3 columns showing 0% cut, 25% cut, 50% cut to government funding

I printed this on a single page and handed it to the board chair. His response: “Why haven’t we always had this?” That’s the value of Beancount—not the technology itself, but the clarity it provides when you need it most.

My Honest Assessment

Could you do this in QuickBooks? Technically yes, but the class + custom field system in QBO is a nightmare for multi-grant tracking. In Beancount, I can query any dimension of the data with BQL and script custom reports in Python. For a bookkeeper willing to invest the setup time, it’s genuinely better for this specific use case.

The catch: your nonprofit client needs to understand that plain text accounting requires a technical bookkeeper. If I get hit by a bus tomorrow, my successor needs to know Beancount, Python, and Git. That’s a real risk for organizations running on thin margins.

finance_fred · April 5, 2026, 1:02am

Fascinating thread. I’m coming at this from a different angle—I don’t work with nonprofits professionally, but the scenario modeling problem Alice describes is exactly the same problem FIRE planners face with sequence-of-returns risk. Let me explain.

The Parallel: Grant Cuts = Market Crash for Nonprofits

In the FIRE world, the scariest question is: “What if the market drops 40% in your first year of retirement?” We model this obsessively—Monte Carlo simulations, historical backtesting, variable withdrawal rates.

For a nonprofit dependent on federal grants, the equivalent is: “What if your $500K grant gets cut by 50% in year 2 of a 4-year award?” Same problem, different domain. You need to model the impact on cash runway under multiple scenarios and identify the point of no return.

A Script Architecture for Scenario Modeling

I’ve been building scenario modeling tools for my FIRE projections in Python + Beancount, and I think the architecture translates directly. Here’s the pattern:

# scenario_model.py - conceptual outline
import beancount.loader as loader
from beancount.query import query

def load_baseline(ledger_path):
    """Load current ledger and extract revenue/expense patterns"""
    entries, errors, options = loader.load_file(ledger_path)
    
    # Get last 12 months of federal grant income
    federal_income = query.run_query(
        entries, options,
        "SELECT account, sum(position) WHERE account ~ 'Income:Grants:Federal' "
        "AND date >= 2025-04-01 GROUP BY account"
    )
    return federal_income

def apply_scenario(baseline, cut_pct, replacement_timeline_months):
    """Model impact of funding cut with phased replacement"""
    monthly_shortfall = baseline * cut_pct / 12
    # Assume replacement funding ramps linearly over timeline
    for month in range(1, 25):
        replacement = min(monthly_shortfall, 
                         monthly_shortfall * month / replacement_timeline_months)
        net_impact = monthly_shortfall - replacement
        # Generate projected entries...

def calculate_runway(current_cash, monthly_burn, scenarios):
    """Months until cash hits zero for each scenario"""
    results = {}
    for name, scenario in scenarios.items():
        adjusted_burn = monthly_burn + scenario['monthly_shortfall']
        runway = current_cash / adjusted_burn if adjusted_burn > 0 else float('inf')
        results[name] = round(runway, 1)
    return results

The key output isn’t a ledger—it’s a decision matrix:

Scenario	Monthly Shortfall	Runway (months)	Action Required By
25% cut	$5,200/mo	18 months	Oct 2026
50% cut	$10,400/mo	9 months	Jan 2026
100% loss	$20,800/mo	4.5 months	Immediate

Revenue Diversification as “Portfolio Allocation”

Here’s where my FIRE brain really lights up. Nonprofits should think about revenue diversification the same way investors think about asset allocation:

Federal grants = equities (high yield, high volatility, correlated risk)
Foundation grants = bonds (moderate yield, moderate stability)
Individual donations = cash (low yield, high stability)
Earned revenue = real estate (reliable but requires investment to build)

The advice for FIRE: don’t have more than 60% in equities. The advice for nonprofits should be the same: don’t have more than 60% from any single funding category. Bob’s clients at 62% and 71% government funding are the equivalent of a retiree with 90% in stocks—one bad year away from catastrophe.

The Open Question I’d Love Explored

Could someone build a Beancount plugin that does rolling scenario analysis automatically? Something that reads your revenue accounts, calculates concentration risk by funding source, and generates a monthly “financial health score” with warnings when you’re over-concentrated? Think of it as a bean-check for organizational financial resilience, not just ledger correctness.

The data is all there in the Beancount file. We just need the scripts to make it actionable. I’d be willing to collaborate on building this if others are interested.

accountant_alice · April 5, 2026, 1:02am

These responses are exactly what I was hoping for. Let me synthesize and respond to each:

@helpful_veteran — The deferred revenue pattern is brilliant and I’m embarrassed I wasn’t using it. You’re absolutely right that recognizing grant revenue as expenses are incurred (rather than when cash is received) is the proper ASC 958 treatment, and your Beancount structure makes it clean. I’m going to refactor my nonprofit clients’ account structures this month. And your point about tagging quality being more important than modeling sophistication is one I need to tattoo on my forehead. I’ve been so focused on the output (scenario reports) that I’ve neglected the input (consistent grant tagging on every transaction).

@bookkeeper_bob — The “nobody knows their numbers” problem is painfully familiar. When I asked one of my clients for their federal dependency ratio, the ED literally guessed 35%. The actual number was 58%. Your simpler account structure with metadata-driven allocation tracking is a great approach for smaller organizations. And the one-page board dashboard idea? I’m stealing that. One of my clients’ boards gets a 47-page financial packet each quarter that nobody reads. A single page with concentration chart, runway, and scenario table would be transformative.

But your “hit by a bus” concern is the elephant in the room. I’m actually working on something to address this—a “Beancount Operations Manual” for each client that documents the account structure, import workflows, and how to generate reports. The idea is that any competent bookkeeper who knows Beancount basics could pick it up. Not ideal, but better than nothing.

@finance_fred — The FIRE-to-nonprofit parallels are surprisingly apt. Revenue diversification as portfolio allocation is a framework I’m going to use in my next board presentation. Telling a board “you have 71% in one asset class” speaks their language in a way that “your government funding concentration is too high” doesn’t.

The Beancount plugin idea for rolling scenario analysis is compelling. I think the minimum viable version would:

Calculate revenue concentration by source category (warn if any category > 50%)
Calculate cash runway under current burn rate
Flag grants expiring in the next 90 days
Generate the 3-scenario table (25/50/100% cuts) automatically

If we could run that as a bean-query or Fava plugin that updates whenever the ledger changes, every nonprofit using Beancount would have real-time financial resilience monitoring. That’s honestly better than what most $50K/year grant management software provides.

I’d be interested in collaborating on this. Shall we start a separate thread for the technical design?