Yujong Lee, Co-founder at Char.
Commercial open source is often framed in the wrong way. On one side, you have people who treat open source as a moral commitment that becomes compromised the moment money enters the picture. On the other hand, you have people who assume any open-source company is simply using openness as a temporary go-to-market strategy before closing things down and extracting value later. Both views miss the point.
I love open source as a philosophy, but I don’t believe commercial open source works because founders are idealists who stumble into revenue. I also don’t believe it works because open source is a clever discount tactic. It works because, done right, openness creates a stronger business structure and a larger surface area for value creation than closed software. That argument starts with a simple idea: Source code isn’t the product.
That sounds obvious, but it’s easy to forget—especially now. Code generation is getting dramatically cheaper, and with it comes a growing confusion between software and code, between repository and product and between something that runs and something that reliably solves a problem over time.
Users don’t buy repositories or source trees. They buy outcomes: reliability, support, compatibility, security, trust, maintainability, documentation, operational clarity, migration paths and confidence that what they adopt will keep working. They buy the ability to understand and control what they depend on. They buy peace of mind.
Commercial open source doesn’t work because code itself is scarce or because open source is the cheapest version of something else. It works because openness makes possible a better product around the code—one that earns trust more easily, gives users more control, adapts more flexibly and remains more resilient over time.
This is also why “open source but cheaper” is a weak framing. If your only pitch is cost, you attract the most price-sensitive users. That may generate attention, but it isn’t a strong foundation for a durable business. The cheapest users are rarely the best customers, and most serious buyers—especially in infrastructure, developer tools, security or data systems—aren’t optimizing for sticker price.
They care about whether the product works—whether they can trust it, inspect it, extend it, self-host it, migrate away from it or integrate it into environments more complex than your road map anticipated. They care whether the vendor will still matter in five years and whether they’re safe if the vendor doesn’t.
That’s where commercial open source becomes compelling. Open source creates value not only through lower friction in adoption but through transparency, which is operational. Transparency reduces black-box risk. It makes software easier to evaluate, audit, debug and trust. In categories where control matters, that’s core product value.
In many domains, this will matter even more over time. Partly for regulatory and organizational reasons (more systems now touch sensitive data, business-critical workflows or infrastructure that companies can’t afford to misunderstand ) but also for a simpler reason. As AI makes it easier to build something that looks like software, it becomes more important to distinguish between something that demos well and something that deserves trust.
The easier it becomes to generate code, the more valuable trust becomes. The easier it becomes to assemble functionality, the more valuable clarity, inspectability and long-term resilience become. In that sense, open source matters even more in the AI era.
The value isn’t only human-facing. In developer tools and infrastructure, open source increasingly becomes legible not only to developers but also to agents. If AI systems help operate, debug or extend software, then readable source becomes part of the product environment in a new way. It becomes usable context. It becomes operational substrate.
That doesn’t mean every advantage of open source grows. In some areas, the importance of community-built extensions may change. If generating integrations or plug-ins becomes easier, the old model of ecosystem-building may matter less in some cases.
However, that doesn’t weaken the case for commercial open source. It shifts where the value sits—which is less in the existence of code and more in the quality of the core system: architecture, interfaces, control points, design discipline, reliability and the trustworthiness of the steward behind it. If the ecosystem becomes easier to generate, the importance of a well-designed core increases.
This is also why brand matters so much in commercial open source. Code is forkable. Increasingly, it’s also generatable. That means defensibility can’t rest on the idea that code alone will protect you. It has to come from elsewhere: trust, stewardship, product excellence, operational competence, distribution and brand. Open source sharpens these things.
When code is visible and alternatives are possible, the question becomes: Who do users trust to build, maintain, operate and stand behind the product best? That’s a business question, not a licensing question.
To be clear, this doesn’t mean every open-source business model is healthy or that tensions between community and monetization are easy to resolve. They’re not. However, it becomes much easier to reason about once you stop treating code as the product.
The product is what openness makes possible. Trust. Control. Extensibility. Resilience. A better migration path. A more inspectable dependency. A safer long-term bet. A product that reflects that users don’t just want software that works today but software they can live with tomorrow.
That’s why commercial open source works. Not because it is cheaper or morally purer, and not because source code by itself has magical business value. It works because source code isn’t the product.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
