Something has been in the works since Azul completed its acquisition of Payara in December 2025, and today we're ready to share it: the community edition of Payara has a new name and logo – but not so very different from the one you already know!

Payara Platform Community is now Azul Payara Community, made up of two distributions you already know and love - Azul Payara Server Community and Azul Payara Micro Community - plus the tooling and connectors that go with them.

It's a small change in letters but an important one. The new name reflects where we are: fully part of the Azul family, with all the backing that brings, while staying true to what this project has always been - an open-source runtime built by and for the Java and Jakarta EE community.

The iconic Payara fish has also had a bit of a refresh. The Azul Payara commercial logos were updated back in December, and now the community edition gets the same treatment - same fish character the Payara community knows well, just updated to match its new home at Azul.

What the acquisition means for the Community

We believe the open-source community is the heart of the Payara ecosystem. The contributors, committers and developers using Azul Payara Community for testing, education, side projects or apps that haven't gone commercial yet all matter to us. Growing that community, listening to it and investing in it is central to how we think about Azul Payara's future.

The rebrand is part of bringing Azul Payara Community properly into the Azul portfolio alongside Azul Zulu (OpenJDK), Azul Prime, Intelligence Cloud and Azul Payara’s commercial offering. It's the same open-source project with a new home in the broader Azul ecosystem.

What's changing (and when)

Over the coming weeks and months, you can expect to see updates to Payara documentation, resource names, technical content and the blog. Downloads are still available at payara.fish for now, but will be moving to Azul website before long - we'll announce that when the time comes.

One thing we're particularly excited about: we'll be increasing our presence here on Foojay sharing everything that is relevant for the Friends of OpenJDK community - educational content, tutorials, community updates and more.

For social media, we're consolidating onto Foojay and Azul's official channels. Make sure you're following us there, so you don't miss a thing.

Getting out and meeting you

Together with the Azul DevRel, Product and Engineering Teams, we're planning to visit a lot of Java User Groups over the coming months, and we're really looking forward to meeting community members face to face. If your JUG would like a visit or a talk on Azul Payara Community, OpenJDK or Jakarta EE - let us know.

We'll also be at a number of Java conferences this year. More details to come, but if you spot us - come and say hello.

What's been shipping: April and May 2026 Azul Payara Community Releases

We didn't want to announce the rebrand without also catching you up on recent releases (download here!), so here's a combined look at what landed for Azul Payara Community in April and May.

May: Azul Payara Community 7.2026.5

Security fixes (critical - please upgrade):

• Remote arbitrary file read vulnerability via unsafe parsing of OpenMQ configuration
• Restricted access to vulnerable EL expressions

Bug fixes:

• Admin Console freezing after upgrading from Payara 6 to 7

Improvements:

• Updated JACC Provider Compatibility Startup Service

• Audit Modules removed

• warlibs support added to Admin Console redeployment

• Reduced INFO logging for the Jakarta Data implementation

• New deployment descriptors created with deprecated properties removed

• Fix for Jakarta Data @Repository methods not throwing UnsupportedOperationException when no implementation logic can be injected at deploy time

Component upgrades: Docker JDK images refreshed to 21.0.11 and 25.0.3, with dependency updates for Jakarta Faces, MicroProfile Config, Project Reactor, and other libraries.

The critical security fix is also backported across Azul Payara 6.38.0, 5.87.0, and 4.1.2.191.55 — we recommend all users upgrade regardless of which branch they're on.

April: Azul Payara Community 7.2026.4

April's community release was a significant cleanup milestone, removing three long-standing deprecated items: the start-domain --upgrade service (replaced by the Payara Upgrade Tool), all methods previously annotated @Deprecated, and all deprecated configuration properties.

Bug fixes:

• Asadmin Recorder generating invalid commands when recording MicroProfile property changes

• Rendering issue in the Admin Console connection pool Advanced tab

• Broken news link in the Admin Console

• Race condition in application-scoped QueryData under concurrent access

• OpenMQ unclosed stream warnings

Community contributions from Lenny Primak:

• Fix for CDI annotation type resolution failing when annotations were defined in WAR library dependencies
• Resolution of an SLF4J class loader leak that could accumulate memory in long-running deployments

Component upgrades: EclipseLink 5.0.0-B08 → 5.0.0-B13, OpenMQ updated to 6.8.0, plus bumps to Jackson BOM, Reactor Core, Kotlin Stdlib, and several others.

A lot more to come

The rebrand is just the start. As part of Azul, Payara Community gains access to more resources, more engineering investment and a broader platform to grow.

We have exciting plans - for the runtime, the tooling and connectors available to community users, content, and the events we put on - and we'll be sharing them with you as they take shape.

A huge thank you to everyone who has been part of the Payara community over the years - the contributors, the committers, the developers who have filed issues, submitted fixes, written content and shown up at conferences and JUGs. This project is what it is because of you, and that doesn't change with a new name. We're genuinely excited about what comes next, and we hope you are too!

For now: download the latest release from payara.fish, join us on Foojay, and follow Azul's official social channels for updates.

The post A New Chapter for the Payara Community appeared first on foojay.

Foojay.io, the website for the Friends of OpenJDK, is turning six years old. To celebrate, Frank Delporte headed to JCON in Cologne, Germany, and sat down with twelve members of the Java community to talk about what Foojay means to them, what they learn from each other, and how the community is evolving.

This episode covers a lot of ground. Sharat Chandar reflects on 25 years in the Java community and why the people are what keep the language alive. Markus Westergren and Iryna Dohndorf both focus on a theme that comes up again and again: developer sustainability. Not just green software, but how you stay healthy, grounded, and relevant when AI is changing everything around you. Markus and his wife researched how developers are reacting to AI, from ignoring it completely to transforming everything they do. Iryna talks about building resilience and robustness as skills, not afterthoughts.

René Schwietzke dives deep into JIT compilation and his work on the 1 billion row challenge, writing fast pure Java code without reaching for unsafe methods. Gerrit Grunwald explains the Disco API, the tool behind SDKMAN, Gradle, and more, which tracks every OpenJDK distribution available, including ones you have probably never heard of from Asia. Catherine Edelveis walks through why choosing the right OpenJDK distribution matters and how reducing Docker image sizes improves both security and performance. Jago de Vreede built a JavaFX UI for SDKMAN and talks about what he keeps learning from the community.

Annelore Egger mentors people who think they do not know enough to speak at conferences. Spoiler: they do. Buhake Sindi brings Jakarta EE into the AI agent world with LangChain4J CDI and a talk on agent-to-agent protocols. François Martin just published a fresh Foojay article on flaky tests and shares what writing and mentoring have taught him about open source. Dominika Tasarz-Sochacka, Frank's new Foojay colleague, shares her vision for growing the community and making it even more welcoming. And Geertjan Wielenga, who started Foojay six years ago, joins remotely from under a lighthouse in Ireland to look back and look forward.

Foojay is more than a blog. It is a Mastodon server, a Slack community, the Disco API, a book on sustainability, a podcast, and now an education catalog. Six years in, it is still growing, still community-driven, and still very much a place where anyone who works with Java is welcome.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Content

00:00 Introduction

02:16 Sharat Chandar

• https://www.linkedin.com/in/sharatchander/
• Java community and history
• What you can learn from conferences and articles

05:37 Markus Westergren

• https://www.linkedin.com/in/markuswestergren/
• https://foojay.io/sustainability-for-java-developers/
• https://foojay.io/today/join-slack-com-t-foojay-signup/
• Book "Sustainability for Java Developers"
• How to "sustain yourself" in this strange-AI-changing-world
• Everyone in the Java community is approachable and wants to help you

09:46 Iryna Dohndorf

• https://www.linkedin.com/in/iryna-dohndorf/
• https://foojay.io/today/author/iryna-dohndorf/
• Mentoring about sustainability as a developer + groundness + robustness skills
• High performance without crushing your soul

13:59 René Schwietzke

• https://www.linkedin.com/in/reneschwietzke/
• https://foojay.io/today/the-curious-case-of-different-runtimes-with-different-training-data-jit/
• Diving deep into the runtime, JITWatch
• About the broad mix of topics handled on Foojay
• Foojay helps connect the Java community with Mastodon
• Writing the best performing pure, safe Java code for the 1B row challenge

18:28 Gerrit Grunwald

• https://www.linkedin.com/in/gerritgrunwald/
• https://foojay.io/today/author/gerrit-grunwald/
• https://foojay.io/today/disco-api-helping-you-to-find-any-openjdk-distribution/
• https://sdkman.io/
• The Disco API, the source with all the available OpenJDK distributions, is used by SDKMAN, Gradle, and many other tools
• About the many distributions that are available, even ones that are mainly (and only) used in Asia
• About bringing opensource projects to Commonhaus to ensure their future

27:45 Catherine Edelveis

• https://foojay.io/today/author/catherine-edelveis/
• https://www.youtube.com/watch?v=Ytdo8OGEYFI
• https://foojay.io/today/which-java-runtime-should-you-use-in-production-comparing-openjdk-distributions/
• Reducing Docker sizes improves security and performance
• Many distributors provide builds of OpenJDK

31:16 Jago de Vreede

• https://foojay.io/today/author/jago-de-vreede/
• About the Java community and the place of Foojay in it. What is good, what are we missing?
• SDKMAN, creating an UI for it, and using the many OpenJDK distributions

35:05 Annelore Egger

• https://www.linkedin.com/in/anneloredev/
• https://foojay.io/?s=egger
• Java community, conference volunteering, mentoring
• How to become a conference speaker
• Learn by teaching

38:03 Buhake Sindi

• https://www.linkedin.com/in/buhake-sindi/
• https://foojay.io/today/author/buhake-sindi/
• https://github.com/langchain4j/langchain4j-cdi
• Jakarta EE, LangChain4J CDI, Agent to Agent
• Impact of AI on developer life and sustainability
• Get in touch with your "Java Rockstars"!

44:03 François Martin

• https://www.linkedin.com/in/fran%C3%A7oismartin/
• https://foojay.io/today/author/francois-martin/
• https://foojay.io/today/eliminating-flaky-tests-to-end-world-hunger/
• https://foojay.io/today/five-ways-to-use-gradle-enterprise-to-identify-and-manage-flaky-tests/
• Learn from mentoring, for example, how to earn from opensource
• Foojay author, just published an article about Flaky tests
• Learn from writing and reading

48:18 Dominika Tasarz-Sochacka

• https://www.linkedin.com/in/dominikatasarz/
• https://foojay.io/today/author/dominika-tasarz/
• https://foojay.io/today/join-slack-com-t-foojay-signup/
• https://foojay.io/today/how-to-submit-your-next-article-on-foojay-io/
• The future of Foojay, how can we get the community even more involved
• What you can learn from the community

51:18 Geertjan Wielenga

• https://www.linkedin.com/in/geertjanwielenga/
• https://education.foojay.social/
• Java communities are everywhere
• How Foojay started and grew
• How can contributing to the community influence your career
• Can Foojay connect to universities and other educational initiatives

58:15 Conclusion

The post Foojay Podcast #94: More Than a Blog: How Foojay Connects, Sustains, and Evolves the Java Community appeared first on foojay.

Azul recently announced that Azul Zulu Builds of OpenJDK are now available as Docker Official images on Docker Hub. That means you can pull TCK‑verified, fully compliant OpenJDK builds directly from the same Official Images library you already trust for your base OS and databases.

You can browse and pull the images here:
https://hub.docker.com/_/azul-zulu

Why should you care about official images?

With the official Docker images you get:

• Verified cryptographic signing using Azul’s GPG key, so you can validate what your CI pulls.
• Automatic rebuilds whenever upstream base images are patched, so CVEs are addressed without you manually rebuilding everything.
• Fully open‑source licensing (GPL v2 with Classpath Exception plus relevant OpenJDK licenses).
• Images built and maintained to Docker’s security and maintenance standards, rather than ad‑hoc community images.

This is especially useful if you are:

• Standardizing Java base images across multiple services.

• Locking down a software supply chain (SBOMs, signing, provenance).

• Reducing the noise from ad‑hoc “java:latest” images in different teams.

Which versions and variants can you use?

The Azul Zulu Official Images cover multiple Java releases, including the key LTS versions many teams already rely on:

• Java 8
• Java 11
• Java 17
• Java 21
• Java 25

Each version comes with:

• -jdk, -jre, and -headless variants per major version.
• -debian and -debian13 suffix tags so you can pin the base image.

Example tags include:

• azul-zulu:17-jdk-debian
• azul-zulu:21-jre-headless-debian13

This is just the start - more tags and base images are planned. As new Java releases and additional base images are introduced, they are expected to show up under the same Official Images namespace so you can keep a consistent pattern across services.

Where to start?

Getting the images into your workflow should be straightforward if you already use Docker for Java.

Basic steps:

1. Go to the Official Images page: https://hub.docker.com/_/azul-zulu.

2. Pick the Java version and variant that matches your service (e.g. 17-jdk-debian13).

3. Pull it locally:

docker pull azul-zulu:17-jdk-debian13

4. Use it in your Dockerfile:

FROM azul-zulu:17-jdk-debian13

WORKDIR /app
COPY target/app.jar app.jar
CMD ["java", "-jar", "app.jar"]

5. Wire it into your CI/CD templates so all new services share the same trusted base.

For more details, Dockerfiles and tag information, check the GitHub repo.

What’s next and how to stay involved?

This is just the beginning, here's what's coming next:

• Additional Java releases (including future STS and LTS versions) under the same Official Images namespace.

• More base images over time, so you can choose the footprint and OS family that fits your stack.

• Continued automatic rebuilds and security updates to keep your containers current with minimal noise.

Azul Zulu OpenJDK Official Images are designed to make running Java in containers as straightforward and trustworthy as possible. By standardizing on these images, you get a consistent, signed and actively maintained base that fits naturally into modern CI/CD workflows.

Download from Docker Hub

The post Official Azul Zulu OpenJDK Images Now Available on Docker Hub! appeared first on foojay.

Last week, Eclipse Foundation and Payara hosted Jakarta Agentic AI, An Open Conversation, an open house Jakarta TechTalk session, exploring a brand new initiative under the Eclipse Foundation. If you could not join us live, the full recording is now available.

What is Jakarta Agentic AI?

Jakarta Agentic AI is an exploratory project looking at how AI agents could be built, deployed and run within Jakarta EE runtimes. As AI systems increasingly move from simple inference to autonomous, agent-based behaviour, the question becomes how these systems fit into enterprise Java environments that value reliability, security, and portability.

Find Jakarta Agentic AI on GitHub

What we discussed in the session

During the conversation, panel members actively involved in the project – Reza Rahman (Jakarta EE Ambassadors, Payara), Tanja Obradovic (Eclipse Foundation), Mike Redlich (Garden State JUG, InfoQ), Luis Neto (Payara) & Dominika Tasarz (Payara) – covered topics including:

• What agentic AI means in the context of enterprise Java
• Why Jakarta EE is a strong foundation for experimenting with agent-based systems
• The early goals and design principles guiding the project
• How openness, flexibility and community input are being prioritised from day one
• Where feedback and contributions are most valuable right now
• The discussion reflects a project at a very early stage, focused on learning, collaboration and shared exploration rather than predefined outcomes.

Why this matters for the Jakarta ecosystem

Jakarta EE has long provided a stable, open platform for enterprise Java applications. As AI-driven systems become more autonomous and more integrated into business workflows, it is important that Jakarta remains an active participant in that evolution.

Jakarta Agentic AI is one way the community can explore how emerging AI patterns align with existing enterprise concerns such as:

• Portability across runtimes and vendors
• Security, governance and observability
• Integration with existing Jakarta EE applications and architectures

Watch the recording and get involved

If you are interested in the future of Jakarta EE, enterprise Java or agent-based AI systems, the recording is a great place to start. You will hear directly from the people shaping the project and get a clear sense of where input from the community can make a real difference.

This initiative is open, early and very much a work in progress. Your questions, ideas and concerns are not just welcome, they are essential!

• See the slide deck here.
• Find out more about the project.

The post Shaping Jakarta Agentic AI Together – Watch the Open Conversation appeared first on foojay.

In this short, practical talk DIY Technical Marketing, Real World Tips For Building A Successful Developer Brand, delivered at Jfokus 2026 conference, Payara Community Manager Dominika Tasarz-Sochacka explores why personal branding matters for developers and how even small, intentional actions can make a real difference over time.

Drawing on real world examples from years of working with Java developers, the session focuses on three core ideas:

• understanding the value of personal branding in the tech industry
• identifying what makes you unique and how to communicate it clearly
• taking simple first steps to build visibility without turning it into a full time job

This talk is designed to be approachable and realistic, especially for developers who want to focus on building great software while still investing in their long term career growth.

The post Watch the Recording: DIY Technical Marketing for Java Developers appeared first on foojay.

Enterprise Java has matured into one of the most stable and widely adopted ecosystems in software development. Yet for many teams, the biggest challenges no longer come from the language itself, but from the complexity of the environments built around it.

Modern enterprise Java teams are dealing with a mix of legacy Java EE applications, Jakarta EE runtimes, microservices, container platforms, cloud-native deployments, and increasingly sophisticated DevOps pipelines. The result is an ecosystem that is powerful, but often fragmented across frameworks, runtimes, tooling, and operational models.

To understand how organizations are navigating these challenges, at Payara we surveyed enterprise Java practitioners and analyzed the results in the State of Contemporary Enterprise Java Report (download here). The findings highlight a clear pattern: while Java remains a core enterprise technology, fragmentation across platforms and workflows is becoming a key bottleneck for productivity, reliability and scalability.

Where fragmentation shows up

In real-world enterprise environments, fragmentation typically emerges across several layers:

• runtime platforms and application servers

• frameworks and libraries across teams and projects

• deployment models (VMs, containers, Kubernetes, hybrid cloud)

• configuration and environment management

• observability, logging, and monitoring stacks

• CI/CD pipelines and operational automation

Even when individual components are best-in-class, integration overhead and operational inconsistency increase cognitive load for developers and platform teams.

Why platform architecture matters

Platform choices directly influence how teams manage complexity. A well-designed enterprise Java platform can:

• standardize runtime behavior across environments

• reduce custom scripting and glue code

• simplify deployment models across cloud and on-premise

• improve developer experience through consistent tooling

• align application architecture with modern DevOps practices

The report shows growing interest in platforms that provide cohesive runtime, automation, and operational consistency, rather than isolated tools.

Join our webinar: Insights on Enterprise Java, Trends, Challenges and Strategies

On Wednesday, Feb 11, 2026 at 2:30 PM GMT, register here , Payara experts will present a technical breakdown of the report findings in the live session Insights on Enterprise Java: Current Trends, Challenges and Strategies.

The webinar will cover:

• how teams are modernizing Java EE and Jakarta EE applications

• architectural patterns emerging in enterprise Java deployments

• Kubernetes adoption and its impact on Java workloads

• DevOps maturity across enterprise Java teams

• common failure points and scalability constraints

• practical strategies for reducing fragmentation

We will also connect survey data to middleware architecture, showing how platform design decisions affect deployment, performance, operability, and developer productivity.

Explore the data

The State of Contemporary Enterprise Java Report provides detailed survey data, technical insights, and analysis of enterprise Java trends across industries. If you are responsible for designing, building, or operating Java systems at scale, the report offers a data-driven perspective on where teams are succeeding, where they struggle, and what architectural choices matter most.

Register for the webinar to explore the findings with Payara engineers, and dive into the report to benchmark your own enterprise Java stack against current industry patterns.

The post Enterprise Java in Practice: Fragmentation, Platforms and Real-World Trade-offs appeared first on foojay.

As we begin 2026, we’re pleased to announce new releases across all Payara Platform editions this January: Payara Platform Community 7.2026.1, Payara Platform Enterprise 6.34.0 and 5.83.0. These releases deliver important security fixes, address deployment and administration issues as well as refreshing multiple component versions across the platform.

Security Priority

This month’s releases address two security vulnerabilities. First, we’ve resolved CVE-2020-5258, a cross-site scripting vulnerability in the dojo.js library (versions 6.0.2 and earlier). This fix applies to Payara Platform Community 7.2026.1 and Payara Platform Enterprise 6.34.0, with dojo.js now upgraded to version 6.0.3.

Second, and more critically, we’ve closed a vulnerability that could allow admin account takeover through malicious URL payloads. This issue affected all editions and has been resolved across Payara Platform Community 7.2026.1, Payara Platform Enterprise 6.34.0 and Payara Platform Enterprise 5.83.0. We strongly recommend upgrading promptly if your Payara instances are exposed to untrusted networks.

Payara Platform Community Edition 7.2026.1

The Payara Platform Community edition continues to lead with full Jakarta EE 11 and MicroProfile 6.1 support, keeping you current with the latest enterprise Java specifications.

This release tackles several deployment pain points. If you’ve encountered EJB deployment failures on JDK 24, that’s now resolved. We also fixed a class loader leak that occurred when EJB deployments failed, preventing memory from being properly released. Another EJB-related fix resolves duplicate class definition errors for GenericEJBHome_Generated_DynamicStub during redeployment, a problem that could cause unexpected behavior in long-running applications.

On the component front, we’ve upgraded numerous dependencies. Parsson moves to 1.1.7, the CORBA implementation reaches version 5.0.0, and we’ve brought in gmbal 4.1.0 and PFL 5.1.0. Reactive users will appreciate reactor-core 3.8.1, and Kotlin developers get version 2.3.0 of kotlin-stdlib. Other notable updates include commons-io 2.21.0, ASM 9.9.1, angus-activation 2.0.3, and nimbus-jose-jwt 10.6.

Payara Platform Enterprise Edition 6.34.0

Payara Platform Enterprise 6.34.0 maintains Jakarta EE 10 and MicroProfile 6.1 compatibility while incorporating this month’s security fixes and addressing several administration issues.

If you’ve experienced HTTP 500 errors when sorting columns by keystore or truststore alias names in the admin console, that’s now fixed. The EJB redeployment issue affecting Community users has also been addressed here. Component upgrades in this release include Parsson 1.1.7 and gmbal 4.1.0, keeping the Enterprise 6 line current with upstream dependency improvements.

The Payara Upgrade Tool

Cluster operators will welcome a new addition to the Payara Upgrade Tool: the –nodes flag. This option enables selective node upgrades when you need finer control over rolling upgrades. Instead of upgrading every node in your cluster simultaneously, you can now specify a comma-separated list of node names to upgrade incrementally. The same capability extends to rollbacks, letting you revert individual nodes if an upgrade encounters issues. This supports safer, more controlled upgrade patterns for production clusters where you want to validate each node before proceeding to the next.

Payara Platform Enterprise Edition 5.83.0

For organizations still running Jakarta EE 8 workloads, Payara Platform Enterprise 5.83.0 maintains our commitment to long-term stability, with MicroProfile 4.1 support. This release includes the critical admin account takeover security fix and resolves the keystore/truststore sorting issue that was causing internal server errors in the administration interface. The Jackson BOM has been updated from 2.20.0 to 2.20.1 as well.

Release Notes

• Payara Platform Community 7.2026.1
• Payara Platform Enterprise 6.34.0
• Payara Platform Enterprise 5.83.0

Not using Payara Platform yet? Download Payara Platform Community or request a free trial of Payara Platform Enterprise to experience these improvements in your development and production environments.

We value your feedback and contributions to the Payara Platform. Report issues or share your experiences on our GitHub repository.

Happy deployments!

The post What’s New in the January 2026 Payara Platform Release? appeared first on foojay.

Download the free eBook here (no form fill necessary).

The eBook focuses on Jakarta EE as the foundation for scalable enterprise Java, showing how it continues to evolve to meet today’s cloud requirements. It walks through running Jakarta EE in the cloud with Payara Micro, simplifying development workflows, and aligning enterprise Java with container-based and Kubernetes-friendly architectures.

A key part of the guide is its practical exploration of NoSQL in cloud environments. Using Jakarta NoSQL and Oracle NoSQL, the book demonstrates how developers can work with flexible data models while maintaining consistency, portability, and productivity. Real code examples help bridge the gap between theory and real-world application development.

This eBook offers clear guidance, practical insights, and proven approaches from industry experts. Scalable Enterprise Java for the Cloud is available now as a free download, and we invite you to explore it, share it, and join the ongoing conversation around the future of enterprise Java.

The post Scalable Enterprise Java for the Cloud appeared first on foojay.

Working with enterprise Java databases can sometimes feel like swimming upstream. Jakarta EE 11’s Jakarta Data helps developers glide through data operations effortlessly, cutting complexity and keeping projects flowing smoothly.

In this blog post, we look at what Jakarta Data brings to the table and how it can transform everyday Java development tasks.

Jakarta EE is evolving, and one of the most talked-about additions in the latest release (Jakarta EE 11) is Jakarta Data, a framework designed to simplify how developers interact with databases. By reducing boilerplate and offering a more intuitive approach, Jakarta Data promises to make enterprise Java development cleaner, faster and more maintainable.

The Problem: Data Access in Enterprise Java

Traditionally, data access required a lot of boilerplate code, complex design patterns and careful maintenance. Historically, enterprise Java developers have been on the hook for setting up numerous classes just to talk to a database. CRUD operations required the Data Access Object (DAO) pattern, with multiple classes, plus JPA Criteria API scripting for complex queries.

This extra work meant hundreds of lines of boilerplate and maintenance headaches.​Even more, this combination can introduce latency, bugs and scalability issues. Jakarta Data addresses this head-on.

Annotation-Driven Persistence with Jakarta Data

At its core, Jakarta Data simplifies database operations by standardizing repository patterns. Instead of navigating multiple layers and classes, developers now only need to define a single interface.

Jakarta Data solves this with a clean, single-interface approach built atop Jakarta CDI. Developers define their repositories using new annotations, and Jakarta Data handles the heavy lifting at runtime. The result is:

• Dramatically reduced boilerplate
• Enhanced code clarity and maintainability
• Flexible, efficient generation and implementation of CRUD repositories
• A special highlight: Jakarta Data introduces its own, purpose-built query language, JDQL (Jakarta Data Query Language), as well as native support for pagination, features previously requiring custom logic or verbose JPA scripting.

By introducing a unified repository abstraction using familiar annotations, Jakarta Data standardizes and streamlines how developers write code for data operations. Jakarta Data is particularly effective for applications with one-to-one table relationships, which covers a large portion of enterprise workloads, but also supports advanced scenarios, such as many-to-many relationships, multi-database interactions, or complex entity mappings, may require additional configuration.

How Payara Implemented Jakarta Data

At Payara, we took a modular, independent approach to implementing Jakarta Data, ensuring our solution was fully compatible with Jakarta EE 11. The team modularized requirements and maintained close collaboration to ensure rapid, robust support. This approach enabled Payara Platform Community 7 Beta to achieve fast Jakarta EE 11 certification.​ In effect, Payara is the first vendor to be compliant across all three Jakarta EE 11 profiles: Core, Platform and Web.

Payara’s implementation doesn’t stop with baseline Jakarta Data support. The team is actively working on enhancements, including merging of JDQL interpretation and query name creation parsers, promising even more efficient, developer-friendly experiences in upcoming releases.

Where Does This Leave Enterprise Java Developers?

Jakarta Data marks a key shift in enterprise Java. With Jakarta EE 11 and Payara Platform Community 7 Beta, building robust, modern, data-driven applications just got dramatically easier.

Ready to go deeper? Download Payara Platform Community 7 to explore, contribute feedback and take full advantage of Jakarta Data for your projects.

The post Jakarta Data Makes Persistence a Breeze appeared first on foojay.

If you’ve been living in the Spring ecosystem, you’re used to fast project setup. Spring Initializr gives you a sleek interface, some starter dependencies and a running project within minutes. Now you’re moving to Jakarta EE, where do you begin? 

In this blog, you’ll see how Spring developers can create Jakarta EE applications with the same ease they’re used to from Spring Initializr. 

Let’s be honest: Spring Boot abstracts away so much of the setup pain that you forget it’s even there. You don’t worry about the underlying servlet container, dependency versions or deployment descriptors, as Spring Boot handles it all. 

If you’ve spent most of your career building microservices and APIs with Spring Boot, you’ve probably grown accustomed to a certain rhythm to ship features quickly: 

1. Spring init your project by visiting https://start.spring.io. 

2. Pull in all the dependencies you need for an application and get most of the setup automatically sorted

3. Choose either Gradle or Maven, the language you want to use and which version (here, we assume Java, along with its version) as well as the Spring Boot version you want to use

4. Add Dependencies

5. Click Generate

6. Download the resulting ZIP file, which is an archive of a web application (as .war/.jar file) that is configured with your choices.

Starting with Jakarta EE Doesn’t Have to be Slow  

Now, even though you are a Spring aficionado, for a number of reasons you may be tasked with developing a Jakarta EE application. Maybe it’s because the company landed a project where the framework was specified. Maybe it’s time to modernize any existing Java EE workloads, and the transition to the Jakarta EE namespace was identified as the most suitable option. Maybe you just want to see what’s out there beside Spring and expand your skillset, especially with the release of Jakarta EE 11.

In any case, while Spring and Jakarta EE share some commonalities as enterprise Java frameworks, if you’ve never touched Jakarta EE, you may feel out of your depth. You might think Jakarta EE is heavyweight, XML-heavy and bound to large application servers. But the good news is the platform has evolved. Modern runtimes like Payara Micro run lean, start fast and work beautifully with container deployments. 

And the even better news? The latest Payara Starter, a free online developer tool to generate entity relationship diagrams and code, makes scafollding a Jakarta EE project as easy — dare I say, easier than creating a Spring Boot project with Spring Initializr.

Meet Payara Starter: The Equivalent to Spring Initializr for Jakarta EE

Payara Starter is a free, web-based project generator that offers a web-based UI that walks developers through scafollding a Jakarta EE application step by step. Think of it as Jakarta EE’s version of Spring Initializr. In effect, it is a tool that gives you a ready-to-run project with all the right dependencies, packaging and configuration for Payara Platform.  

The latest version of Payara Starter has three major features that make it a game-changer: 

1. Full Jakarta EE 11 support to develop future-oriented applications that leverage the latest specifications and technologies.
2. A Jakarta Faces generator so you can scaffold JSF projects without touching obscure XML configs
3. An AI-powered ER diagram generator and ready-made code templates to shave hours from initial scaffolding, so the app is up and running almost instantly, even with complex data relationships. Note: expert oversight is essential when handling Gen AI tools. For these reasons, the AI functionalities within Payara Starter are best suited for testing and development environments, where they can help accelerate initial setup and design without the risks associated with production use. In any case, the generated ER Diagram and source code should be reviewed carefully, as they may contain errors. 

Payara Starter vs. Spring Initializr: Same Comfort, Different Stack

Think of Payara Starter as a mirror image of the experience you’ve enjoyed in Spring Initializr. Both tools: 

1. Generate a complete starter project from a browser form
2. Allow you to pick dependencies and packaging types 
3. Provide a build-ready ZIP you can import into your IDE 

Payara Starter and Spring Initializr Side by Side

Step-by-Step: Starting a Jakarta EE 11 App with Payara Starter

1. Go to the Payara Starter webpage at https://start.payara.fish/ 
2. Select Maven or Gradle 
3. Select Jakarta EE 11 as the platform version and the profile (Platform, Web or Core)
4. Choose your runtime:
   • Payara Server (traditional)
   • Payara Micro (lightweight, perfect for microservices)
5. Pick the Java version you need 
6. Pick the MicroProfile specification you need, which will help you build cloud-native, resilient microservices with Jakarta EE
7. Choose you deployment option – if you want an intuitive, fully managed PaaS, opt for Payara Cloud 
8. Search for an Entity Relationship Diagram (ERD) as the backbone of your application
   (Optional) Open the AI-enriched Diagram Builder & Live Preview to adjust the structure based on your needs 
9. Download your generated project as .war file 

Wrapping Up: Familiar Simplicity, Different Framework 

Switching frameworks can feel like switching languages. Payara Starter gives you something steady to hold while you explore Jakarta EE. If you’ve built dozens of Spring Boot apps with Spring Initializr, you’ll feel right at home, only now you’re targeting a modern Jakarta EE runtime. 

Ultimately, by using Payara Starter you can spend less time on boilerplate and more time solving real problems, so the next time someone says, “We need Jakarta EE 11”, you won’t panic. You’ll just fire up Payara Starter, click a few options and get a quick proof of concept.

The post From Spring Boot To Jakarta EE 11: How Payara Starter Eases The Transition appeared first on foojay.