Open source isn’t altruism. It’s how you avoid getting surprised

For a long time, I thought I understood what open source was about.

Like many engineers, my early understanding was shaped by its origin story: the hacker ethic, academic collaboration, the idea that software should be shared because it was the right thing to do. I read the books. I absorbed the culture. Open source felt like an ideological movement, and participation felt almost moral in nature.

That story isn’t wrong. But it’s incomplete.

Over time, and across different roles, I’ve learned that open source endures not because of altruism alone, but because it’s one of the few reliable ways to reduce surprise in complex technology ecosystems. When it works well, it doesn’t just distribute code. It distributes power, context and options.

I didn’t fully appreciate that until the rules changed.

When the ground shifted

When HashiCorp announced a license change for Terraform, my first reaction was disbelief.

At the time, Terraform underpinned a significant portion of modern cloud infrastructure. It wasn’t just another tool. It was foundational. Many organizations — vendors and users alike — had quietly assumed that its openness was a constant. The possibility of a sudden shift had been discussed in abstract terms but not seriously anticipated.

When it happened, I expected chaos. Fragmentation. Months of argument before anything meaningful emerged.

Instead, the community responded with something closer to calm urgency. A fork appeared. Governance took shape. Contributors showed up. OpenTofu came into existence far faster and more coherently than most people expected. [Disclaimer: Marcin is the co-founder of the OpenTofu project.]

What struck me wasn’t the fork itself. Forks are easy. What mattered was how prepared the ecosystem turned out to be. The response revealed a latent consensus: many people had already internalized the risk of depending on a project whose direction and decision-making lived behind closed doors.

The episode forced me to confront an uncomfortable truth. The license was technically open, but much of the project’s evolution had not been. It was what we’d today call a vendor-led open source project. Contributions were gated by one organization, and pull request decisions happened privately. When the moment came, there were very few structural barriers to a unilateral change.

In hindsight, the surprise wasn’t that the license changed. It was that we were surprised at all.

Good intentions, hard incentives

It’s tempting to frame these moments as morality plays. Vendor greed versus community values. Control versus freedom.

Reality is messier.

Companies are run by people with principles, but also by boards with incentives. Decisions that feel abrupt or hostile from the outside often emerge from long-running internal tensions: monetization pressure, market expectations, growth targets that never quite feel sufficient.

Watching this play out reshaped how I think about trust. Not trust as a feeling, but as a system property. As ecosystems grow more interconnected, trust can’t rely solely on intent. It has to be supported by structure: transparency, shared ownership and real participation. Without those, even well-meaning decisions can destabilize entire communities.

The Terraform episode didn’t convince me that vendors are bad actors. It convinced me that relying on goodwill alone is a fragile strategy.

Learning by being wrong in public

Another shift in my thinking came from building things in the open and then discovering how often my confidence was misplaced.

More than once, I was convinced a system was finished. Elegant. Complete. Ready.

Then someone from the outside would ask a question or propose a use case that reframed the problem entirely. Not an edge case, but a fundamentally different way of thinking about what the system should enable.

Those moments were uncomfortable. They also accelerated learning in a way no internal roadmap ever could.

When development happens in public, assumptions don’t get to hide. Feedback arrives early, often bluntly, and sometimes from directions you didn’t know existed. Users imagine possibilities builders haven’t yet considered. They stress the design in ways internal teams rarely can.

Over time, that experience changed how I evaluate confidence. A closed roadmap can feel reassuring. An open one feels exposed. But exposure is often where the most valuable corrections occur.

Ecosystems aren’t platforms

One lesson that emerged repeatedly is the difference between platforms and ecosystems.

Platforms centralize control. Ecosystems distribute it.

Healthy ecosystems show certain signals over time: multiple serious contributors, transparent governance, public decision-making and standards that outlast any single tool or vendor. No single entity gets to dictate direction unilaterally. Checks and balances exist not because participants distrust one another, but because they understand how quickly incentives can diverge.

Letting go of control is hard. It slows things down. Consensus takes time. Decisions feel less crisp.

But I’ve seen the alternative up close. When control is concentrated, resilience depends on the continued alignment of one organization’s interests with everyone else’s. That’s a narrow margin for something so many people depend on.

What open source didn’t guarantee

In hindsight, the Terraform moment also clarified something else: openness is not binary.

A permissive license alone doesn’t create a durable ecosystem. Process matters. Participation matters. Design matters.

Only later did I encounter language that articulated what I had been circling. It was the idea of open design: not just open code, but open planning, open decision-making and real community ownership of a project’s direction. Looking back, it was obvious what had been missing. (One framework for this that’s worth reading up on is the Four Opens.)

Naming the concept didn’t change the lesson. It just gave it shape.

The lens I use now

I no longer think of open source as charity, or even primarily as ideology. I think of it as long-term risk management.

Open ecosystems don’t eliminate uncertainty, but they make it legible. They surface tensions earlier. They give participants options when incentives shift. They reduce the blast radius of surprises that are inevitable in fast-moving markets.

That doesn’t mean open source is always the right answer. It comes with tradeoffs: slower consensus, public disagreement and the messy reality of human communities. It requires patience and a willingness to live with ambiguity.

This is simply the lens I use now, a lens shaped by watching systems bend, communities respond and assumptions fail in real time. I’m certain it will keep evolving. Experience has taught me that certainty rarely survives contact with reality.

What I’m confident about is this: In an industry defined by rapid change, fewer surprises are worth a lot. And openness, when practiced fully, remains one of the best ways I know to earn that resilience.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?