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.

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 group | Core | Web | Platform |
|---|---|---|---|
| Dependency injection, CDI Lite | yes | yes | yes |
| CDI Full | no | yes | yes |
| Jakarta REST | yes | yes | yes |
| JSON-P, JSON-B | yes | yes | yes |
| Servlet, WebSocket | no | yes | yes |
| Faces, Pages | no | yes | yes |
| Persistence, Transactions | no | yes | yes |
| Bean Validation | no | yes | yes |
| Security, Authentication | no | yes | yes |
| Concurrency, Interceptors | partly | yes | yes |
| Messaging (JMS) | no | no | yes |
| Enterprise Beans (full) | no | partial | yes |
| Mail, Batch, Connectors | no | no | yes |
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
- List the Jakarta APIs your code imports (
jakarta.*packages). - Map each to a profile with the table.
- Pick the smallest profile that contains all of them.
- 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:
<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:
| Specification | Core | Web | Full |
|---|---|---|---|
| CDI (Lite in Core, full in Web and Full) | Lite | Yes | Yes |
| REST (Jakarta RESTful Web Services) | Yes | Yes | Yes |
| JSON Processing and JSON Binding | Yes | Yes | Yes |
| Servlet | No | Yes | Yes |
| Faces | No | Yes | Yes |
| Persistence | No | Yes | Yes |
| Transactions | No | Yes | Yes |
| Bean Validation | No | Yes | Yes |
| Security | No | Yes | Yes |
| WebSocket | No | Yes | Yes |
| Batch | No | No | Yes |
| Messaging (JMS) | No | No | Yes |
| No | No | Yes | |
| Enterprise Beans (full) | No | Lite only | Yes |
| Connectors | No | No | Yes |
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:
<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:
grep -rhoE 'import jakarta\.[a-z]+' src/main/java | sort | uniq -c | sort -rnA 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
| Runtime | Certified for |
|---|---|
| WildFly, GlassFish, Payara Server, Open Liberty | Full and Web |
| TomEE, Payara Micro | Web |
| Quarkus, Helidon | Core pieces, with their own extensions for the rest |
| Tomcat, Jetty | A 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.


