Why the fundraising sector can't learn from itself, and what a commons would change

The fundraising sector can’t learn from itself for two reasons that compound: its data is trapped twice over, siloed inside each institution and reshaped differently by every CRM, and the only way to compare has been to expose donor records, which no responsible shop will do. So every team re-invents its definitions alone, and the hard-won lessons of thousands of organizations never add up to shared knowledge. A commons changes both halves of that. This is the whole argument, in one place.

Why can’t nonprofits benchmark against each other?

Three barriers, each real on its own:

1. Silos. Your data lives inside your institution; your peer’s lives inside theirs. There’s no shared place, and no one wants one if it means handing over donors.
2. Mismatched shapes. Even if you could see each other’s numbers, they wouldn’t line up, because “retention” and “lapsed” mean different things in every shop (why your reports disagree). Comparing them is comparing two different calculations.
3. The privacy wall. Traditional benchmarking asks you to upload donors to a third party. A CISO says no, donors never consented, and the law scrutinizes the transfer, so the shops who’d benefit most opt out.

Trapped twice over

The deepest barrier is structural. Your data isn’t just private (siloed). It’s shaped by whatever CRM you bought, so even with permission it wouldn’t be comparable. One system splits a gift into a commitment and a transaction; another flattens them. One models households as real records; another as a label. Two databases describing the same reality speak different languages, so the sector can’t compare even when it wants to. (That’s exactly the gap a vendor-neutral common data model closes.)

The false choice: insight or privacy

For decades the sector has been handed a false choice: you can have comparison, or you can protect your donors, but not both. Benchmarking meant exposure, so caution meant ignorance. The shops that cared most about donor trust learned the least from their peers, which is exactly backwards.

What a commons changes

A commons dissolves the false choice by separating the two things benchmarking actually needs (a shared question and comparable answers) from the one thing that was never safe to share: the records.

• Shared definitions mean “retention” computed in two shops is the same calculation, so the numbers line up at last.
• Compute-to-data means each organization runs the math inside its own walls and only an aggregate ever leaves, so you compare without exposing a single donor (benchmark without exposing donor data, powered by privacy-preserving analytics).

Why it matters most for the shops with the least

This isn’t an abstract good. The gap between resourced and constrained shops is widening. Analytics and AI raise the bar, big shops clear it, and small shops fall behind serving missions just as worthy. A shared, open foundation is the one thing that closes that gap instead of widening it: it gives a one-person shop the same definitions, the same portability, and the same ability to learn from peers that a large institution can buy. A good foundation shouldn’t need a big budget, and a commons is how it doesn’t.

The through-line

If you’ve followed this blog, you’ve seen the argument arrive in pieces: write your definitions down, separate the promise from the payment, keep your data portable, build the foundation before the AI, compare without exposing. They’re all the same argument. A sector that can trust its own numbers and safely pool what it learns is a sector that gets better together instead of each shop alone.

What you get

A clear picture of why the sector has been stuck, and why it doesn’t have to stay that way: shared definitions plus privacy-preserving comparison turn “we can’t risk it” into “let’s see how we compare.” The sector has always had the knowledge. A commons is how it finally adds up.

Start with the free self-assessment to see where you stand, explore What Becomes Possible, or read why we built this.

Examples use synthetic data. The standard is open and early; treat current releases as drafts.