Open source is free until it reaches production

Every comparison between an open-source stack and a commercial one gets the same shape: the licence column is zero on one side and large on the other, and the decision looks obvious. It is also the least interesting number on the page, because the licence was never the expensive part. The costs that decide whether this works show up after the download, and almost nobody puts them in the spreadsheet.

Where the money actually goes

Learning. Somebody has to understand the stack well enough to make decisions about it, and that is measured in months rather than a training course. For a small team, that person is also the person who was doing something else.

The first deployment. Not the demo — the one with your data, your identity provider, your network and your compliance requirements. This is where every project discovers which of its assumptions were wrong, and it almost always costs more than the estimate.

Operations. Backups that are tested, monitoring that catches the thing before the user does, updates that happen on a schedule rather than after an incident. This is a permanent cost and it is the one most often assumed away.

Being on call. Not the hours — the availability. Somebody has to be reachable, which means either a rota or a single person who never really goes on holiday. The second option works until it stops working, usually at the worst moment.

Turnover. The person who learned the stack leaves. On commercial software the vendor retains the knowledge; on a self-run open-source stack, it walks out with them unless it was written down, which it usually was not.

When self-hosting is genuinely cheaper

This is not an argument that you should pay somebody. Plenty of organisations should run it themselves, and the pattern is fairly clear.

You already have the capability — people who operate infrastructure as their actual job rather than as a thing they also do. The workload is not on the critical path, so an afternoon of downtime is annoying rather than expensive. And you have enough scale that the learning cost amortises over many deployments rather than one.

If all three are true, run it yourself. The software is open specifically so that you can.

When it is not

The inverse is equally clear. A team of five where the person who would learn it is also the person who closes the books. A workload where downtime stops the warehouse. A single deployment, where the entire learning cost lands on one project and never gets reused.

In those cases the calculation is not “licence versus no licence”. It is “months of an internal person versus a contract with response times”, and the second is frequently cheaper as well as faster.

The comparison worth making

Not open source versus commercial. Self-run versus supported, with the same software on both sides.

That framing removes the ideology and leaves an operational question: who carries the risk, who does the work, and what does each option cost per year. It also makes the answer reversible — start supported, take it in-house when your team is ready, or the other way round when the person who knew it leaves.

That reversibility is the actual advantage of building on open source, and it is the one that gets lost when the discussion is about licence fees. The software staying open means the decision about who operates it can be revisited every year, by you, without anybody’s permission.