Six ways to lower development costs

Every IT department is looking for ways to reduce its IT infrastructure costs. Costs can easily get out of control from a number of sources: expensive hardware, maintenance bills, multiple licenses, and unreliable software just to state a few. Bellsoft has already examined ways to reduce costs around Java and support in a guide to lowering TCO by choosing the right OpenJDK vendor.

In this article we take cost reduction a step further and explore six additional areas and methods that will tame your expenditures.

Microservices

Although microservices are not a novel technology, some companies still stick to their monoliths. In cases of small or legacy applications, monolithic architecture may be more beneficial. But if you are planning to add new functionalities, scale, and expand the customer base, the costs of maintaining a monolith will eat a significant part of your budget.

Microservice architecture enables a company to cut the expenses in the long-term through:

• Facilitated maintenance and increased productivity of the team. Small, independent services are easier to develop and debug. A team focuses on their dedicated microservice without having to entangle the intricacies of the whole application, so developers can do more in less time.
• Reduced downtime and failure resilience. If one microservice needs updating or debugging, there is no need to take down the whole application and risk losing the clients frustrated with service interruption.
• DevOps enhancement. An application broken into smaller loosely-coupled chunks is faster to build, test, and send into production. Increased agility enables the company not only to accelerate time-to-market, but also shorten release cycles and introduce incremental updates. Moreover, application deployment and management can be further automated and facilitated by means of containerization, which reduces the risk of errors and saves time and human resources. As a result, a company spends less time and money on development, but at the same time provides a fail-proof, high-quality product to the customers.

But to make microservices work to your advantage, you need to design the architecture carefully and set up appropriate infrastructure. Read our guide to microservices to get a better grip on theory or use our tutorial and try building your own Java application based on this model.

If you worry about compatibility issues, our Liberica JDK supports the widest range of platforms on the market and so is great for building microservices regardless of devices used by your developers!

Migrate to the cloud

Some of the obvious and immediate cost reductions associated with cloud migration are:

• Cost of hardware (servers, auxiliary equipment), its licensing and maintenance
• Rental costs related to physical data centers and office premises
• Utility bills for electricity, gas, coolant, etc.
• Corporate downsizing

But cloud relocation is a serious endeavor. Although there are multiple technologies supporting cloud-native development, and cloud vendors offer ready solutions for cloud migration, you need to invest time and money into rewriting the code base, hiring or training personnel to work in cloud services, alleviating security risks associated with cloud hosting, etc.

By carefully defining the strategy of cloud-native development at your company, you will avoid such pitfalls as cloud-vendor lock-in, inflated cloud bills, and under- or overutilization of resources. Below are some of the best practices of working with the cloud.

Automate to the max.

Modern software solutions help businesses to automate various processes such as compliance and security monitoring, updates and patches integration, deployment, scaling and so on. By turning tasks into automatic workflows, you:

• Save the time of your developers for them to focus on enhancing your product
• Minimize the risk of human error
• Accelerate the CI/CD pipeline
• Introduce more complex deployment schemes such as blue-green or canary deployment to lessen the costs of software failures

You can use Kubernetes for automatic management and scaling of containers. To control corporate runtimes, use Liberica Administration Center (LAC). It enables you to manage all Java runtimes in the Windows PC fleet from a single dashboard, i.e. monitor licenses, integrate security patches, and perform updates with one click.

Monitor everything

Low prices for cloud resources may tempt you into the trap of neglect. Simply rolling out new instances is not always the solution to underperformance, and as a result, your application devours resources and still doesn’t meet the business requirements. Cloud monitoring is an essential part of TCO reduction strategy and rests upon the same principle: “do more with less”. Although it is a complex task requiring a separate discussion, key points are:

• Monitor the behavior of containers and Kubernetes pods: it is not uncommon for them to use two times less CPU than requested
• Check the JVM metrics regularly including garbage collection, which may impact the app’s performance significantly
• Retrieve Kubernetes metrics as part of cluster check-up
• Study latency, peak rates and app’s performance under load

As a result, you will be able to define an optimal scaling strategy, utilize resources wisely, and prevent unexpected expenses coming from the necessity to allocate more resources to the app due to rapid surge of requests, for instance, on Black Friday.

Watch your containers

Cloud computing implies working with virtual machines (VMs) or containers instead of physical equipment. We have already written about the benefits of containers, but if you rely heavily on out-of-the-box solutions, you will waste the potential of reducing the cloud costs even more by utilizing small and performant containers.

For instance, a Debian base container image size is 27.78MB, whereas an Alpaquita Linux base container image is only 3.59MB. Coupled with Liberica Lite it provides a small container for Java applications of only 52MB — imagine how much space in the cloud you can save!

But size is not the only container characteristic that matters. A perfect container for your enterprise doesn’t exist yet, but you can make one yourself:

• Choose a fresh JDK image with fresh bug fixes and security issues and make sure it is updated regularly
• Tune JVM parameters such as -Xmx or GC
• Determine heap and memory requirements
• Adjust the configurations based on load testing results
• Continuously monitor container health in production

In summary, take care of your containers and in return, they will contribute to your TCO reduction goals.

Clean out the waste on time

Unused data doesn’t disappear; instead, it accumulates on your instances like waste and thus deteriorates the performance of the application and takes up precious resources.

• Define the data retention policy. The data you or your users don’t use can be moved to cloud archives, which are cheaper than regular cloud storage. And some data can even be removed.
• After the data retention period expires, delete the data. Holding on to obsolete information simply for the sake of being on the safe side leads to unnecessary expenses and safety risks
• Clean up the database regularly and delete duplicate data
• Eliminate containers you no longer use. If you use Docker, stopped containers and images are not removed unless explicitly ordered, which results in extra space usage. Run docker image prune and docker container prune regularly to solve the issue.

Standardization

Standardization of IT infrastructure is aimed at reducing the complexity and total cost of systems used at the company. It covers

• Software. Instead of paying several JDK vendors, choose one whose runtime is compatible with all your platforms and thus reduce cost of support and time spent on monitoring the security and updates.
• Hardware. Maintaining both Aarch64 and x86 devices is more costly than using one architecture across the whole organization.
• Procedures. Standardized stack of frameworks, utilities, and programs promotes cooperation between teams following the same procedures, increases the security, and accelerates the time-to-market.

A good practice for a software company is to create a single container that suits all business needs and integrate it into all production stages, from development through testing to deployment. This way, you will minimize the number of vendors you work with, eliminate compatibility issues and save time of your developers.

BellSoft knows the value of standardization and offers a unified technology stack to Java developers:

• Liberica JDK, a unified runtime with the widest range of supported platforms and three flavors for different purposes
• Liberica NIK for creating native images
• LAC for automated runtime monitoring and updates
• JFR and Mission Control for performance profiling

Choose the right technologies

Energy-efficient hardware

Energy consumption is one of the most relevant topics in all industries because it is related both to high TCO and environmental pollution. The IT sector is no exception. For instance, in high-performance computing, the cost of a supercomputer is similar to the sum of energy bills over its lifetime. The same applies to any high-performance hardware: the reduction of time-to-solution leads to the increase of energy-to-solution.

Modern energy-efficient technology and appropriate design approaches can reduce energy consumption by 25%, server consolidation — by 20%. The combination of less power-hungry hardware and performant software will yield the best result. If you develop Java applications, Liberica JDK is compatible with the widest range of platforms, so it can be used with any server, cloud, or energy-efficient hardware of your choice.

Useful Java utilities

Using Java for enterprise development gives access to an extensive ecosystem of solutions aiding in overall improvement of app’s performance and memory consumption:

• Java Flight Recorder and Mission Control are used to profile and monitor Java applications and detect memory leaks, which lead to increased resource consumption
• Embedded Java databases like Daffodil DB help avoid compliance issues and are tuned together with other JVM settings thus reducing administration time
• Spring is a family of frameworks, where every developer will find a solution for their needs. In addition, Spring Native comes with embedded support for Liberica NIK, which enables the reduction of startup and memory consumption of Spring Boot applications. Find out how to reduce TCO of Spring apps with Liberica JDK in our white paper on the topic.

There is one more special technology developed by BellSoft: Liberica Native Image Kit (NIK). Liberica NIK is a tool that converts Java applications into small native executables thus minimizing memory footprint and accelerating startup. It supports multiple system configurations and programming languages, so it is perfect for microservices. Our tool is based on the Community Edition of GraalVM and is free to download and use.

Check out our guides on using Native Image Kit with various frameworks: Spring Native, Quarkus, and Micronaut. Or try it out now and see how the startup of your app reduces to 1/10 s!

Operating system

Another factor contributing to TCO reduction strategy is the choice of an operating system. The TCO for an OS includes:

• Installation and maintenance. Open-source solutions are cheaper than proprietary ones, but it is advisable to opt for products with optional commercial support to mitigate the risks and promptly deal with bugs and security issues.
• Support period. Some OSs have to be upgraded every couple of years, while other solutions enjoy long-term support from their vendors. In addition, some products require an upgrade of hardware leading to significant expenditures.
• Customization. The opportunity to customize an OS may be beneficial for some companies that evolve rapidly or have specific needs, but don’t want to be limited by end-user license agreement (EULAs).
• Downtime. Opt for products with high-availability because downtime has severe and costly impacts on business, from loss of customers to broken SLAs.

The most optimal OS that helps to meet the goals within the above mentioned aspects is Linux. Some studies have shown that Linux-based solutions are 26—36% (in case of free Linux distributions) and 19—27% (in case of Red Hat distribution) more cost-efficient than Windows-based ones. Read our review of Linux distributions for server and cloud to select an optimal solution.

The exciting news is that BellSoft created a lightweight Linux distribution tailor-made for Java applications, Alpaquita Linux. It is based on Alpine, but comes with a bunch of performance and security enhancements, as well as LTS support from BellSoft. What is more, we provide two Alpaquita variants based on optimized musl and glibc, so you don't have to worry about migration issues.

Learn more about Alpaquita Linux

Bundled together with Liberica Lite and Liberica NIK in a microcontainer. Alpaquita is an end-to-end solution optimized for creating and deploying Java apps. Imagine how much you can save by using Linux and JDK stemming from one vendor and with LTS support for both!

Open-source vs proprietary software

One way to reduce TCO dramatically is to opt out of proprietary software in favor of free open-source solutions. Although open source contributes to short-term cost reduction, which is an acquisition price, TCO is about long-term savings, ie., the price of maintaining the software. This is where hidden dangers of open source sit:

• Legal risks. Developers may accidentally pull licensed dependencies and violate copyright, which will lead to litigations and vast expenses
• Safety risks. Not all open-source products receive timely security updates, which means that your project may contain known vulnerabilities and be vulnerable to attacks. In addition, open source packages can be modified by anyone, and in rare cases, open software may contain malicious code.
• Operational risks. Many open-source products are maintained by the community and have no dedicated support. It means that in case there is a bug in the product you are using, you have to fill in the form and wait for your issue to be solved, sometimes for a couple of weeks. It is inacceptable for enterprise-grade technologies.

It doesn’t mean that all open-source products are inherently unsafe. The key is to find the right balance between free and proprietary technologies and choose open-source solutions from reliable vendors, with regular updates and optional commercial support.

Liberica JDK is a free Java runtime developed by BellSoft, a major OpenJDK contributor. You can use our binaries for free and stay safe and up-to-date with the quarterly CPU-release cycle, but you can also choose our High-Powered Support, which costs five times less than that of Oracle’s and provides you with off-cycle updates and response times within 24 hours based on SLAs.

Minimize risks

TCO includes hidden costs such as disaster recovery (after data loss or cyberattacks) and loss of clients or reputation. They are hard to calculate but always massive and should be accounted for in business strategy through risk mitigation.

IT companies can do the following to minimize risks related to their product:

• Reduce downtime by regularly checking the health status of hardware and software, choose software products (not only OS) with high availability.
• Define and follow SLA. Service Level Agreement (SLA) is an agreement between a company and commercial customers that details the company’s obligations towards users. An SLA should be carefully crafted with participation of developers, not only lawyers, because only your engineers know how to deliver services basen on the SLA. A realistic SLA is a prerequisite of clients’ satisfaction.
• Perform backup and protect your data. If one server or microservice goes down, you must have an opportunity to get it back online ASAP. Three leading causes of data loss are hardware or software failure and human error.
• Ensure enhanced security of the whole IT infrastructure. Make sure that your hardware is protected physically and with passwords, and your software receives regular security patches eliminating known vulnerabilities that can be used by hackers. Never use software dependencies from unknown sources or without fresh patches.
• Work with vendors providing reliable support. If there is a problem with any technology, it has to be solved promptly. For instance, our support team provides 24/7 access and security patches within 48 hours, and responds within one hour.

Virtual machines: good old classics

If you are not ready to shift development to the cloud, you still can reduce TCO through clever employment of hardware. Instead of underutilizing powerful server machines, virtualize them. If one physical server hosts ten virtual ones, instead of buying twelve servers you acquire only two (one for the backup purposes), and thus save min. 50% of initial acquisition cost plus minimize expenses for power and cooling.

The best operating system for virtual machines is Linux Server distribution. If you later decide to have a hybrid cloud application, i.e., part of the data is kept in physical data centers, another part in the cloud, you will benefit most from a Linux distribution suitable both for virtual machines and cloud computing, because, as we mentioned before, less vendors means less licensing expenses.

A Linux distribution soon to be marketed by BellSoft supports both virtualization and cloud technologies. Being even smaller than Alpine Linux, it will enable you to minimize the size of containers and VMs and save even more!

Summary

To sum up, there is no template of TCO reduction strategy as every business situation is unique. Nor are there any definite numbers in terms of savings. But following the “doing more with less” principle you will reduce

• Acquisition costs
• Maintenance
• Staffing costs
• Lost user productivity costs

BellSoft offers a unified stack of Java technologies enriched with Alpaquita Linux helping you to reach the goals described in this article:

• Liberica JDK, which supports the widest range of platforms (including modern energy-efficient devices), receives regular patches and updates, and comes in a lightweight version, is perfect for microservices and microcontainers
• Liberica Administration Center provides you with automated monitoring, license control, and updates of Java runtimes through the organization
• Liberica Native Image Kit helps to minimize resource consumption and accelerate startup
• Our soon-to-be-released Linux is suitable for cloud, servers, and VMs
• Our engineers provide LTS support both for JDK and Linux with fast response times and fixes