S1E7.5 – OSSPledge: urging tech to step up
And pay up. But is it necessary?
What’s cool about OSSPledge?
Here’s a riddle: how do you fund a global “public” good like open source software?
The Open Source Pledge answers this question with a single number: $2,000 per developer, per year.
By introducing $2,000 / dev as an anchor, CFOs and managers now know the figure. Engineering leads know the expectation. Maintainers know the scale of support they could ask for if this OSSPledge sticks.
What is fascinating is that this now has the potential to change norms and opinions. Once you start saying “two grand per developer,” suddenly there’s a benchmark. If your company has 25 developers, you’re on the hook for $50,000 annually in supporting open source software.
That reframing is the key here: it’s no longer optional, feel-good charity. It’s now part of the cost of doing business – that is, and this is the big caveat: if you care.
This entire proposal hinges on that: whether people care enough to push their companies towards taking the pledge, or elevating the pledge to the level of policy.
The pledge is important because this all can be much like paying office rent or dealing in AWS credits in terms of convenience, only this rent pays the people patching your software dependencies.
And because companies publish annual reports on where the money goes, this new expense doesn’t just collect dust in some company policy documents drawer or the bottom of the stack of some marketing blog. It now turns into public accountability.
For decades, support for open source has lived in abstractions and platitudes: “be a good citizen,” “contribute back”…similar to how some countries treat their veterans (some form of social acumen and pride, with much, much less in the way of support for services to care for those who’ve provided military services).
The OSSPledge aims to rewrite these cultural norms, with precise dollar quantities attached and a convenient mechanism to make it happen.
Since launching, OSSPledge signatories (starting with Sentry and joined by other Scary Big Companies) have reported millions flowing to maintainers and foundations. The PHP Foundation, Ruby Central, OpenSSL — substantial open source projects now directly benefiting from this “movement”.
$2,000 is not the “perfect” number. The point is that there is a number, and with that more hope in shifting support for open source maintainers from ad-hoc tips to a more systematic funding.
A maintainer once described the support they received through the Pledge as “the first time I could think in years, not months.” There’s huge potential in that, given the size of features and the length backlogs and bug lists, and the time pressures beset on developers.
Will this be a net-positive contribution to the world of open source?
On the mixing of open source and money
We must start this meditation with an expansion in the range (or scope) of what we consider economics to be responsible for studying and explaining.
We often think economics is limited to supply and demand, markets, entrepreneurship and corporations – concepts, institutions, norms and activities that stem from the logic of quid pro quo transactions. While this logic and its implications are valuable for us to study, they are only a narrow subset of the vastness of human activity.
For our purposes, it means that this logic is too limiting to be useful in explaining curious behaviors like people collaborating in their spare time and no financial reward to create open source software. The weird world of open source, too, is economics.
We can now consider economics a much broader practice – a framework, if you will – that we use to explain human behavior in its blooming, ever-changing strangeness. Certainly why we buy and sell – and how and when and under which circumstances – but also why we gather, cooperate, lie, trust and love. Why we pay to watch other people play video-games, why we have hobbies and go to concerts, and why we stand in lines to buy crap we don’t need, or even want.
Economics is weird precisely because humans are weird, because we are not rational simpletons that act the same way every time we shop, call a friend, go for a walk or decide who to marry, what career to pursue, what good music sounds like or whether we should go out for dinner or cook at home.
We are passionate and irrational, but we are also cooperative and intrinsically motivated. When people stress that humans are more than rational, they usually overemphasize the first two – passion and irrationality. But its the last two possibilities of human behavior – cooperativeness and intrinsic motivation – are the stuff of which open source software is primarily made of.
Neither the theory of the commons – how common pool resources are owned managed and used nor the Coase Theorem of the firm – why production is best organized within institutions, companies and organizations – are enough to explain open source software production.
Because of the particular dynamics between contributors, maintainers and users for each project, not all open source software can be understood as mere commons. Nor can we say that all of them should be developed under market-based terms. It’s a mix of both approaches and of many other variables at play, including the most fundamental one: the personal motivations of the people who develop them.
Software has the weird quality of approaching zero in terms of marginal cost. This little quirk is responsible for trillions of dollars in todays economy: people buy and sell software, and companies invest seriously frightening sums of of capital to build the infrastructure that allows them to profit from it.
But/and it’s also, surprisingly and ironically, the same core principle that lets open source maintainers reject the idea of charging or getting paid for their open source contributions. Open source is a legitimate and proven mechanism for producing high-quality software; software that can be as good, and as bad, as software made by companies. Software that is, in fact, a critical dependency for most of the software products and systems in existence today.
And thus, we now come back to the Open Source Pledge. It doesn’t solve every sustainability problem in software, and it doesn’t aspire to. But it does pose an intriguing challenge: what happens if we set a price tag (per developer) on the existence and, dare I say, survival of open source?
We know from projects like the web app framework Ruby on Rails that open source can not only survive but thrive without subscribing to market-based dynamics. But what if there’s a sudden influx of cash that is itself rooted in peer pressure and appeals to lofty ideals like the commons, or social responsibility? Cash thrown at open source that is slightly outside of market-based dynamics.
Now imagine a critical mass of companies adopting it. That’s billions of dollars a year flowing as infrastructure investment. Real-world investments, in real-world software, that are not pegged directly to the whims, cycles, droughts and bubbles of venture capital funding.
Do not lose sight that at the core of Open Source Pledge there is a completely arbitrary – manufactured? – belief: that you should pay for open source! Like we’ve said before: that is simply not an absolute truth but only one possibility of many. It is similar to the belief, the social-constructed illusion, that a piece of paper with some fancy stamps and the words “In God We Trust” has any value.
It’s a cry for social responsibility at an unprecedented scale, and a cool experiment. We’ll see how open source software is impacted by it – if at all – and how open source evolves in the bumpy years to come.
Essential questions
1. What happens when we assign a fixed price to something previously treated as “free”?
Assigning a price to “free” software is less about monetizing it and more about reframing its value. For decades, companies built billion-dollar businesses on dependencies maintained by volunteers. Gratitude was expressed through conference talks or swag, but the balance sheet showed zero. By introducing a concrete number, Open Source Pledge forces companies to treat open source as infrastructure — as something that costs money to sustain, like office space or electricity.
This shift has ripple effects. A fixed price means maintainers can make future plans, not just hope for one-off donations. It means CFOs can evaluate whether they are over- or under-investing relative to peers. And it means the broader ecosystem can finally measure the gap between “usage” and “support.” The number might not be perfect, but the act of naming it creates a floor — and once a floor exists, companies are less likely to race to the bottom.
2. How does a single number ($2,000/dev/year) shift the culture of responsibility in open source?
Culture is sticky, and vague norms don’t change it. For years, “contribute back” was the mantra — but that phrase could mean anything from filing a bug report to funding a foundation. The brilliance of the $2,000 figure is that it turns a fuzzy ideal into a measurable responsibility. It offers both a ceiling and a floor: enough to be meaningful, but simple enough to calculate without endless debates.
This clarity rebalances the power dynamic between companies and maintainers. Companies can’t hide behind excuses of uncertainty or complexity — they know exactly what responsible support looks like. Maintainers, in turn, gain leverage to say: “Here’s the norm. If you’re benefiting from our work, where’s your contribution?” One number becomes a cultural anchor, setting expectations the way emissions targets or minimum wages do in other domains.
3. What’s the difference between gratitude and obligation in open source?
Gratitude is what you feel after unwrapping a gift; obligation is what you owe when the roads you drive on need fixing. Open source has long lived in the gratitude zone — companies thanking maintainers for their hard work, sometimes sending stickers or a thank-you tweet. But that dynamic left maintainers underfunded, insecure, and exhausted. Gratitude doesn’t pay rent.
Obligation changes the social contract. By framing support as a duty — a recurring financial responsibility tied to headcount — the Open Source Pledge moves open source out of the gift economy and into the infrastructure economy. Obligation is less romantic, but it’s more durable. And it’s precisely this shift, from “thanks” to “line item,” that can transform open source from a fragile commons into a sustainable foundation for everything built on top.