In 1999, Eric Raymond collected his essay The Cathedral and the Bazaar into a book. It asked how software gets written: by a small group of wizards working behind closed doors, or by a loud crowd building in public and letting anyone poke at the result. Raymond argued that the bazaar tended to win, because many eyes make bugs shallow.
This series is about a different question. Not how code gets written, but what gets paid for. Same two shapes, a cathedral and a bazaar, but now we are looking at the balance sheet behind each one.
Two teams, one difference
Picture two teams of equally good engineers. Same degrees, same years of experience, same taste for clean abstractions. One team ships a thing you can read, fork, and run on your own machine. The other ships a thing you rent.
Nothing about the engineers explains that. If you swapped the teams overnight, each would probably build what the other had been building, because the product is not shaped by what the engineers can do. It is shaped by what the organisation around them is rewarded for doing.
That is the thesis of this article: the difference between a proprietary lab and an open-source lab is not talent or skill. It is what each one is rewarded for, and that shows up in the code.
I do not mean this as an accusation. Nobody at a subscription company sat down and decided to make your life harder. Incentives work more quietly than that. They decide which tickets get prioritised, which pull requests get merged, which features get a launch post, and which bugs quietly age out in a backlog. Over a few years, those small decisions add up to an architecture.
What the proprietary lab is paid for
A proprietary software company is, at the level of its balance sheet, paid for three things:
- retention
- recurring revenue, and
- keeping you inside the product.
The unit that matters is rarely the sale- it's the renewal.
A customer who pays once is a transaction; a customer who pays every month is an asset, and the company's valuation is largely a bet on how long that asset lasts.
Every roadmap meeting, or, whatever it is called, ends up asking some version of one question: does this make people more likely to stay?
So every feature is graded on whether it keeps you subscribed. This is not always a bad thing. Oftentimes, the answer is a good one: make the product faster, make it more reliable, make it do the thing the customer cares about. A product people love is the best retention strategy there is, ideally.
But the grading rubric leaks into the design in ways that are easy to miss:
- Integrations that only go one way. Importing your data from a competitor is a priority. Exporting it to one is not.
- Proprietary formats. Not necessarily out of malice. A custom format is simply the cheapest and fastest way to support the features the product has.
- Features that raise switching costs. Templates, history, shared workspaces, and automations are useful. They are also the things that make leaving feel like moving house.
- Closed extension points. If the platform controls the plugin store, it controls what the product can become.
None of this requires a villain. It only requires a quarterly target and an engineer who wants to hit it.
What the open-source lab is paid for
The open-source lab is paid in a different currency: reuse. Being depended on. Being the thing that other people reach for when they need that problem solved.
A library with a million downstream users has influence, a reputation, and often a career-shaped halo around its maintainers. The reward is leverage: your work multiplies because other people build on it. That pushes the code in a specific direction. Open projects tend to favour stable interfaces, documented behaviour, portable formats, and extension points, because those are the things that make something easy to depend on.
There is a second reality that deserves honesty: a great many open-source maintainers are paid nothing at all. They work evenings and weekends, around day jobs, and they are rewarded mostly in gratitude and issue reports. That is its own distortion. Unglamorous tasks such as security audits, accessibility, documentation, and long-term maintenance are exactly the ones that go underfunded.
So the open lab is not a utopia. It is a different set of pressures, with different failure modes.
Conway's Law, updated
In 1967, Melvin Conway observed that organisations which design systems are constrained to produce designs that copy their own communication structure. Think of it like this: if you have four teams building a compiler, you will get a four-pass compiler.
It is one of the more durable ideas in software, and it still hold up to this day. It just needs a small update, because the org chart behind a modern product is only half the story. The other half is the incentive chart.
Behind the proprietary lab, the incentive chart is a cap table and a quarterly target. There are investors who want growth, a board that wants a trajectory, and a finance team that models churn to the decimal. The code reflects that. It is cohesive, because one organisation owns every decision. It is also shaped around the metrics that organisation answers to.
Behind the open lab, the picture is a loose federation of maintainers, many with day jobs, a handful of corporate sponsors, and a contributor base that comes and goes. The code reflects that too. It tends to be modular, because modules are how a federation divides work. It tends to be configurable, because nobody can force a single vision on everyone. And it can be rough at the seams, because nobody is paid to sand them.
When you look at a codebase, you are looking at a fossil record of the organisation that produced it, and of what that organisation was paid to care about.
Where the incentives agree
It would make an easier statement to say the two labs are opposites. They are not.
Nobody wants broken software. A proprietary company that ships constant crashes loses customers. An open project that ships constant crashes loses users, contributors, and its reputation. Both sides want the thing to work, both sides want security holes closed, and both sides want fast performance.
This is why, on a quiet day, the two kinds of software can look the same from the outside. The incentives are aligned on quality, and they stay aligned for as long as quality is the cheapest way to get what each side wants.
The interesting question is what happens when they stop being aligned.
Where they split hard
The split shows up at the boundaries, in the places where what is good for the user and what is good for the balance sheet pull apart.
- Portability. A user benefits from being able to leave. A subscription business benefits from you not leaving. An open project, whose success is measured by adoption rather than retention, has little reason to trap you and every reason to let you take your data to wherever you want.
- Pricing and packaging. A proprietary product has a reason to hold back features for higher tiers. An open project has a different tension: features that matter to commercial users but cost real effort to build. Here the incentives do not split so much as get complicated, and I will come back to that in Article 2.
- Longevity. A proprietary product lives as long as it is profitable, or as long as the company that owns it stays interested. An open project lives as long as someone is willing to keep going, and when they stop, someone else is allowed to pick it up. That one difference is large enough that Article 3 is built on it.
- Direction. A proprietary roadmap is steered by whatever maximises revenue. An open roadmap is steered by whoever shows up. Neither is guaranteed to be steered by what you, the user, actually need.
These are not moral differences. They are the predictable output of two different payment structures.
The sentence the series rests on
Here it is, in one line:
Proprietary labs optimise for the moat. Open labs optimise for the leverage.
A moat is a defence. It is anything that makes it hard for a customer to leave or a competitor to catch up. Proprietary formats, accumulated data, network effects, and workflows built into your daily routine are all moat. A company with a deep moat can charge steadily, plan years ahead, and survive mistakes.
Leverage is multiplication. It is anything that lets a small amount of work produce a large amount of effect. A library that thousands of products depend on, a protocol that every system speaks, and a tool that teaches people a skill they take elsewhere are all leverage. A project with strong leverage grows by being useful to people who never have to ask permission.
Both are rational strategies. Both can produce excellent software. They simply produce different software, because they are solving different problems. One is asking, how do we make sure this customer stays? The other is asking, how do we make sure this thing is worth using everywhere?
One caution before moving on
It is tempting to read this as a story about good and bad. Please do not. The incentive framing is useful precisely because it removes the need for villains and heroes. A proprietary engineer building a beautiful, locked-in product is doing a good job at the thing they are paid for. An open-source maintainer building a rough but portable tool is doing a good job at the thing they are rewarded for. Both are rational. Both are doing what the structure around them asks.
The practical consequence is that you can predict a lot about a piece of software without ever reading its code. Ask who pays for it, what they are paid for, and what would happen to that payment if you left. The answers will tell you most of what the architecture will eventually show you.
In the first series, in Open Source Is How Small Teams Build Big Things, I argued - A small team cannot out-spend a corporation, but it can choose which incentives it builds on top of.
The open ecosystem is where the leverage lives, and a small team that learns to use it gets to punch well above its size.
What comes next
If open labs are optimising for leverage, a reasonable follow-up question is: what exactly is being leveraged?
The answer is not code in the abstract. It is something more specific, and more like a public road than a gift: inspection, repairability, and shared foundations that nearly every product, including the proprietary ones, quietly stands on. That is the subject of Article 2.
Top comments (0)