Every software project is built on layers of other people’s work. Libraries, packages, tools — most of them invisible, all of them essential. There’s a good chance your project depends on code written by someone you’ve never heard of. Someone who doesn’t work for a big company. Someone who maintains their project in the evenings, between dinner and sleep.

I want to talk about what it’s like to be on the other side of that equation.

The invisible layer

For years, I’ve maintained an open source package called Mozart. It solves a specific problem in the WordPress ecosystem: it helps plugin developers avoid conflicts when multiple plugins use the same third-party libraries. It’s not glamorous work. There are no conferences about dependency namespacing. Nobody writes Twitter threads about how it changed their life.

But Mozart is used. It runs silently in the build pipelines of some of the largest WordPress plugins out there, including WooCommerce — a plugin that powers a significant chunk of online commerce and generates millions in revenue every month. Over the past couple years, Mozart has been downloaded over 3 million times.

I don’t say this to brag. I say this because it illustrates something important: the gap between the value open source software provides and the support its maintainers receive.

The maintainer’s dilemma

Here’s what maintaining an open source project actually looks like: it’s evenings and weekends. It’s reviewing issues during your lunch break. It’s guilt when you don’t have time to respond to a bug report. It’s watching contributors who were once enthusiastic slowly fade away because they, too, have jobs and families and other priorities.

I’m currently working towards the first major release of Mozart in five years. Five years. Not because the project was abandoned, but because finding the time to work on something that generates essentially no income is genuinely hard. Every hour spent on Mozart is an hour not spent on paid work, or with my family, or simply resting.

This isn’t a complaint. I chose to build Mozart. I chose to make it open source. I believe in the principles behind it. But I also think we need to be honest about the reality: open source maintainers are often running on fumes, sustained by passion alone, while the software they create generates enormous value for others.

The asymmetry

If this sounds familiar, it should. The WordPress community spent months watching a very public fight about this exact issue: companies profiting from open source without contributing back. The conflict between Automattic and WP Engine made headlines, sparked lawsuits and divided the community.

I’ve been vocal about how that conflict was handled. The collateral damage to end users and the broader community was unacceptable. But the underlying point remains valid. There’s an imbalance between those who profit from open source and those who maintain it.

Here’s the irony, though. That fight played out between two companies with lawyers, PR teams and millions of dollars at stake. It made the news precisely because the players were big enough to make noise.

Meanwhile, the same dynamic plays out every single day at a smaller scale, in complete silence. Individual maintainers, working in their spare time, building the foundations that commercial products depend on. No lawsuits. No headlines. Just people quietly burning out while others profit from their work.

WooCommerce uses Mozart. WooCommerce is owned by Automattic. Full disclosure: I spent two years as one of WooCommerce’s early developers. No bad blood there. But it’s hard not to notice the irony. A project I once helped build now depends on one I maintain in my spare time. The dynamics haven’t changed.

I’m not saying this to single anyone out. This pattern repeats across the entire software industry. Billion-dollar products built on the backs of projects maintained by people in their spare time. It’s not malicious. It’s just how things are. And that’s exactly the problem.

This isn’t unique to me

My situation is not special. It’s typical.

Talk to any open source maintainer and you’ll hear variations of the same story. The constant pull between wanting to contribute and needing to pay bills. The slow burnout. The feeling of being taken for granted. The quiet resentment when a company worth more than you’ll ever see, asks for free support.

Some maintainers have found ways to make it work. Sponsorships, paid support tiers, consulting. But for most of us, open source remains a labour of love that we squeeze in around the edges of our actual lives.

The ecosystem we’ve all come to depend on is held together by people who are, frankly, not being compensated fairly for their work.

Awareness as a first step

I’m not asking for pity. What I’m asking for is awareness.

The next time you add a dependency to your project, take a moment to think about who maintains it. Check if they have a way to receive support. Consider whether your company might sponsor the tools it relies on.

And if you’re a maintainer yourself, know that you’re not alone in this. The struggle to balance open source work with everything else in life is real, and it’s shared by thousands of developers around the world.

Open source has a funding problem. It’s systemic, it’s structural, and it won’t be solved by individual actions alone. But awareness is the first step. And maybe, if enough of us start paying attention to the invisible layer that holds our software together, we can start building something more sustainable.