Jakarta EE 11 New Features Explained With Practical Impact
What Jakarta EE 11 changes for application developers: the Java baseline, Jakarta Data, virtual thread support, updated specifications and removals.

Jakarta EE 11 is the first release of the platform that treats Java 17 as the floor, a modern persistence-and-data story as a headline feature and virtual threads as a supported way to run managed concurrency. It also quietly retires several pieces of legacy API. If you write enterprise Java on Payara, WildFly, Open Liberty, GlassFish or TomEE, or you depend on Jakarta specifications through Spring or Quarkus, some of this changes your code and some of it only changes what you can expect from the next server upgrade. This post separates the two. It covers the baseline, Jakarta Data with working code, virtual thread support, the updated specifications, what was removed, and a Monday checklist. The release was finalized in 2025 and the details here follow the Jakarta EE 11 release page.
Java baseline
The platform requires Java 17 or later, and supports Java 21 and later as the target for new features. In practice, a certified implementation runs on 17, 21 and 25, and the features that depend on newer language runtime capabilities, such as virtual threads, need 21 or later. If you are on Java 11, this is the release that forces the upgrade. The path through the language changes is in the modern Java guide.
Two cleanups followed from the new baseline. The platform no longer builds on the Security Manager, which Java deprecated for removal, so the permission-based references in the specifications were removed. And specification APIs can use records and sealed types in their own surface, where earlier ones were limited to what Java 8 offered.
The namespace did not change. If you already moved from javax to jakarta for Jakarta EE 9 or 10, imports stay as they are. The previous release and what it introduced are in Jakarta EE 10 new features.
Jakarta Data
Jakarta Data 1.0 is the largest new specification. It defines repository interfaces that the runtime implements for you, so a data-access class becomes an interface with annotated methods. If you have used Spring Data, the shape is familiar, with one important difference: the annotations say what a method does, and method names are not parsed into queries.
package dev.javahacks.shop;
import jakarta.data.repository.CrudRepository;
import jakarta.data.repository.Find;
import jakarta.data.repository.Query;
import jakarta.data.repository.Repository;
import jakarta.data.page.Page;
import jakarta.data.page.PageRequest;
import java.util.List;
@Repository
public interface Products extends CrudRepository<Product, Long> {
@Find
List<Product> byCategory(String category);
@Find
Page<Product> byCategory(String category, PageRequest page);
@Query("where price < :limit order by price")
List<Product> cheaperThan(java.math.BigDecimal limit);
}Inject it like any CDI bean:
@ApplicationScoped
public class CatalogService {
@Inject
Products products;
@Transactional
public Page<Product> browse(String category, int pageNumber) {
return products.byCategory(category, PageRequest.ofPage(pageNumber).size(20));
}
}@Find matches method parameters to entity attributes by name, @Query takes Jakarta Data Query Language (a subset of the persistence query language), and PageRequest with Page gives offset pagination in the API itself. There are also @Insert, @Update, @Delete and @Save for lifecycle methods, and Sort and Order parameters. The repository can sit on Jakarta Persistence entities, and a provider can also support other stores such as NoSQL databases. Hibernate ships a Jakarta Data implementation, and the specification text is at jakarta.ee/specifications/data.
Know what it does not do: a provider's repository is only as good as the query it generates, so look at the SQL, as you would for any ORM. Features beyond the spec (derived query keywords, projections in some providers) are vendor extensions and tie you to that vendor.
Virtual threads in Concurrency
Jakarta Concurrency 3.1 adds virtual thread support to the managed executors. A managed executor definition can ask for virtual threads, so tasks submitted to it run on cheap threads that park instead of blocking an operating system thread:
@ManagedExecutorDefinition(
name = "java:app/concurrent/ioExecutor",
virtual = true)
@ApplicationScoped
public class ExecutorConfig { }@Resource(lookup = "java:app/concurrent/ioExecutor")
ManagedExecutorService ioExecutor;
public CompletableFuture<String> fetch(String url) {
return ioExecutor.supplyAsync(() -> httpClient.get(url));
}The attribute virtual = true is the whole switch. The container still propagates the security and transaction context you configure, which is the reason to use the managed executor and not Executors.newVirtualThreadPerTaskExecutor() directly inside a Jakarta server. Requires Java 21 or later. Two cautions apply, as with virtual threads anywhere: they help I/O-bound waiting and do nothing for CPU-bound work, and code that holds a monitor (a synchronized block) while blocking can pin the carrier thread on older runtimes.
Updated specifications
Most other specifications moved forward with smaller, concrete changes.
| Specification | Version | What it means for you |
|---|---|---|
| Persistence | 3.2 | Records as embeddables, java.time.Instant and Year support, findMultiple and new query language functions |
| Servlet | 6.1 | Clarifications, new HttpServletRequest methods, removal of Security Manager references |
| Faces | 4.1 | Cleanup, UIData and Part improvements, removal of deprecated API |
| CDI | 4.1 | Core clarified, Bean Validation interplay and removal of deprecated features |
| Validation | 3.1 | Support for records as constraint targets |
| Security | 4.0 | Alignment with the new baseline and the removal of Security Manager references |
| Concurrency | 3.1 | Virtual threads, as above |
| Data | 1.0 | New: repositories |
The persistence change that most code will notice is records. An @Embeddable can now be a Java record, which fits the value-object style:
@Embeddable
public record Address(String street, String city, String postalCode) { }
@Entity
public class Customer {
@Id Long id;
Address billing;
}If you have been mapping this with a mutable class and getters, you can shrink it, subject to what your provider supports at the version you run. For the mapping decisions around such types, see the Hibernate and JPA guide.
Removals
Platform releases remove things that were deprecated for several versions. Jakarta EE 11 removes the Jakarta Managed Beans specification from the platform. A class annotated with @ManagedBean stops being a bean on a strict Jakarta EE 11 runtime and should be a CDI bean instead (@Named plus a scope). The same consolidation is why mixing bean models in JSF is discouraged, as laid out in JSF managed beans vs CDI beans. Other removed or optional pieces include a number of long-deprecated APIs in Servlet and Faces, and several profiles' references to the Security Manager. Check each server's compatibility notes, because the Web Profile, Core Profile and Platform each carry a different set.
The practical test is a recompile. Search your sources for javax.annotation.ManagedBean, jakarta.annotation.ManagedBean, @ManagedBean on JSF beans and calls to methods the Javadoc marks as removed, then let the compiler tell you the rest.
What to do on Monday
- Confirm your target server supports Jakarta EE 11 and which profile. Compatible implementations are listed on the release page.
- Move the build to Java 21 or 25 and the runtime to the same, so everything on the page above is available.
- Replace
@ManagedBeanwith CDI beans, and recompile against the 11 APIs to find removed methods. - Pick one repository class that is mostly CRUD and try rewriting it as a Jakarta Data repository behind a feature branch, then compare the generated SQL.
- If a service waits on remote calls, trial a virtual-thread managed executor and measure with the load you actually see.
- Keep dependencies on the specification APIs at
providedscope so the server's version wins.
This is an upgrade of the platform, not a rewrite. Apps that moved to Jakarta EE 10 usually need an afternoon of recompilation rather than a project, while apps still on javax have the bigger step first, described in what replaced Java EE.
Where this does not apply
If you run Spring Boot, you consume parts of Jakarta EE (servlet, validation, persistence) but not the platform as a whole. Boot 4 aligns with the Jakarta EE 11 baseline for those pieces, and Jakarta Data is not part of Spring's programming model; Spring Data fills that role. If your servers are pinned to a vendor release that has not yet certified Jakarta EE 11, you cannot use these features, no matter what the specification says. And a monolith that works on Java EE 8 under a supported contract does not need this release; the cost is in the namespace change that comes first.


