For a long time, I strongly believed in open source and paying it forward to the developer community.

At the same time, over the years, I’ve grown increasingly skeptical of how open source plays out in developer tooling.

Not because I stopped believing in it, but because I’ve watched too many tools / frameworks I depended on quietly change direction. They start permissive and community-first, gain massive adoption, and then introduce license shifts, feature gating, or enterprise-only tiers once business pressure mounts.

We’ve seen this pattern repeatedly: Terraform > OpenTofu, Redis > Valkey, Elastic > OpenSearch.

After enough of these cycles, it’s hard not to become a little cynical. In some ways, SaaS starts to feel more honest at least the incentives are explicit from day one.

Trying to understand why this keeps happening, one pattern stands out.

Many of the most durable open-source tools and frameworks such as VS Code, React, Kubernetes, and Backstage - were built by companies where the tool itself was not the primary revenue engine. Their core business lived elsewhere.

That mattered.

It meant these tools could function as ecosystem infrastructure rather than direct monetization vehicles. They could stay open because they weren’t carrying payroll, sales targets, and investor expectations on their own.

In contrast, when an open-source project becomes the business, the incentives shift. The tool now has to fund teams, meet SLAs, satisfy investors, and deliver predictable growth.

Over time, that pressure often leads to open-core models, licensing changes, community forks, and growing tension between "community" and "enterprise."

This isn’t about bad intentions. It’s about economics.

The popular "open source first, monetize later" strategy is especially risky. Once adoption takes off and the tool becomes central to a company’s survival, teams are forced into trade-offs that often erode trust and fragment communities.

Open source thrives most easily when it isn’t carrying the full weight of corporate survival.

When it is, preserving its original spirit becomes much harder.

If we want healthier developer ecosystems, we need to be more honest from the start.

Either:

  • build an open-source project as genuine long-term infrastructure and commit to keeping it open, or
  • build a commercial product with a clear monetization model from day one.

Both paths are valid.

Trying to blur the two is what repeatedly leads to broken trust, frustrated contributors, and fragmented communities.