Jakarta EE

Stop Overthinking Jakarta EE Setup. Just Use This.

Tired of complex Jakarta EE project setups? Stop overthinking! This guide reveals the one simple tool you need to generate a runnable project in minutes.

Daniel Costa

A pragmatic Java Champion and enterprise architect passionate about simplifying developer workflows.

September 16, 20257 min read20 views

Let’s be honest. How many times have you wanted to spin up a quick Jakarta EE project, only to be stopped dead in your tracks by the thought of the setup? The ghosts of monolithic XML files, confusing dependency versions, and manual server configurations still haunt many of us. You start thinking, "Which Maven coordinates do I need for Jakarta REST? Wait, do I need an implementation too? Which one? What version is compatible with WildFly 32 vs. Open Liberty?"

Before you know it, you've fallen into a rabbit hole of research and analysis paralysis. Your brilliant idea for a new microservice is forgotten, and you close your IDE in frustration.

It’s time to stop. The year is 2025, and setting up a Jakarta EE project is no longer a Herculean task. In fact, it’s ridiculously simple. You just need to use the right tool.

The Paradigm Shift: Generate, Don't Fabricate

For years, the Java enterprise world watched with a bit of envy as frameworks like Spring Boot, with its brilliant Initializr, made starting new projects a complete joy. The philosophy was simple: answer a few questions about what you need, and get a runnable, best-practice project in seconds.

That philosophy is now a first-class citizen in the Jakarta EE ecosystem. The days of manually crafting your pom.xml from scratch for a standard web application are over. Unless you have a very specific, bespoke need, you should not be doing it. Your time is valuable. Spend it writing business logic, not boilerplate.

The modern developer mindset: My job is to solve business problems with code, not to be an expert in build-system esoterica.

Meet Your New Best Friend: The Jakarta EE Starter

So, what is this magic tool? It's the official Jakarta EE Starter. It’s a clean, simple web application that does one thing and does it perfectly: it generates a complete, ready-to-run Jakarta EE project based on your needs.

Let's walk through how to use it. It’ll take less time than it took you to read this far.

Step 1: Define Your Project Metadata

When you land on start.jakarta.ee, the first thing you'll see are fields for your project's Maven coordinates. This is standard stuff:

Group ID: Usually your reversed domain name, e.g., com.mycompany.app.
Artifact ID: The name of your project, e.g., user-service.
Project Version: Defaults to 1.0.0-SNAPSHOT, which is perfect for initial development.

Fill these in. It's the hardest part, I promise.

Step 2: Choose Your Jakarta EE Version

Next, you’ll select the Jakarta EE version. You'll typically see options like Jakarta EE 11, 10, or 9.1. Which should you choose?

Jakarta EE 11: The latest and greatest. Use this for new, greenfield projects to take advantage of the newest features and improvements.
Jakarta EE 10: A very stable and widely adopted version. It's an excellent, safe choice if your target deployment environment isn't on the absolute cutting edge yet.

For a new project today, Jakarta EE 11 is a fantastic choice.

Step 3: Select a Runtime

This is a game-changer. Instead of just getting a bag of dependencies and being told, "Good luck deploying it," the starter lets you choose a compatible runtime. You'll see options like WildFly, Open Liberty, GlassFish, and Payara.

When you select one, the generated project will include the necessary Maven/Gradle plugin to download, configure, and run that server for you. This means you can run your application with a single command (e.g., mvn wildfly:run) without ever manually downloading a server zip file.

Step 4: Pick Your Specifications

Here’s the real magic. Remember trying to find the right dependencies for REST, persistence, and CDI? Forget it. Now, you just check the boxes for the APIs you plan to use.

Need to build a REST API? Check Jakarta RESTful Web Services.
Need to talk to a database? Check Jakarta Persistence and Jakarta Data.
Need dependency injection? Check Jakarta Contexts and Dependency Injection (CDI).

The starter knows which dependencies correspond to these specifications and adds them to your build file correctly. It typically uses the Core Profile, which is a single dependency that brings in all the essential APIs, and then ensures your runtime provides the implementations.

Step 5: Generate and Go!

Click the "Download" button. You’ll get a .zip file. Unzip it, open it in your favorite IDE (like IntelliJ, VS Code, or Eclipse), and you're done. You have a fully configured, runnable project.

What's in the Box? A Look Inside

The generated project isn't just a pom.xml. It's a complete, sensible starting point. Here's what you'll typically find:

my-awesome-app/
├── .dockerignore
├── .gitignore
├── Dockerfile
├── pom.xml
├── README.md
└── src/
    ├── main/
    │   ├── java/com/mycompany/app/HelloResource.java
    │   └── webapp/
    │       ├── index.html
    │       └── WEB-INF/beans.xml
    └── test/
        └── java/com/mycompany/app/HelloResourceTest.java

pom.xml: Perfectly configured with the Jakarta EE dependencies, the runtime plugin (like wildfly-maven-plugin), and best-practice build settings.
HelloResource.java: A sample JAX-RS endpoint so you can run the project and immediately see something working.
Dockerfile: A production-ready Dockerfile to containerize your application. This is a massive head start for a cloud-native workflow.
README.md: Simple instructions on how to build and run your project. No more guessing the right Maven command!

You can literally go from an idea to a running, containerizable REST endpoint in under two minutes.

Alternative Routes: IDEs and Archetypes

While the web-based starter is fantastic, it's not the only way to achieve this simplicity.

IDE Integration

Modern IDEs have this same functionality built-in. IntelliJ IDEA Ultimate, for example, has a brilliant "New Project" wizard for Jakarta EE. It asks you the same questions—project name, version, runtime, and dependencies—and generates an identical project structure. If you live in your IDE, this is an equally valid and fast approach.

The Classic: Maven Archetypes

For those who love the command line or need to automate project creation, Maven Archetypes are still a powerful tool. They are templates for creating projects. Many Jakarta EE runtimes provide their own archetypes.

For example, to create a simple WildFly project, you might run a command like this:

mvn archetype:generate \
    -DarchetypeGroupId=org.wildfly.archetype \
    -DarchetypeArtifactId=wildfly-jakartaee11-webapp-archetype \
    -DarchetypeVersion=...

This is less discoverable than a web UI but is excellent for scripting and repeatable builds.

Conclusion: Code More, Configure Less

The perception of Jakarta EE as a complex, configuration-heavy platform is outdated. The ecosystem has embraced modern developer experience principles, and the tools are here to prove it.

So, the next time you have an idea, don't let the fear of setup stop you. Go to start.jakarta.ee, check a few boxes, and download your project. Run it, see the "Hello, World!" message from your new REST endpoint, and then start building something amazing.

Your time is better spent on creating value, not wrestling with configuration. It's time to get coding.