This page builds the buyer-side cost model most vendors hope you never run: a one-time migration project versus multi-year per-employee subscription spend. It names the break-even point, the labor most estimates miss, and what to do in the next 90 days.
This page builds the buyer-side cost model most vendors hope you never run: a one-time migration project versus multi-year per-employee subscription spend. It names the break-even point, the labor most estimates miss, and what to do in the next 90 days.
The decision is simpler than Oracle's account team wants it to appear. On one side sits an annual, recurring, headcount-indexed subscription that grows with your company and never shrinks with your Java usage. On the other sits a one-time engineering project to replace Oracle's JDK with a free OpenJDK build, followed by a support cost that is a small fraction of the subscription. Everything else is detail. Your job is to find the year in which cumulative subscription spend crosses the one-time migration cost, because after that year the migration pays for itself and keeps paying.
Oracle's Java SE Universal Subscription is priced per employee, not per install. Published tiers run $15/employee/month for 1 to 999 employees, $12 for 1,000 to 2,999, and $10.50 for 3,000 to 9,999, dropping toward $5.25 at scale (Oracle Java SE Universal Subscription Global Price List, Oracle FAQ). The metric counts every full-time, part-time, and temporary employee plus the staff of your agents, contractors, outsourcers, and consultants who support internal operations (House of Brick, March 2026). We cover the mechanics in full on the Oracle Java SE subscription pricing page. What matters here is that the bill is set by your org chart, not your Java footprint.
You are comparing a recurring headcount tax that only grows against a one-time project that only has to be done once.
Because pricing is linear with headcount and independent of usage, the subscription behaves like a tax on being a larger company (Atonement Licensing, Sept 2025). A firm of 25,000 does not run five times more Java than a firm of 5,000, yet it pays roughly five times more. Worked at Oracle's own published rates, the numbers are blunt.
| Total employee count | Illustrative rate/emp/month | Annual cost | 3-year cost | 5-year cost |
|---|---|---|---|---|
| 500 (5 Java users) | $15 | $90,000 | $270,000 | $450,000 |
| 1,000 | $12 | $144,000 | $432,000 | $720,000 |
| 3,000 | $10.50 | $378,000 | $1,134,000 | $1,890,000 |
| 20,000 | ~$6.75 | $1,620,000 | $4,860,000 | $8,100,000 |
| 28,000 (Oracle's example) | $6.75 | $2,268,000 | $6,804,000 | $11,340,000 |
The 500-employee row is the one that reveals the metric's design. That company has five IT staff touching Oracle Java and cannot buy five licenses. It must license all 500 employees, roughly $90,000 per year to support a trivial use case (Oracle Licensing Experts, Aug 2025). The 28,000-employee row is Oracle's own price-list example: $2,268,000 per year (Oracle Global Price List). Note the multi-year columns. These are not one-time figures. They renew, and Oracle's standard term is one year, so you re-price your headcount annually (Oracle FAQ). Companies that switched to this metric from the old processor and named-user model reported 300 to 400 percent cost increases at the 1,000-employee scale (Jalasoft, Sept 2025).
The engineering reality is far less dramatic than the invoice. For the same major LTS line (8, 11, 17, 21), moving from Oracle JDK to a free OpenJDK build is a drop-in replacement, a packaging change, not a code rewrite (Oracle Licensing Experts, May 2026). The four leading distributions, Eclipse Temurin, Amazon Corretto, Azul Zulu, and BellSoft Liberica, are all free for production and all remove the per-employee liability entirely (Oracle Licensing Experts, May 2026). They are licensed under GPLv2 with Classpath Exception, which permits unrestricted free commercial use (BellSoft, April 2026). We compare the destinations on the alternative Java options page.
Field data supports the low-effort read. Applications ran unchanged on the same LTS line in roughly nine of ten cases, with JavaFX and a few vendor-bundled runtimes as the exceptions (Redress Compliance, May 2026). In a large vendor survey, 84 percent of organizations that completed a migration said it went as expected or was easier than expected, 75 percent finished within a year, and 23 percent finished in three months or less (Azul, April 2025). The savings, net of the one-time project, ran 70 to 92 percent across the estates we modeled (Redress Compliance, May 2026).
The honest caveat: a clean exit is longer than a binary swap. Full estate cutover ran nine to fourteen months at large enterprises, and a defensible exit runs twelve to eighteen months because it ends with formal non-renewal and documented removal, not just a new binary on disk (Redress Compliance, Feb 2026 and May 2026). The steps that consume that time are inventory, compatibility testing, phased rollout, and the third-party app problem. Each has its own playbook: start with inventorying every Oracle Java install, then run compatibility testing across JDK vendors, then move the estate in waves per the rollout phasing guide.
Most internal estimates undercount the project because they price the binary swap and forget the surrounding work. In our experience across enterprise migrations, the labor breaks down roughly as follows. Treat these as planning proportions, not universal constants, because they are drawn from our project experience rather than a published benchmark.
Two costs almost every estimate omits. First, telemetry: Oracle JDK phones home, and update check-ins can seed an audit. Blocking them is a task in its own right, covered in blocking Oracle Java update check-ins and telemetry. Second, paid OpenJDK support if you want SLAs and security patches. Commercial support runs roughly $400 to $800 per unit at the low end (Azul, per research), a small fraction of the per-employee subscription. Even fully loaded, the destination cost stays far below Oracle's.
The binary swap is a week. The inventory, the third-party bundled runtimes, and the removal evidence are the project.
Here is the arithmetic that should drive the decision. Take a one-time, fully loaded migration cost (internal labor plus any external help) and divide it by annual subscription spend to get break-even in years. The table below uses conservative migration cost assumptions from our project experience: roughly one to three months of a small internal team plus contingency, scaled by estate complexity. Adjust to your own loaded rates.
| Company size | Annual subscription | Illustrative one-time migration cost | Break-even | 5-year net saving |
|---|---|---|---|---|
| 500 employees | $90,000 | $60,000 | ~8 months | ~$390,000 |
| 1,000 employees | $144,000 | $120,000 | ~10 months | ~$600,000 |
| 3,000 employees | $378,000 | $300,000 | ~10 months | ~$1,590,000 |
| 20,000 employees | $1,620,000 | $1,200,000 | ~9 months | ~$6,900,000 |
The pattern holds across every size band: break-even lands inside the first year, and often well inside it. That is the decisive fact. Because the subscription is recurring and the migration is one-time, the comparison is not close once you extend past 12 months. A migration that takes nine to fourteen months to execute still pays back inside its first year of completion because you stop paying the subscription the moment you non-renew. The migration cost figures above are illustrative and should be replaced with your own loaded-labor estimate; the subscription figures are grounded in Oracle's published tiers.
The only scenario where staying wins on pure economics is a very short remaining horizon, for example a business you plan to divest or shut down within a year, where you would not amortize the project. For any going concern, the recurring nature of the headcount tax makes migration the cheaper path over any multi-year window. See the broader Oracle Java SE exit strategy for the full transition map.
There is a third option people assume is free: keep running Oracle JDK under the No-Fee Terms and Conditions (NFTC). It is real but it runs on a clock, and the clock is where organizations stumble into non-compliance and hand Oracle audit leverage.
The trap is that NFTC feels like a permanent free ride and is actually a rolling grace period. Every LTS release resets a countdown on the previous one. The clean move is to run a free OpenJDK distribution that ships its own long-term patches, which removes both the subscription liability and the NFTC clock in one step.
The pure cost model assumes an orderly decision. Oracle's Java audits are not orderly. Claims we have defended reached $4.7M, $4M, $1.5M, and $1M before resolution (see the Avis Budget Group case study and the CSAA Insurance case study, both resolved at zero cost). An audit shifts the break-even calculus: the risk-adjusted cost of staying is not just the subscription, it is the subscription plus the probability-weighted cost of a claim built on installs you did not know you had. Migration, done with proper removal evidence, retires that risk. That risk reduction is a real, if unquantified, benefit that belongs on the migration side of the ledger.
Staying is not the subscription alone. It is the subscription plus the audit claim you cannot yet see.
Run the model with your own numbers, in this order. First, pull your exact employee count under Oracle's broad definition and multiply by your applicable tier to get the real annual and five-year subscription figure. Second, inventory every Oracle Java install so you can scope the project honestly; do not estimate migration cost before you know where Java runs. Third, calculate break-even as one-time migration cost divided by annual subscription. In nearly every enterprise case that number is under 12 months, which means the analysis is done: migrate.
Then execute with the OpenJDK migration execution guide as your master plan, and close the project with removal evidence in hand so the savings are not undone by a later audit. If your remaining horizon is genuinely under a year, or if third-party bundled Java makes a full exit impossible this cycle, negotiate the subscription hard on the metric definition rather than the rate, because the employee count is where the money is.
For nearly every enterprise, break-even lands inside the first year. Because the subscription is recurring and per-employee while the migration is a one-time engineering project, a company paying $144,000 a year against a $120,000 project breaks even in roughly ten months. After that, the free OpenJDK path saves 70 to 92 percent annually, net of the migration.
No. For the same major LTS line (8, 11, 17, 21), moving to a free OpenJDK build such as Temurin, Corretto, Zulu, or Liberica is a drop-in replacement, a packaging change rather than a code change. Applications ran unchanged in roughly nine of ten cases, with JavaFX and vendor-bundled runtimes as the usual exceptions.
Inventory, third-party apps that bundle Oracle JDK, blocking update telemetry, and documenting removal for audit defense. The bundled-Java problem is the most common reason an exit stalls. A defensible exit runs twelve to eighteen months and ends in formal non-renewal, not just a binary swap.
Only temporarily, and only for JDK 17, 21, and later. Java 8 and 11 never had NFTC. JDK 17's free window closed in September 2024, and JDK 21's closes in September 2026. After each window, patched Oracle JDK requires a paid subscription for production, so NFTC is a rolling grace period, not a permanent free ride.
A fraction. The leading OpenJDK distributions are free for production. Paid commercial support with SLAs and security patches runs roughly $400 to $800 per unit at the low end, versus a per-employee subscription that costs a mid-sized firm $144,000 a year and a 20,000-employee firm over $1.6M.
Yes. Oracle Java audits produce large claims built on installs organizations did not know they had; we have defended claims of $4.7M, $4M, $1.5M, and $1M, all resolved at zero cost. Staying means paying the subscription plus carrying that audit exposure. Migration with proper removal evidence retires the exposure.
Oracle Java SE Universal Subscription bills every employee, not just developers. The 2026 buyer guide to the cost math, audit exposure, and OpenJDK migration.
Gated with a work email on the download page. No sales follow up you did not ask for.
Get the White Paper →
500+ enterprise clients. 11 vendor practices. Industry recognized. One conversation can change what you pay for the next three years.
One buyer side briefing a week. Renewal signals, audit moves, and the levers that work. No vendor spin.
