Why high-performance Java is becoming a business imperative

A new generation of JVM technologies is reshaping how businesses build, deploy, and scale mission-critical Java applications.

Sponsored Feature Java is clearly a powerhouse language when it comes to driving enterprise-scale applications. It has been around for years (first released by Sun Microsystems in 1995) and it has gone through numerous versions and updates since then. The latest version is Java 25, which was released in September 2025.

While Java certainly has a lengthy and respectable track record, there have been more frequent, dramatic updates to the platform since the release of Java 9 in 2017. They have taken place every six months, says Scott Sellers, co-founder and CEO of Sunnyvale, CA-based Azul. "Every March and every September, there's a new version released. It's moving at breakneck speed in terms of capabilities of the platform."

Java has considerable advantages given its widespread popularity and extensive track record. "The advantage of Java relative to other languages used in the enterprise is you get the best of both worlds. You get the stability, the robustness, the track record of Java powering the most demanding apps in the most demanding enterprises worldwide," says Sellers. "And there's stability and security and know-how. There are more than 10 million professional developers out there who know Java; marry that with the fast pace of innovation and all these new capabilities, and enterprises gain a future-proof application infrastructure they can trust to scale, adapt, and evolve with their business."

Having Java as the foundation of enterprise-scale apps conveys further advantages of compatibility, reliability, and security. Sellers describes the process of an application developer going through a mental checklist when deciding how to architect and develop an app.

"I need a robust platform. I need to leverage open-source technologies. I want to easily find developers familiar with it. I want something inherently secure. I want patches and updates to be readily and regularly available. I want to use something I can maintain over a long period of time," he says. "When you go through that checklist, Java always comes back as, 'Yep, this makes sense for many reasons.'"

Challenges do exist

There are, however, several challenges for organizations building out their application landscape in the cloud. As more companies develop and host dynamic, cloud-based applications, they often over-provision to account for unexpected increases in scale.  Likewise, legacy applications were most often designed as monoliths and not refactored into more cloud-native, container-based and microservice architectures, meaning the efficiencies and performance of an elastic architecture aren’t realized. Applications developed using Java and Java-based languages (e.g. Kotlin, Scala, Groovy, Clojure) which are running on Java runtimes that are not up to the task can incur significant expense. According to Azul's State of Java 2025 survey, 65 percent of the respondents reported Java workloads account for more than half of their cloud compute bills, clearly representing a disproportionate percentage. And with companies continuing to push workloads into the cloud, The new Java releases continue to fuel that phenomenon. "We don't see any end in sight," he says.

Over-provisioning is one approach to ensure performance and stability, but it's an expensive route to take. "The majority of survey respondents report they're overspending in the cloud. They have unused cloud capacity that they don't know what to do about," reports Sellers. "They need that unused capacity as apps unexpectedly scale, and the solution is to over-provision."

There's also the notorious warm-up time for Java apps. As a Java-based app begins to run, it can often take seconds to minutes before the app is running at full performance. "One of the downsides of a JIT (just in time) compiler, like you have in the Java runtime, is it actually takes some time for the app to warm up. The first time the runtime actually sees the app, it is literally doing interpreted logic," he explains.

As the app continues to run, the JIT compiler starts to see patterns in how methods are called and other behaviors. After a few cycles, it will begin to more aggressively compile the code. "So over time, the app gets faster and eventually you get to that full steady state performance," says Sellers. "But it does take some time from when the app is started to when it's fully performing."

That warm-up time is bad for business. "Imagine electronic trading," he says. "Imagine if this is happening during early morning trading hours with the app not fully performing. That's a real problem for the business."

Move to high performance

For modern apps and workloads, the fundamental architecture makes a significant difference in capacity requirements. "The way most modern apps are built is based on microservices architectures and container-based deployments orchestrated in the cloud. When we think of cloud native, that's how we characterize it," says Sellers.

Instead of over-provisioning to account for unexpected increases in scale and to work around that warm-up time, development teams would do well to look toward using a high-performance Java platform. High-performance Java platforms operate much faster than standard OpenJDK distributions (i.e. have higher performance and throughput, and lower latency), have faster start-up and warm-up times, and more consistent response. This helps improve operational efficiency without having to re-architect applications or change any code.

Using a high-performance Java platform can not only improve app performance, response time, and service availability; it can also reduce cloud spend. "It's that latter part that is not obvious to many people. I get that a faster Java runtime (or Java Virtual Machine - JVM) will improve app SLAs, but how do I map that back to cloud spend?" he says. "That's the part that's not necessarily intuitive."

It's really quite simple though, according to Sellers. "If you have a faster Java runtime, it means you need less compute to handle given amounts of workloads, users, and transactions. It ultimately means you're able to do more with less and reduce the amount of compute infrastructure needed to be able to host your apps and microservices," he says.

Even making a relatively small dent in enterprise cloud spend can have a significant impact. "The scale of compute and cloud deployments is incredible. When you hear about the dollars these enterprises are spending in the cloud; it's tens and hundreds of millions of dollars. If we're able to affect that by even 10 to 20 percent, the ROI is incredible," says Sellers.

Those cost savings free up budget dollars for further investment.  "How can we accomplish these more forward-leaning things, but still in an environment that's fairly budget constrained? You can think about saving in the cloud as shifting dollars away from cloud spend into more forward-looking initiatives like AI," he explains.

Digging deep into performance

Modern JIT compilers in high performance Java platforms are quite sophisticated. "The JIT compiler is highly integrated into the Java runtime as the application is being run," explains Sellers. "What that means is there's a lot of performance information that is only available during run time, and that can make further optimizations possible. Optimizations you simply can’t do when compiling statically."

When DevOps teams can examine that performance data as the app is running, it conveys several advantages. "You can see the methods and calls. And you can do all sorts of aggressive optimizations as a result of that information that's only available during the run time," he says.

Development teams looking for a higher performing Java runtime and compiler can look to Azul's Platform Prime with ReadyNow technology and the Falcon JIT compiler. "ReadyNow is a way of significantly lessening this warm up curve and getting the application to its full performing state much quicker," explains Sellers. "This largely addresses the downsides of warm up that's common with traditional Java runtimes."

ReadyNow paired with the Falcon JIT compiler results in a high-performance Java platform. "Ultimately, the quality of the JIT compiler really matters in terms of performance and latency for Java-based workloads. The Falcon JIT compiler creates machine code and sequences that are much more optimized and ultimately more efficient than the JIT compiler that’s part of off-the-shelf OpenJDK," explains Sellers.

The Falcon JIT compiler creates code that is faster and more efficient, which results in apps having lower latency because they're able to respond faster. That more efficient code can also improve response consistency, result in higher throughput and require fewer compute resources and significantly reduce overprovisioning. "So again, doing more with less, which can help reduce cloud spend," he says.

Big things with big data

One organization that continues to experience the benefits of Platform Prime is a global digital ad-tech company,. The company now delivers digital content to more than 1.4 billion people every month.

Several years ago, the company experienced rapid growth and was outstripping its infrastructure, which dramatically increased its expenses. One of the critical issues was the manner in which the garbage collector in Oracle Java (or any other OpenJDK-based JVM) was operating within its apps. The server would end up not responding consistently, pauses for hundreds of milliseconds and up to many minutes during collection. Attempts to address the issue with performance tuning didn't work out, leading the company to shift to Azul's Platform Prime.

The company experienced dramatic performance, stability, and security improvements after moving to Platform Prime. The company was also able to reduce its server footprint by 30 to 50 percent. "We're now doing things with our big data system that cannot be done without Azul."  Other enterprises and development teams can expect similar results after moving to Platform Prime. With the steady, incremental improvements being made to Java every six months, adapting and evolving the supporting infrastructure makes both operational and financial sense.

Sponsored by Azul.