Liberty Previews InstantOn for Cloud-Native Java

4 min read

A new feature within Liberty called InstantOn helps avoid the disadvantages and limitations that come with native image compilation.

A massive shift to the cloud has caused organizations to face rising infrastructure costs to deploy and manage their applications. Many are turning to cloud-native technologies that offer advantages over traditional IT solutions. These technologies empower organizations to build and run scalable applications in modern, dynamic environments like public, private and hybrid clouds. Cloud-native also provides additional agility, enabling applications to be rapidly deployed, scaled, and optimized for any cloud environment.

Cloud-native solutions include IaaS (infrastructure-as-a-service), PaaS (platform), SaaS (software) and serverless computing. Each offers varying levels of support and responsibility between the cloud provider and users of the service. 

Leading the charge is serverless computing, which takes on the responsibility of managing the infrastructure — freeing up developers to focus their time on building applications. Besides helping make developers more productive, it has another big benefit: cost. Applications deployed in a serverless environment are automatically scaled up and down based on demand and charged accordingly. This pay-as-you-go model means you only pay for what you use (which, in some cases, can be zero when your application is idle).

Are your applications ready for serverless?

To effectively scale dynamically —especially from zero instances — your application should be responsive to requests instantly, typically measured in milliseconds. While quick start-up time can be an issue for applications of any size or type, it is especially challenging for Java workloads. This is because, traditionally, a lot of work is done by the JVM during start-up. 

One popular way to improve start-up times for Java workloads is to use a static compiler to build your application into a native image. While this does improve start-up time, there are disadvantages to this approach. The first is that you lose all the benefits of running in a traditional Java application runtime, including memory and performance optimizations. Another is that static native-image compiling solutions may not support the full set of Java features, so you will have to modify your code to work around this limitation.

Perhaps the biggest issue is that the compile-to-native approach introduces additional steps to the development and deployment process. Since the time to compile and build a native image can be significant, developers typically choose to do development and testing in a traditional Java runtime. This difference between development and production environments runs counter to best practices for cloud-native application development and adds the risk that problems will be discovered late in the delivery cycle.

Liberty InstantOn, without compromise

InstantOn, a new feature within IBM WebSphere Liberty, is a better solution that avoids the disadvantages and limitations that come with native image compilation. 

InstantOn allows the Liberty runtime to start up cloud-native Java applications incredibly fast. As shown in the graph below, applications typically start 10 times faster than without InstantOn. Designed for cloud and container environments, Liberty provides developer tools to help increase your productivity by 50%, adheres to open standards (like Jakarta EE and MicroProfile) to help avoid vendor lock-in and offers world-leading performance to help you potentially reduce IT infrastructure costs by 40%.

potentially reduce IT infrastructure costs by 40%

How does InstantOn produce such fast start-up times? It does this by taking a snapshot of a running Java runtime and then restoring it from the point the snapshot was taken. The beauty of this is all the work done before the snapshot is taken does not have to be repeated; if you started a Liberty runtime and deployed an application before the snapshot, that is all ready to go when the Java process is restored.  When restored, your application will continue to have the same high throughput and low memory performance characteristics as a Liberty runtime without InstantOn. And if you are concerned about the effort involved in creating the snapshot, it can be accomplished with a simple command that completes in a matter of milliseconds.


New cloud-native technologies allow applications to dynamically scale, reducing the need to pay for over-provisioned resources so that operational costs can be optimized. To maintain the best possible service to end users, applications need to rapidly scale up (especially from zero instances) when demand load increases. But quick start-up times can be an issue for many Java workloads. One possible approach is to compile your code to native images, but this introduces limitations and drawbacks that need to be addressed.

InstantOn with Liberty offers a better solution, without any compromises. It enables you to take full advantage of cloud infrastructure with fast and dynamic start-up by doing the following:

  • Enabling your application to continue to run in traditional Java runtimes, optimized to deliver high throughput and low memory usage
  • Ensuring you always have full Java language support
  • Ensuring your development, testing and production environments remain as similar as possible, removing the need to modify your application workflow and lifecycle

This all seamlessly helps to ensure that your cloud-native Java application is automatically optimized and ready to thrive in the ever-changing world of cloud computing.

Watch the video to learn more:

Be the first to hear about news, product updates, and innovation from IBM Cloud