The Fork or the Check: What Happens Next After a License Change

Archi4 min read

licensingsoftwarebudgetforks

Contents
  1. The Fork or the Check
  2. The arithmetic people get wrong
  3. Months zero to six: the fork looks fine
  4. The first high advisory is the test
  5. Month twelve: the hiring problem
  6. What happens next, by scenario
  7. What to watch next

The Fork or the Check#

Three weeks before renewal, an engineering director at a 240 person analytics vendor had two quotes in front of her. A commercial license for the open source database her product depended on: roughly $180,000 a year, three year term, priced per node. The other option was a fork. Two engineers, indefinitely, plus a build pipeline nobody had budgeted for.

The project had switched from a permissive license to a source available one eighteen months earlier. Her team was still running the last permissive release. It sat two major versions behind and carried three open advisories, one rated high.

The specifics are a composite drawn from public license terms and typical salary data. The shape of the decision is not. Every time a license changes, a few hundred companies face the same split in the road, and the forecasts they get from their own engineers are usually too optimistic by half.

The arithmetic people get wrong#

The license fee is a line item. The fork is a payroll. A senior backend engineer at $190,000 base, loaded with benefits, equipment and overhead at roughly 25 percent, costs about $240,000 a year. Two of them is $480,000. That is more than double the license on day one, which is why most companies sign.

The comparison flips if you model it honestly. The license is priced per node and the fleet grows. At 18 nodes today, the bill is $180,000. At 40 nodes in year three, assuming standard per node tiers, it is closer to $400,000, and the renewal after that carries a mid term increase. The fork's cost curve is flat: two salaries rising about 4 percent a year, plus $15,000 in CI compute and a part time release manager.

Crossover lands somewhere near month 30 for this profile. That is the number to argue about, not the year one invoice.

Months zero to six: the fork looks fine#

The first half year is quiet. The two engineers are upstream contributors already. They read the changelogs, they cherry pick security patches, and the build passes. Leadership feels clever.

The unseen work starts in month four, when a customer asks for a feature that landed upstream in the version the company no longer tracks. Backporting a feature is not the same job as backporting a security fix. The fix is usually small and isolated. A feature drags dependencies, tests, and a schema change with it. The first backport request typically costs three to five weeks of one engineer's time, and it arrives inside a sales cycle, which means it wins.

The first high advisory is the test#

This is the moment the forecast turns. A high severity vulnerability is published against the current upstream release. A patch usually lands upstream within days. The forked company now has three jobs: work out whether its older code is affected, write or adapt a patch if the fix depends on code the fork does not have, and ship a release to its own customers on its own schedule.

In the typical pattern, the fix depends on a refactor the fork skipped. What would have been a four line change upstream becomes a two week reimplementation. Expect the first one of these inside eighteen months. Expect it to consume a full quarter of the team's capacity, and expect the security questionnaire from your largest customer to arrive in the same week.

Month twelve: the hiring problem#

Fork maintenance is not a project, so it never gets a project plan. The two engineers split their time between the fork and product work. When one of them leaves, which happens, the backfill takes four months and the new hire spends the first three learning a codebase that no longer matches the public documentation. Every tutorial, every forum answer, and every third party driver now points at upstream code your team has drifted away from.

What happens next, by scenario#

If the company signs the commercial license at year two, after twelve months of fork overhead, it pays the original price plus the work already spent. The decision only gets more expensive to reverse.

If it commits to the fork, the realistic outcome is a smaller fork: fewer backports, a documented list of features the company will simply never ship, and a support policy that tells customers the truth about version lag. That can work. It works best for companies whose product does not compete on the features of that particular database.

If a competitor project relicenses to something more permissive in the same category, which has happened in several recent license changes, the whole calculation resets and the fork becomes a migration project instead.

What to watch next#

Three signals predict which path a company takes. Whether the license is priced per node or per company, because per node pricing makes the crossover arrive sooner. Whether the fork's maintainers already contribute upstream, because contributors make backports cheaper. And whether a high advisory lands before the next renewal, because nothing moves a budget meeting faster than a customer security review with a deadline.

The decision that looks like a licensing question is really a staffing forecast. Companies that treat it that way tend to survive the first advisory. Companies that treat it as a legal formality tend to sign the commercial contract twelve months late, at a higher price, with a release schedule they no longer control.

More articles