A Story That Began with a Question About Open Source
This series began with a simple question: how can free software make money.
At first glance, this question feels contradictory. If something is free, it seems like it cannot generate revenue. And if it generates revenue, it no longer feels free. For a long time, the software industry followed a relatively simple model. A company built software, and customers purchased it. The product was an asset of the company, and the source code was something to be strictly protected. In this structure, the idea of making code public seemed to conflict with business itself.
But open source completely overturned this long-standing assumption. Code could be made public, anyone could use it, and it could even be modified and redistributed. Despite this, countless companies began building businesses on top of it. Open source evolved from a development method into an entire industrial structure, forming a vast ecosystem involving developer communities, companies, and platform providers. This series was a journey through how that ecosystem was created and how it operates.
We began with the reality that most open source projects do not actually make money. While millions of projects exist on GitHub, only a very small number have sustainable economic models. Many projects are maintained through passion and contribution, but that alone is not enough to guarantee long-term maintenance and growth. This is why the same question keeps reappearing in the open source world: what is the difference between building good software and sustaining it over time.
That question was the starting point of the long story of open source business models.
The Tension Between Open Source and Business
The greatest strength of open source is collaboration. Developers around the world contribute to the same codebase, discover problems, improve features, and evolve software together. Compared to traditional closed development models, this structure enables remarkably fast innovation. Much of today’s technology stack—ranging from internet infrastructure and cloud platforms to development tools, databases, and machine learning frameworks—runs on open source.
However, collaboration does not always guarantee economic sustainability. The fact that code is open also means that anyone can use it. Someone can build a product on top of it, and someone else can provide it as a service. In some cases, companies even generate greater revenue than the original creators of the software.
With the arrival of the cloud era, this issue became even more visible. Many open source projects existed as databases or infrastructure software, and cloud platforms began offering them as Managed Services. From a user’s perspective, this was highly convenient—they could use powerful software without worrying about installation or operations. But for the companies behind the open source projects, it created a complex problem. They built the software, yet the largest share of economic value was captured by platform companies.
It was at this point that the tension between open source and business fully emerged.
Why New Models Emerged
The various cases explored in this series were all attempts to solve the same problem in different ways. Some companies chose support- and service-based models. Others adopted the Open Core model, separating community editions from enterprise versions. Still others chose to change their licenses. New licenses such as SSPL and BSL emerged within this broader transformation.
These changes were not simply driven by corporate greed. Rather, they signaled that open source had moved into the center of the industry. When open source was primarily a small-scale experiment within developer communities, these issues were less visible. Today, however, open source is connected to multi-billion-dollar markets, and countless companies build products and services on top of it. As a result, a new structure has emerged where technology and economics are deeply intertwined.
The conflict between Elastic and AWS, and the licensing debates that followed, can be understood within this context. As open source projects grow and become core infrastructure, questions about where the value generated on top of that code flows become increasingly important. This is not merely a legal or licensing issue—it is a question of how the entire open source ecosystem should be structured.
Where Is Open Source Heading
So where is open source headed in the future. It is difficult to provide a definitive answer today. However, one thing is clear: open source is no longer at the periphery of the software industry—it is at its center. Most of the modern technology stack, including cloud, containers, data platforms, and AI infrastructure, is built on open source.
In the future, open source is unlikely to be sustained by simply making code public. The balance between communities, companies, and platforms will become increasingly important. Some projects will continue to follow fully open, community-driven models. Others will adopt stronger commercial strategies. In some cases, entirely new licensing or collaboration models may emerge.
What matters is that even as the form of open source changes, its core values do not disappear. The ability to share code, spread knowledge, and collaborate across boundaries remains one of the most powerful drivers of software innovation. While business models will continue to evolve, the principle of collaboration is unlikely to fade.
In the End, What Remains Is the Ecosystem
At the end of this series, we return to the original question: how can free software make money. By now, it becomes clearer that this is not just a question of economic models.
The way money is generated in open source cannot be explained by a single model. Some companies build revenue through services, others through platforms, and others through licensing strategies. Yet all of these models share one common foundation: the ecosystem.
For an open source project to grow, developers must contribute, communities must form, companies must build products and services on top of it, and users must apply the software to solve real problems. Only when all of these elements are connected does a sustainable structure emerge. And at that point, open source becomes more than just a repository of code—it becomes infrastructure for the entire industry.
In the end, open source is not important because it is free. It is important because it creates a structure that enables knowledge sharing and collaboration. On top of that structure, companies emerge, new markets are created, and technology continues to advance.
Perhaps this is why open source has not disappeared over the past decades, but instead has grown even stronger. And it is likely that many future stories in the software industry will continue to begin with the same question:
In a world where code is shared, where is value created?
