Skip to content
javahacks.dev
Jakarta EE

Jakarta EE Profiles Core Web and Full Platform Compared

Compare the Core Profile, Web Profile and full Platform of Jakarta EE, see which specifications each includes and choose the smallest one you need.

5 min read
Summarize in AI
Flat illustration of a flame graph with one hot frame, with the OpenJDK, OpenTelemetry, Prometheus and Grafana logos.

Jakarta EE is large, and most applications use a fraction of it. Profiles exist to let you choose a smaller platform than the full set. Three are defined, and the choice affects which server you run and how much it carries. This comparison lists what each includes and gives a verdict. The platform's history is in what Jakarta EE is.

The three profiles

Specification groupCoreWebPlatform
Dependency injection, CDI Liteyesyesyes
CDI Fullnoyesyes
Jakarta RESTyesyesyes
JSON-P, JSON-Byesyesyes
Servlet, WebSocketnoyesyes
Faces, Pagesnoyesyes
Persistence, Transactionsnoyesyes
Bean Validationnoyesyes
Security, Authenticationnoyesyes
Concurrency, Interceptorspartlyyesyes
Messaging (JMS)nonoyes
Enterprise Beans (full)nopartialyes
Mail, Batch, Connectorsnonoyes

The exact membership changes by release, so confirm it on the Jakarta EE profiles page for the version you target. The pattern is stable: Core is the foundation, Web adds web and persistence, Platform adds enterprise integration.

Core Profile

The Core Profile was introduced in Jakarta EE 10 for small, fast services. It has no servlets and no persistence: a REST service with CDI and JSON. Build-time runtimes such as Quarkus and Helidon implement it. If you want a service that starts quickly, this is the target; see why Quarkus starts fast.

Web Profile

The Web Profile is what most business web applications need: servlets, Faces or REST, persistence with transactions, validation and security. It is the sensible default for a WAR deployment. Servers such as WildFly, Payara Micro and Open Liberty support it with smaller footprints than the full platform.

Full Platform

The Platform adds Jakarta Messaging, full Enterprise Beans (remote EJBs, message-driven beans), Batch, Mail, Connectors and others. Choose it when an existing estate depends on them, or when a server's certification matters. For new work most teams use a message broker client directly instead of JMS.

How to choose

  1. List the Jakarta APIs your code imports (jakarta.* packages).
  2. Map each to a profile with the table.
  3. Pick the smallest profile that contains all of them.
  4. For one missing API, add it as a library instead of moving up a profile.

The dependency that declares the target is explicit in a build:

pom.xmlXML
<dependency>
    <groupId>jakarta.platform</groupId>
    <artifactId>jakarta.jakartaee-web-api</artifactId>
    <version>10.0.0</version>
    <scope>provided</scope>
</dependency>

There are matching artifacts for the Core Profile and the full platform. Compiling against the Web API prevents you from using a class that a Web Profile server will not provide. The Core Profile specification and the Web Profile specification list the exact membership.

Which specifications each profile carries

The names are easier to judge against the APIs an application imports. This table lists the common ones for Jakarta EE 10, and the specification page for the version in use is the authority:

SpecificationCoreWebFull
CDI (Lite in Core, full in Web and Full)LiteYesYes
REST (Jakarta RESTful Web Services)YesYesYes
JSON Processing and JSON BindingYesYesYes
ServletNoYesYes
FacesNoYesYes
PersistenceNoYesYes
TransactionsNoYesYes
Bean ValidationNoYesYes
SecurityNoYesYes
WebSocketNoYesYes
BatchNoNoYes
Messaging (JMS)NoNoYes
MailNoNoYes
Enterprise Beans (full)NoLite onlyYes
ConnectorsNoNoYes

The pattern is that Core suits a REST service with no database, Web covers a typical web application with persistence, and Full is for systems that use messaging, batch or the enterprise bean model. A project that imports jakarta.jms or jakarta.batch cannot run on a Web Profile server, whatever else it uses.

Declare the profile you target

The platform publishes one API jar per profile, so the compiler refuses what the profile does not contain. Pick the smallest that compiles:

XML
<dependency>
    <groupId>jakarta.platform</groupId>
    <artifactId>jakarta.jakartaee-web-api</artifactId>
    <version>10.0.0</version>
    <scope>provided</scope>
</dependency>

The Core and Full equivalents are jakarta.jakartaee-core-api and jakarta.jakartaee-api. Scope provided is right, because the server brings the implementation. A project that compiles against the full API and deploys to a Web Profile server fails at runtime with NoClassDefFoundError, so the wrong choice shows up late. Compiling against the Web API moves the failure to build time.

Check what the code really uses

Before moving a project to a smaller profile, list the specification packages that the code imports:

Shell
grep -rhoE 'import jakarta\.[a-z]+' src/main/java | sort | uniq -c | sort -rn

A result that lists only servlet, persistence, inject, validation and ws fits the Web Profile. A line with jms or batch rules it out. Run the same search over the dependencies that bring their own imports, since a library using jakarta.mail pulls in Full requirements by itself, unless it ships its own implementation.

Runtimes and what they certify

RuntimeCertified for
WildFly, GlassFish, Payara Server, Open LibertyFull and Web
TomEE, Payara MicroWeb
Quarkus, HelidonCore pieces, with their own extensions for the rest
Tomcat, JettyA servlet container, not a profile on its own

A servlet container is not a Jakarta EE profile. An application on Tomcat adds its own implementations of CDI, persistence and validation, which is what Spring does. Check which version of the platform a product has been certified for, since the profile names carry a version number and a runtime that supports Jakarta EE 9 may not support 10.

Where MicroProfile fits

MicroProfile adds APIs that Jakarta EE lacks, such as configuration, health checks, metrics and fault tolerance, and it builds on the Core Profile. A service that needs health endpoints and typed configuration on a small runtime is a MicroProfile service, and it runs on Quarkus, Helidon and Open Liberty. If the project depends on both a Jakarta profile and MicroProfile, align the two versions, because each MicroProfile release is based on a specific Jakarta release.

Where profiles do not matter

Spring and Spring Boot choose their own set. They use servlets, persistence and validation as libraries, so the profile does not constrain you. For maintainers of older systems, the profile decides whether an application can move from a full application server to a smaller one; check EJB, JMS and JAX-WS use before you try. See also the Jakarta EE 10 changes.

Share

Keep reading

Get new posts by email

We send one email when a new post is published. No spam.

Unsubscribe in one click. No spam, ever.