In addition to my main use case, while studying, I used JDK to build backend logic for my personal project, which is a form-fill assist application.
OpenJDK Java
Supported ImagesExternal reviews
3 reviews
from
External reviews are not included in the AWS star rating for the product.
Robust platform has supported secure wallet backends and reduced development costs
What is our primary use case?
My main use case for OpenJDK Java is to build Java backend code and backend logic. A specific example of a project where I used OpenJDK Java for backend logic is in my current organization, where we are using it to build our Deva code, which is an application that functions as a digital wallet.
What is most valuable?
The best features OpenJDK Java offers include its own garbage collection system, as it automatically removes unused objects, which is an important feature.
This feature has helped my development process because creating too many objects can lead to an out of memory situation, but the garbage collection efficiently deletes unused memory.
OpenJDK Java stands out for its portability, as it runs on a write once, run everywhere principle due to its virtual memory and JVM, which converts every code into machine code, making it helpful to run code on any device.
OpenJDK Java has positively impacted my organization by providing a large number of resources to find issues and creating a large environment that helps in many areas.
Having a large environment and many resources has helped my team specifically when we tried to use Redis components, as we could consult previous blogs to maintain it, which was helpful for integrating other components into our code.
What needs improvement?
To improve OpenJDK Java, I wish for more AI integrations and support for AI and API integrations, as we need AI capabilities to build using Java.
We would like to see better documentation of new features that are updated in OpenJDK Java.
It would be great to provide AI-related features and proper documentation to study OpenJDK Java.
For how long have I used the solution?
I have been using OpenJDK Java for around three years.
What do I think about the stability of the solution?
OpenJDK Java is very stable.
How are customer service and support?
The customer support for OpenJDK Java is very good, as they are happy to help us if we face any issues.
Which solution did I use previously and why did I switch?
We started our project with JDK only and did not previously use a different solution.
How was the initial setup?
We did not evaluate other options before choosing OpenJDK Java.
What was our ROI?
Since using OpenJDK Java, I believe the cost has reduced by up to fifty percent.
What's my experience with pricing, setup cost, and licensing?
I am not sure if we purchased OpenJDK Java through the AWS Marketplace as that is handled by our DevOps team.
I do not have prior experience with pricing, setup cost, and licensing for OpenJDK Java.
What other advice do I have?
OpenJDK Java has a large number of resources, allowing others to easily find solutions. I would rate this review as a nine out of ten.
Which deployment model are you using for this solution?
Private Cloud
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
Automation has improved reliability and development is delivering error-free tools
What is our primary use case?
My main use case for OpenJDK Java is developing software, and I have also worked with Java and Selenium for automating tasks.
How has it helped my organization?
OpenJDK Java has positively impacted our organization by helping us develop our tools and the software we use. We use Java very widely, and our applications are written in Java. Sometimes, with Java, we also use PowerShell codes, which I have integrated for automation purposes.
What is most valuable?
The best features that OpenJDK Java offers are the ease of using any other tools with Java; it is very easy and efficient, and troubleshooting in OpenJDK Java is the best thing you can say. It is very easy, and it will tell you where or what exact error you have. Additionally, OpenJDK Java is a pure object-oriented programming language.
Troubleshooting in OpenJDK Java has helped me in my work while using Eclipse as a tool, which supports multiple languages including Java, Python, and Selenium. In Eclipse, at the bottom of the page under the terminal, if there are any errors, you can see the errors, and it will indicate the line number or what mistake you have made, making it very easy. Even a non-technical person will be able to understand what that error is about.
Since using OpenJDK Java, the specific outcomes include that the Selenium automation I have done in Java on the client's home page has given us very good reliability, and after that, we never received any escalation or an email from the client that this page is down and no one is looking into it. OpenJDK Java is extremely awesome.
What needs improvement?
OpenJDK Java does not need any improvement; it is already the best in the market. I have not faced any issues nor noticed anything that needs improvement. It also supports multiple classes, and what we can do in OpenJDK Java is write multiple classes, which can all be integrated into a .jar file.
For how long have I used the solution?
I have been using OpenJDK Java for the last four years.
What other advice do I have?
My advice to others looking into using OpenJDK Java is to please go ahead and use it because it is the best. If you are using Python, then you understand the syntax is easy in Python, but the indentation is problematic, whereas OpenJDK Java is extremely awesome; we do not have an indentation issue, and the code is understandable and not that difficult. I rate this product a 10.
Reliable parsing has transformed financial document workflows and supports accurate LLM extraction
What is our primary use case?
My main use case for OpenJDK Java revolves around incoming financial documents such as PDFs, scanned balance sheets, and trial balances from clients. Apache Tika, which runs on OpenJDK Java, parses those documents and extracts the raw text. From there, we pass that cleaned text into our OCR pipeline using Tesseract and then feed it into our large language models for structured extraction, such as account mapping and compliance classification. OpenJDK Java gives a stable, reliable foundation for that parsing layer.
One thing worth mentioning about my use case is that consistency is crucial for us. Financial documents are sensitive, and we need reliable parsing. OpenJDK Java-backed tooling provides that stability. We run it on Linux servers in production for over a year with minimal issues. The concurrent processing capability is also important because we often batch process multiple documents at once, and it handles that load without memory problems. It is not just about parsing; it is about having a dependable backbone that we can trust in the production environment handling real clients.
What is most valuable?
The best features OpenJDK Java offers, in my experience, include stability, ecosystem maturity, and solid performance. The biggest one for us is stability; it runs consistently. Once we set it up on our Linux infrastructure, it is rock solid, with minimal downtime and no unexpected crashes over the year and a half we used it. The second is the maturity of the ecosystem. Because it has been around for so long, there are incredibly robust libraries built on top of it, with Apache Tika being the perfect example for our use case. Finally, performance matters. Once the JVM warms up, the throughput for document parsing tasks is consistent and predictable, which is essential when processing batches. Those three things make OpenJDK Java valuable for us in the production financial document space.
OpenJDK Java has positively impacted my organization by significantly reducing parsing failures. Before standardizing on this stack, we dealt with manual workarounds for document format inconsistencies, where approximately 10 to 15 percent of incoming documents required manual intervention. Once we locked in Apache Tika and OpenJDK Java as our parsing foundation, that dropped to approximately 2 to 3 percent. That is a huge operational improvement for our team because it meant less manual rework and faster throughput for our clients. On the speed side, document processing time became predictable; we could reliably process a financial document from ingestion to structured output in under two minutes on average, meeting our client service level agreements. From a cost perspective, being open source meant avoiding licensing fees, freeing up budget to reinvest in our machine learning models and infrastructure. For the team workflow itself, the sustainability meant our engineers spent less time debugging parsing issues and more time on higher-value work, improving our LLM extraction logic and building new features. There was a genuine productivity gain.
What needs improvement?
The JVM startup time is noticeable for lightweight, one-off document parsing tasks; that warm-up overhead feels unnecessary compared to a Python script that starts instantly. In a high-concurrency microservices environment where containers are spun up frequently, that matters significantly.
On the developer experience side, managing Java versions across different environments can get messy. We encounter situations where local development is running one JDK version, staging is another, and production is different. Without proper tooling such as SDKMAN or Docker, it becomes a coordination headache. Better built-in versioning and consistency would help. Regarding documentation, the OpenJDK Java documentation itself is solid but quite dense and assumes a certain level of Java knowledge. For teams coming from other backgrounds such as mine, which has a lot of Python and JavaScript experience, the barrier to entry is steeper than necessary. More beginner-friendly getting started guides would be beneficial. Additionally, the JVM baseline memory usage is significant. For resource-constrained environments or when running multiple lightweight services, that overhead adds up. Lighter JVM variants exist, but they are not as well-documented or easy to adopt. Better guidance on choosing the right JVM flavor would smooth that out.
I choose a rating of 8 out of 10 for OpenJDK Java because it could reach a 10 if the JVM startup time was dramatically reduced, perhaps through better default configurations or a lightweight default build for serverless and containerized workflows where speed matters. Secondly, a streamlined, unified approach to version management and environment consistency built in would help eliminate the need for juggling SDKMAN, Docker, and multiple configurations. Lastly, better memory efficiency out of the box would be ideal. If OpenJDK Java could run with smaller baseline footprints without sacrificing performance or stability, it would be a clear winner across more use cases. While it is the best choice for stable, long-running backend services and document processing pipelines, it has trade-offs for lighter, more distributed architectures. Fix those, and it would be a 10 out of 10.
For how long have I used the solution?
I have been using OpenJDK Java for approximately one and a half years.
What do I think about the stability of the solution?
OpenJDK Java is stable. It has been rock solid for us in production. Over the one and a half years we have run it, we have experienced minimal unplanned downtime or crashes. The JVM itself is incredibly mature and well-tested across millions of deployments worldwide, which is vital for financial document processing where reliability is non-negotiable. We can depend on it.
What do I think about the scalability of the solution?
On scalability, OpenJDK Java is good but has nuances. For our use case of batch document processing, it handles concurrent requests well, allowing us to process multiple documents simultaneously without memory leaks or performance degradation. The garbage collection is solid once we understand how to tune it. However, scalability depends on your infrastructure approach. Horizontally, we can scale by adding more servers running OpenJDK Java instances. Vertically, there are limits since the JVM's baseline memory footprint means we cannot plug unlimited instances on a single machine. For our document volumes and processing patterns, we never hit those limits.
How are customer service and support?
The community support for OpenJDK Java is massive and active. When we encounter issues or have questions, Stack Overflow usually has answers. OpenJDK Java documentation itself is comprehensive, though it is dense and assumes some Java experience. For our team, coming from Python and JavaScript backgrounds, we had to do additional learning, but the resources are there. Specifically, the Apache Tika community has helped us greatly; the documentation for Tika is solid, with good examples, and the community forums are responsive. When we run into edge cases with parsing specific document formats, we typically find discussions or solutions within the community. The trade-off with open source is that we do not pay for dedicated support; however, we are also not dependent on the vendor support queue. We need to be more self-sufficient, but this approach works for our team. We troubleshoot, read documentation, check community discussions, and usually find answers within hours rather than waiting for support tickets.
Which solution did I use previously and why did I switch?
Before standardizing on OpenJDK Java, we used a more fragmented approach. We had a mix of Python-based text extraction tools and some proprietary PDF parsing libraries. The problem was inconsistency; different document formats failed unpredictably with different tools. We ended up with manual workarounds, with team members extracting data from PDFs that the automated pipeline could not handle reliably. We switched to OpenJDK Java and Apache Tika because we required something battle-tested and stable for production use with financial documents. The Java ecosystem had proven libraries that could handle edge cases and unusual document formats that were giving us trouble. Tika's maturity and the JVM's stability made it the right choice, simplifying our tech stack significantly. Instead of maintaining multiple parsing tools across different languages, we have one solid foundation that reduces operational complexity. In hindsight, it was absolutely the right decision; the consistency and reliability improvements justified the learning curve my team had to undergo coming from a Python-heavy background.
How was the initial setup?
We deployed OpenJDK Java on-premises. We run our OpenJDK Java infrastructure on Linux servers hosted in our own data center setup, which is important for our use case because we handle sensitive financial documents for clients including balance sheets, trial balances, and compliance data. Having on-premises infrastructure gives us direct control over data residency and security, crucial for client trust and regulatory compliance. We consider cloud options eventually; Docker containerization makes it theoretically portable to cloud environments if needed. However, we decided to keep it on-premises for data sovereignty reasons. The on-premises setup started well for us because our document volumes are predictable, allowing us to manage infrastructure costs directly. We do not need the auto-scaling flexibility that cloud would offer.
What was our ROI?
I have indeed seen a return on investment with OpenJDK Java, particularly in operational efficiency. As mentioned earlier, we reduced manual document processing interventions from around 10 to 15 percent down to 2 to 3 percent. That means our team of three document processors can handle approximately 40 to 50 percent more documents per week without adding headcount. Over a year and a half, that is a significant capacity gain without hiring additional people. On the cost side, being open source means we incurred zero licensing fees. For a financial document processing platform, that represents real money saved since commercial Java solutions would have cost us thousands annually in licensing alone. Development time is another critical metric; our engineers spend significantly less time debugging parsing failures and environment issues. I estimate we save approximately 15 to 20 percent of engineering time that would have gone to infrastructure maintenance, which we redirect toward building new features and improving our LLM extraction accuracy. The speed of processing a document from ingestion to final structured output in under two minutes means we meet aggressive client turnaround SLAs, translating directly to client retention and upsell opportunities.
Which other solutions did I evaluate?
We considered several alternatives before choosing OpenJDK Java. We explored a pure Python-based solution using libraries such as PyPDF2 or PDFPlumber for document parsing. The appeal was that our core application logic was already in Python, making for a simpler tech stack. The trade-off was in limitations with complex and scanned financial documents as those libraries are not as robust for edge cases. We landed on Apache Tika running on OpenJDK Java because it struck the right balance. It is mature, battle-tested for handling complex document formats, open source, meaning no licensing overhead, and the ecosystem is solid. Introducing Java into our stack meant stability and reliability gains justified the architectural decision.
What other advice do I have?
If someone is considering using OpenJDK Java, I advise being clear about your use case; OpenJDK Java is excellent for backend services, document processing, and financial systems where stability and long-term reliability are crucial but less ideal for lightweight microservices or serverless workloads where startup time is critical. Secondly, invest in proper tooling from day one; use Docker for environment consistency, SDKMAN for Java version management, and set up proper JVM tuning parameters early. Do not underestimate this investment; it saves months of friction later. Third, embrace the ecosystem; the Java ecosystem is mature and battle-tested. Proven solutions such as Apache Tika, Jackson, and Spring Boot should not be reinvented. Fourth, understand memory and performance tuning; the JVM is powerful but requires thoughtfulness around garbage collection and heap settings. Spend time understanding these basics upfront. Finally, if you come from a Python and JavaScript background such as my team, budget extra time for the learning curve. Java has different paradigms and conventions, but it is worth learning because the payoff in stability and production reliability is genuine.
OpenJDK Java proved itself in a real mission-critical scenario for us. Financial document processing is not forgiving; if your parsing fails, your entire downstream pipeline breaks. The fact that we can rely on OpenJDK Java and Apache Tika to handle that responsibility consistently over 18 months speaks volumes. I would emphasize the longevity factor; OpenJDK Java is backed by the Java community and Oracle, providing confidence that this platform will be supported and maintained for years to come. That is important when building systems that clients depend on. Furthermore, if you evaluate solutions for backend infrastructure or document processing, do not overlook OpenJDK Java just because it has been around for decades. Its age is actually a strength, not a weakness, signifying that the platform has been battle-tested in countless production scenarios, where bugs have been found and fixed, and the best practices are well established. I provided an overall rating of 8 out of 10 for OpenJDK Java.
Open source tools have supported my Java learning and enabled cross platform development projects
What is our primary use case?
From my first or second semester, I have been using OpenJDK Java on my local PC as part of my college journey and academic learning. I have been using OpenJDK Java for personal projects and during my internship, where I also work on a project utilizing OpenJDK Java mainly for developing and testing Java-based applications such as those in banking sectors and many other systems.
In my third semester, I had one subject, OOPs, where I needed to perform practicals and create an application in Java. I mainly use OpenJDK Java because without it I cannot support my coding needs.
My application relies on OpenJDK Java, as my source code is in Java. Without OpenJDK Java, I cannot manage or run the application or source code because OpenJDK Java is the installer package that is needed. Otherwise, I cannot run my simple code.
For my internship, I only use OpenJDK Java for my college project. While working at my internship, I also needed OpenJDK Java for my college project. It is compatible with almost every development studio such as VS Code and IntelliJ IDEA, which is the Java software. I used both for my college project, starting with IntelliJ IDEA to run my source codes, and in the next semester, I had a subject on advanced Java, where I learned more about OpenJDK Java and Java.
Throughout many subjects in my college academic journey, I needed OpenJDK Java as part of my role as a support engineer. It provides almost all the core features required for Java development, including support for OOPs concepts. For instance, in one subject called OOPs, I needed JDK support to perform my Java programming. I also use OpenJDK Java for database work in DBMS with MS SQL, needing it to run their workbench.
What is most valuable?
OpenJDK Java offers open-source capabilities, which are significant because my laptop runs on Windows while my friend's system uses macOS. It is open-source and cross-platform, which is beneficial as it supports every system when changing the Windows operating system. Therefore, these two features are among the best for me.
I also appreciate the security updates provided by OpenJDK Java. When I download the JDK, it comes in a specific version, but subsequent updates resolve issues with earlier applications. It is continuously updating features, which is the best aspect of OpenJDK Java.
OpenJDK Java also has strong community support, making it the best option for me. OpenJDK Java has saved me time and effort, being one of my main resources that is free to use and helpful as a student. It provides almost all the core features required for Java development, including OOPs concepts, exception handling, file management, and database connectivity.
What needs improvement?
Currently, OpenJDK Java is perfect for me, and I do not think any updates are needed. It works perfectly, and I do not want to add anything else to OpenJDK Java.
For how long have I used the solution?
Since my first or second semester.
What do I think about the stability of the solution?
OpenJDK Java is stable in my experience.
What do I think about the scalability of the solution?
OpenJDK Java is completely scalable and fully reliable for me.
OpenJDK Java is fully scalable for my projects and organization.
How are customer service and support?
I find customer support to be perfect.
How was the initial setup?
I installed it on Ubuntu Linux, and the process was quite smooth using the default package manager.
What's my experience with pricing, setup cost, and licensing?
It saves me both money and time.
Which other solutions did I evaluate?
I did not evaluate other options before choosing OpenJDK Java.
Modern development has become faster and reusable with long-term support and rich language features
What is our primary use case?
OpenJDK Java is one of the open-source Java development kits that I use. With all the Java libraries included in the JRE, I can handle all cases regarding object-oriented programming. However, it does not include J2EE (Java Enterprise Edition). OpenJDK Java is used for Java development and can be utilized in Spring Boot, Spring framework, and other play frameworks.
OpenJDK Java provides nearly all the functionality that Java uses. When comparing OpenJDK Java to Java EE, OpenJDK Java offers better code reusability through OOPs features, class collections, and collection frameworks. These features also bring some J2EE capabilities through beans. A main feature is that OpenJDK Java has Long-Term Support (LTS). For example, Java 21 has long-term support, and Java 1.8, Java 11, and Java 17 also have long-term support. Additionally, there is no cost for development, whereas Java EE is a paid feature where beans are handled by Java. From Spring Boot and Spring framework, I can use OpenJDK Java effectively.
OpenJDK Java runs on Windows, Linux, and macOS across every type of operating system. Similar to Java, OpenJDK Java compiles with Java code into bytecode, which runs in the JVM machine. All the features included in JEE are already present, such as Java compile code, Java run program, Javadoc, and job running and debugging. Multithreading is supported by OpenJDK Java. These are powerful tools, and high performance is available. JIT compilation and adaptive optimization are also present, along with regular updates as a main feature.
Java typically updates twice a year, with updates occurring every six months. Regular updates include bug fixes that do not impact the code if I use LTS (Long-Term Support). If a small update comes, that is fine. If a big update comes, I can also handle it. LTS support will always be available as a key feature. Currently, Java 21 has LTS support, and any update that comes will support my code.
What is most valuable?
OpenJDK Java can be used for Java development in Spring Boot, Spring framework, and other play frameworks. OpenJDK Java provides code reusability through OOPs features, class collections, and collection frameworks. Long-Term Support exists in OpenJDK Java for versions such as Java 21, Java 1.8, Java 11, and Java 17. OpenJDK Java runs on Windows, Linux, and macOS. It compiles with Java code and supports multithreading, high performance, JIT compilation, and regular updates.
What needs improvement?
Bean optimization could be improved. When comparing Java 1.8, which has a basic structure with for loops, to the stream API, the libraries are beneficial but slower. A for loop is a single loop that runs at the core level, whereas the stream API does the same thing but with slightly lower performance. Several improvements could be handled: performance improvement, better garbage collector latency, cloud container awareness, and cleaner syntax. Additionally, lambda is complex for beginners, so the usage of lambda could be improved.
The world is moving toward generative programming and AI usage with agentic approaches. Developers should have better handling of automatic GC performance issues. When compiling anything and an error is thrown, I want developers to have better performance insights into how this error will occur. Through AI, they can debug more effectively. Currently, when errors come, they are not straightforward. Developers have to read between the lines. If AI explains the error response, that would be better. Additionally, code usability could benefit from AI agentic capabilities.
For how long have I used the solution?
I am currently using OpenJDK Java.
What do I think about the stability of the solution?
I do not think there are any stability issues. Java has a very large community, so if anything comes up, I am able to resolve it. In this AI era, most issues can already be resolved. I do not believe any challenges have come that cannot be overcome.
What do I think about the scalability of the solution?
I do not think there is any scalability issue in OpenJDK Java.
How was the initial setup?
I do not think there are any challenges with initial setup. However, when installing any application, everything should be set up automatically, similar to how Java is installed. There should be no need to write environment variables. They should already be set up in the system. At the beginner level, developers can only write the code and do not have to use environment variables at all.
What's my experience with pricing, setup cost, and licensing?
The API impact on OpenJDK Java is minimal. When using the Spring Boot framework or similar frameworks, most things and beans are handled by the Spring framework. OpenJDK Java supports method level functionality with no difference from J2EE. However, bean handling can be a consideration because J2EE handles beans more efficiently compared to other frameworks. J2EE uses better bean optimization. Apart from this, I do not think there is any other issue. Most libraries already support both J2EE and OpenJDK Java, so I do not think there is any other impact.
Regarding development impact, performance-wise, OpenJDK Java is faster. One of the best features is that I can change my code and create my own compiler. Whatever method I choose, I can modify the code in JIT within OpenJDK Java. This is not possible in J2EE as J2EE does not allow these things. In Java 1.8, I can also change the background code and library code as this is allowed.
What other advice do I have?
OpenJDK Java is open for everyone, every developer, and every company, and it is free of cost. There is no deployment cost or any such pricing. OpenJDK Java can be used for developing any type of software that uses API level functionality, such as backend software. I gave this review a rating of 8.5 out of 10. If a company is choosing Java tools, they should go for OpenJDK Java.
Centralized development has delivered fast, secure payment processing with strong community support
What is our primary use case?
OpenJDK Java is used centrally for developing back-end services like APIs, batch processing, and file processing. It is easy to integrate OpenJDK Java with any other product or other languages regarding cross-platform capabilities.
What is most valuable?
What stands out for me about OpenJDK Java is that it is good for processing fast and very efficient in memory management from a technical perspective. It is fast, reliable, and easy to develop any concept in the payment industry.
The community support in OpenJDK is very helpful for my development process. The community has helped me with information on the latest features they added, new encryption and decryption methods, and how the internal memory works. These are the pieces of information I can get from the community channels.
I see a benefit from the regular updates in OpenJDK, as it is beneficial when we face many challenges in development. The regular updates from Oracle provide patches to solve different challenges in terms of security and memory management. From a developer's point of view, it also makes tasks easier.
What needs improvement?
Regarding OpenJDK, I do see areas for improvement, though I cannot currently comment on potential improvements. I acknowledge that there is a chance for enhancement.
Comparing OpenJDK Java with Python and other scripting languages, I find it a bit bulky, as it takes a lot of effort to enable scripts in a system. While Python is good for small tasks and easy to deploy, OpenJDK Java requires more effort for similar tasks.
For how long have I used the solution?
I stopped using it in March 2025, which is more than a year back now.
What do I think about the stability of the solution?
OpenJDK Java is 100% stable and demonstrates no downtime or glitches.
What do I think about the scalability of the solution?
OpenJDK Java is scalable.
How are customer service and support?
Community support is available, and there is also technical support with many discussions happening in different communities since it is an open platform, offering a lot of assistance. In my case, community support has been sufficient, and I did not need to reach out to technical support for the product.
How was the initial setup?
Installation for OpenJDK Java is easy, with not much complexity in the steps.
What was our ROI?
I can observe savings in my ROI and categorize it as money-saving. If I quantify the savings, I see about 60% in money savings and 40% in time savings.
What's my experience with pricing, setup cost, and licensing?
In terms of licensing and pricing for OpenJDK Java, I find it affordable and not expensive.
What other advice do I have?
I have experience with TiDB Cloud as I have been using that product before. I am working right now with multiple vendors and not only with a particular database, as I am using front end and back end languages including React and Angular. I am currently writing some Python code and back end Java.
The languages I am using include Angular, React, Java, and Python. PowerCARD is the product I am currently working on, which is a card product and an HPS product.
I am using OpenJDK Java and confirm that I use OpenJDK Java. I have around 10 plus years of experience with OpenJDK Java. I work with the product not only as a user but also as a consultant, working as a consultant with the vendor.
APIs impact my development speed positively as it is fast and secure, and it is easy to integrate across platforms with different tools and technologies. Almost all the tools available in the market are Java JDK enabled, making integration with OpenJDK Java very easy.
The cloud-native capabilities in OpenJDK Java are beneficial for my projects, as about 80 to 90% of the projects I work on in the card and payment industry are running on OpenJDK Java. I work in a hybrid environment, using a mix of cloud and on-premises solutions.
I have solutions available on AWS Cloud, and OpenJDK Java is compatible with AWS and Azure, as I use both. As of now, I have not purchased anything from the AWS marketplace.
I give this review a rating of 8 out of 10.
Which deployment model are you using for this solution?
Hybrid Cloud
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
Amazon Web Services (AWS)
Building secure microservices has improved reliability and supports high-volume enterprise workflows
What is our primary use case?
My main use case for OpenJDK Java is developing enterprise-level back-end applications. I used Java, particularly with Spring Boot frameworks, to build secure and high-performance REST APIs. Java is also my go-to language for integrating it with databases like Oracle and MySQL and handling message systems such as Kafka and RabbitMQ, as well as implementing validation frameworks.
In my recent role, I developed and maintained OpenJDK Java Spring Boot microservices for an enterprise compliance and sanctions platform using OpenJDK Java as the runtime environment for all our back-end services to ensure open-source compatibility and ease of deployment. My responsibilities included designing the REST APIs, implementing the business validation frameworks, and integrating with Oracle databases and Kafka systems. The application handled critical workflows like watchlist onboarding and attestation and required high reliability and scalability, which OpenJDK Java provided.
In addition to the back-end, I used OpenJDK Java for implementing automated testing frameworks such as JUnit and Selenium to ensure code quality and reliability. I appreciate OpenJDK Java's regular updates and security patches, which helped maintain compliance and stability in production environments.
How has it helped my organization?
Out of those features, I rely mostly on OpenJDK Java's strong support for multithreading and concurrency in my day-to-day work. I often build back-end microservices that need to handle multiple requests simultaneously and process large volumes of data efficiently. OpenJDK Java's concurrency features, like the executor framework and synchronized collections, help me design scalable and responsive applications.
Using OpenJDK Java has impacted my organization positively. It has significantly improved productivity by providing a stable and mature platform. The rich set of libraries and frameworks like Spring Boot and Hibernate accelerates development and reduces the time needed.
By leveraging these OpenJDK Java frameworks and libraries, we reduced our development time by approximately twenty-five percent, allowing us to deliver features faster, and the automated memory management and troubleshooting have contributed to a fifteen percent reduction in production incidents and downtime.
What is most valuable?
The best features OpenJDK Java offers include robust cross-platform compatibility allowing applications to run seamlessly on different operating systems, strong memory management and garbage collection. There are rich standard libraries and APIs for networking, excellent support for multithreading, regular updates and security patches, wide ecosystem support including frameworks like Spring Boot, and strong backward compatibility, making it easier to maintain, along with an active community and extensive documentation.
Its cross-platform compatibility has reduced infrastructure costs as applications can be deployed on various operating systems without major changes. OpenJDK Java's strong memory management and garbage collection have contributed to system reliability, minimizing downtime and performance issues.
What needs improvement?
OpenJDK Java can be improved in startup time and memory footprint, especially for microservices and cloud-native applications where lightweight containers are preferred. Enhancing native integration and support for modern deployment models like serverless and containerized environments would make OpenJDK Java even more competitive. Simplifying the module system and improving the documentation could help reduce the learning curve for new developers. Continued investment in performance optimizations, especially for garbage collection and low-latency applications, would benefit high-throughput systems. Expanding the ecosystem of tools for monitoring, profiling, and debugging OpenJDK Java applications in distributed environments would further support enterprise adoption.
Improving the onboarding experience for new developers by providing more interactive tutorials, better documentation, and enhancing IDE integration with more out-of-the-box tools for code analysis is necessary. Increasing the visibility and accessibility of community-driven resources would also be beneficial.
For how long have I used the solution?
I have been using OpenJDK Java for seven years, starting from the early stages of my career. I have used various distributions of OpenJDK Java. In my recent years, it has become more of a standard in many of our enterprise environments.
What other advice do I have?
I would advise others looking into using OpenJDK Java to take advantage of it and regularly update to the latest release, mainly to benefit from security patches. Also evaluate your application's compatibility with the specific version planned for use and leverage strong community support and extensive documentation available for troubleshooting and best practices. It is wise to integrate automated testing and CI/CD pipelines to ensure smooth deployments and maintain code quality.
OpenJDK Java has a very reliable and robust platform, and its open-source model encourages innovation and transparency. The flexibility to deploy OpenJDK Java across different environments, on-premise, cloud, or containers makes it a versatile choice. I would rate this product a ten out of ten.
Which deployment model are you using for this solution?
Hybrid Cloud
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
Amazon Web Services (AWS)
Cross-platform backend services have accelerated certificate APIs and simplified developer work
What is our primary use case?
My main use case for OpenJDK Java is for backend services.
A specific example of how I use OpenJDK Java in my work is for the backend server for textual service certificates.
The kind of backend systems or applications I support with OpenJDK Java is an API that's mostly for developers who communicate through our API.
What is most valuable?
In my opinion, the best feature that OpenJDK Java offers is that it's a cross-platform solution you can use on any operating system.
The way that helps my team or projects is that it definitely makes our backend developers' lives easier. It's easy to develop and faster to deploy.
OpenJDK Java is well supported, and it really helps our developers.
OpenJDK Java has positively impacted my organization because if developers can deliver work faster, it has of course positively impacted the company.
What needs improvement?
Unfortunately, I cannot answer how OpenJDK Java can be improved. The only thing I can say is that perhaps it could provide more functions or available libraries.
The improvements OpenJDK Java needs are mostly just the functions and drivers that need to be set up.
For how long have I used the solution?
I have been using OpenJDK Java for four years.
What do I think about the stability of the solution?
In my experience, OpenJDK Java is stable.
What do I think about the scalability of the solution?
The scalability of OpenJDK Java is good so far.
How are customer service and support?
The customer support for OpenJDK Java is good.
How would you rate customer service and support?
Which solution did I use previously and why did I switch?
I did not use a different solution before OpenJDK Java.
What about the implementation team?
I purchased OpenJDK Java through the AWS Marketplace as a company decision.
What was our ROI?
I have not seen a return on investment with OpenJDK Java.
What's my experience with pricing, setup cost, and licensing?
My experience with pricing, setup cost, and licensing is that I cannot speak to it because I have not experienced anything.
Which other solutions did I evaluate?
I have not evaluated any other options before choosing OpenJDK Java.
What other advice do I have?
I think everything is clear regarding how I use OpenJDK Java in my setup, so I have nothing other than that to add.
I would rate OpenJDK Java an eight out of ten.
I chose eight out of ten because, as I mentioned, I believe it is a strong solution.
I do not have any advice to give to others looking into using OpenJDK Java.
My company does not have a business relationship with this vendor other than being a customer.
The overall rating for this review is eight out of ten.
Which deployment model are you using for this solution?
Public Cloud
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
Backend services have delivered faster APIs and support present and future growth
What is our primary use case?
My main use case for OpenJDK Java is to use it as a backend service to build my APIs.
What is most valuable?
OpenJDK Java offers the best features of being faster, easy to build, and user-friendly. Faster performance stands out the most for my team. OpenJDK Java has impacted my organization positively because it is our main backend service.
For how long have I used the solution?
I have been using OpenJDK Java for three years.
What other advice do I have?
Scalability and maintainability have benefited my team and projects significantly. Since using OpenJDK Java, we have noticed scalable applications. My applications have better coding practices. OpenJDK Java makes it very easy to get updates. OpenJDK Java is very good. I would rate this product 9 out of 10.
Migration has cut licensing costs and supports long-term api development and maintenance
What is our primary use case?
OpenJDK Java is used for Spring Boot APIs written using versions 21 to 24. A specific example of how OpenJDK Java is used with those Spring Boot APIs is that it is built on top of OpenJDK, so it is used to compile and run the APIs.
What is most valuable?
The best feature OpenJDK Java offers is that it is free software with no licensing fees.
The free licensing aspect helps the organization by impacting the budget and helping save on costs.
OpenJDK Java has positively impacted the organization because, since Java was taken over by Oracle, it became very difficult to secure the license, which was heavy on the cost. OpenJDK Java helped to save on that, and it is very similar to the Oracle JDK.
Almost a million dollars in cost savings have been realized since switching to OpenJDK Java.
What needs improvement?
OpenJDK Java performs well overall. However, OpenJDK Java could be improved in terms of memory performance, and threads could be better optimized.
For how long have I used the solution?
OpenJDK Java has been in use for 10 years.
What do I think about the stability of the solution?
OpenJDK Java is stable.
What do I think about the scalability of the solution?
No scalability issues have been observed with OpenJDK Java; it scales very well.
How are customer service and support?
The customer support for OpenJDK Java is very good with no problems.
How would you rate customer service and support?
Which solution did I use previously and why did I switch?
Before using OpenJDK Java, Oracle Java was used, but the switch was necessary because of the licensing cost.
How was the initial setup?
OpenJDK Java was purchased through the AWS Marketplace.
What was our ROI?
A return on investment has been realized, specifically in terms of money saved and time saved.
Approximately two hours daily have been saved in terms of maintenance since implementing OpenJDK Java, and in terms of project estimation, about four to six story points are saved.
What's my experience with pricing, setup cost, and licensing?
The experience with pricing, setup cost, and licensing has been very positive; the licensing was free, and the cost was negligible.
Which other solutions did I evaluate?
Before choosing OpenJDK Java, Java was required, so OpenJDK Java was the only other option available.
What other advice do I have?
OpenJDK Java is license-free for this use case.
OpenJDK Java is very performant, and memory issues are not commonly observed.
The advice to others looking into using OpenJDK Java is that if there is a need to save on the licensing cost and benefit from the advantages of Oracle Java, OpenJDK Java is recommended. This review has been rated 10 out of 10.
Which deployment model are you using for this solution?
Hybrid Cloud
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
showing 1 - 10