Java’s next feature release is taking shape.
JDK 28, the reference implementation of Java SE 28 under JSR 403, is scheduled for General Availability on March 9, 2027. It is a non-LTS feature release, but several targeted changes could still matter significantly for teams building and operating modern Java applications.
As of November 2026, JDK 28 remains under active development. The current schedule and early-access builds are available through the OpenJDK JDK 28 Project.
The release is shaping up around some important themes: faster startup, a changing Java object model, simpler concurrency, improved garbage collection, and more built-in platform capabilities.
For engineering teams, the important question is not simply:
“What is new in Java 28?”
It is:
“Which changes could affect how we build, test, and run Java applications?”
Ahead-of-Time Compilation Targets Faster Startup
One of JDK 28’s most interesting developments is JEP 544: Ahead-of-Time Code Compilation.
Java traditionally relies heavily on Just-in-Time compilation. The JVM observes an application while it runs and progressively compiles frequently executed code into optimized machine code.
That adaptability is one of Java’s strengths, but applications need time to warm up.
JEP 544 extends Java’s AOT capabilities by allowing optimized native code produced during a training run to be stored in an AOT cache and made immediately available during later production runs.
Importantly, this does not replace JIT.
If production workloads change, HotSpot can still dynamically optimize the application.
The model becomes:
Start with prepared AOT code. Continue adapting with JIT.
That could be especially useful for Java workloads running in containers, microservices, autoscaling environments, and other systems where startup and time-to-ready matter.
OpenJDK’s selected benchmarks for JEP 544 reported substantial startup improvements, but these results should not be treated as a guarantee for every Java application. Teams should benchmark their own workloads before drawing production conclusions.
Value Objects Could Change How Java Represents Data
Another major development is JEP 401: Value Objects.
Traditional Java objects have identity. Two objects can contain identical values while still being separate objects with separate identities.
Value objects introduce a different model.
Their meaning comes from their values rather than their identity. This gives the JVM more freedom in how such data is represented and could eventually support more compact memory layouts and more efficient execution.
This is an important step for Project Valhalla and the longer-term evolution of Java’s type and object model.
But there is an important qualification:
Value Objects are targeted as a preview feature.
Teams should use JDK 28 to experiment, understand compatibility implications, and test libraries—not assume that every application should immediately redesign its domain model around value objects.
Code that depends on object identity, synchronization, or other identity-sensitive behavior deserves particular attention during testing.
Structured Concurrency Becomes a Permanent API
Modern applications frequently need to execute several related operations at the same time.
A request might fetch customer information, inventory data, pricing, and recommendations from separate services. Running those operations concurrently can reduce latency, but coordinating failure, cancellation, and task lifecycles can quickly become complicated.
JEP 543: Structured Concurrency addresses that problem.
After multiple preview rounds, Structured Concurrency is targeted to become permanent in JDK 28.
Its central idea is simple:
Related concurrent tasks should be managed as one unit of work.
If part of that work fails or is cancelled, the relationship between the remaining tasks becomes easier to manage and reason about.
For backend teams already using virtual threads, Structured Concurrency can make concurrent workflows easier to understand, debug, cancel, and maintain.
Java Is Getting a Simpler Built-In JSON Option
JSON processing is part of everyday backend development, but Java applications typically depend on external libraries such as Jackson or Gson for it.
JEP 540: Simple JSON API introduces an incubating built-in API for basic JSON parsing and generation.
The goal is not to replace mature JSON frameworks.
Instead, it gives developers a lightweight option for use cases where bringing in a larger data-binding library may be unnecessary.
That could be useful for tasks such as:
- reading simple API responses;
- processing configuration data;
- navigating JSON documents; and
- generating lightweight JSON output.
Because the API is incubating, teams should treat it as something to evaluate rather than a drop-in replacement for established production libraries.
Garbage Collection Continues to Evolve
JDK 28 also targets several garbage-collection improvements.
Generational mode is set to become the default for Shenandoah, while ZGC receives work focused on startup, warmup, and adaptive memory management.
For organizations running Java services across cloud infrastructure, these improvements matter because runtime efficiency is not only about raw throughput.
Applications also need to behave predictably while starting, scaling, and operating under changing resource constraints.
This is particularly relevant when Java estates are part of broader legacy system modernization services initiatives. A runtime upgrade can expose dependencies, deployment assumptions, infrastructure constraints, and technical debt that have accumulated over years.
JDK 28 Is More Than a Runtime Upgrade
A Java version change may look simple on paper:
Change the JDK → rebuild → deploy.
Production systems are rarely that simple.
Applications may depend on:
- Spring or other frameworks;
- third-party libraries;
- database drivers;
- JVM arguments;
- CI/CD environments;
- Docker base images;
- monitoring agents;
- native libraries; and
- infrastructure-specific runtime settings.
A change that works perfectly in a local environment can behave differently under production traffic.
That is why quality assurance and software testing should be part of the migration plan rather than something performed after the upgrade. Inument’s software testing and quality assurance services cover areas such as compatibility, performance, regression, security, and load testing—the same disciplines that become important during runtime migrations.
Should Production Teams Upgrade to JDK 28?
Not automatically.
JDK 28 is a feature release, not an LTS release.
The right production version depends on several factors:
Support policy · Framework compatibility · Vendor support · Infrastructure · Application lifecycle
Organizations running long-lived enterprise systems may decide that an LTS release remains the better production target.
That does not mean JDK 28 should be ignored.
Early-access builds give engineering teams an opportunity to understand where Java is heading and identify compatibility issues before those technologies influence later releases.
A practical evaluation could include:
1. Run CI against JDK 28
Check whether the application compiles and whether the automated test suite continues to pass.
2. Audit dependencies
Identify frameworks, libraries, plugins, agents, and native components that may not yet support the new runtime.
3. Benchmark real workloads
Test startup, warmup, latency, throughput, memory use, and resource consumption using workloads that resemble production.
4. Evaluate new APIs separately
Preview or incubating features should be tested independently from the core runtime migration.
5. Test deployment and rollback
Make sure a Java upgrade can be introduced gradually and rolled back safely if unexpected behavior appears.
For larger Java estates, this work may require a dedicated software development team with experience across application code, testing, DevOps, cloud infrastructure, and production operations.
Start Testing Before March 2027
JDK 28 is interesting because several targeted improvements address problems that have followed modern Java workloads for years.
AOT compilation targets startup and warmup.
Value Objects continue Java’s object-model evolution.
Structured Concurrency makes related concurrent work easier to manage.
JSON support reduces the need for external dependencies in simple cases.
Garbage-collection improvements continue pushing the JVM toward more adaptive runtime behavior.
Not every feature will matter equally to every application.
And because JDK 28 is still under development, teams should keep following the official OpenJDK JDK 28 project as the release moves toward feature freeze and General Availability.
The goal should not be to upgrade simply because a new Java version exists.
The goal is to understand what the new runtime changes, whether those changes benefit your workload, and what must be tested before production depends on it.
March 2027 may be the release date.
For production teams, the useful work can start before then.