Over the past months I’ve been publishing a steady stream of hands-on tutorials on The Main Thread, my Substack dedicated to Quarkus, Java, and AI. Many of you asked me where to begin and what’s the right order if you’re new to Quarkus and want to build a solid foundation.
This post is my answer. It’s a curated learning journey, weaving together the essential tutorials that will take you from first REST endpoint to a confident Quarkus developer.
If you enjoy this path and want to stay up to date with new tutorials, deep dives, and practical examples, subscribe to The Main Thread and join thousands of developers building modern Java together.
Step 1: Start With REST APIs
Almost every modern Java service exposes REST endpoints. It’s the easiest way to feel Quarkus in action: instant hot reloads, tiny footprint, and code that looks familiar yet runs much faster.
In Getting Started with Quarkus REST API, you’ll walk through your first service. Nothing fancy, just enough to prove how quick it is to get something working.
But real applications don’t live in an English-only world. If your APIs handle names, messages, or data in multiple languages, you’ll need to deal with encodings. The Unicode REST API tutorial shows you how Quarkus helps avoid subtle text handling bugs. This step matters because internationalization isn’t a “later problem”. It’s a reality for almost every enterprise app.
Step 2: Master the CLI
When you first try Quarkus, you might be tempted to stick with Maven or Gradle only. But the Quarkus CLI saves hours of fiddling and makes exploration frictionless. One command can scaffold a new project, add extensions, or start dev mode.
In Building Quarkus Apps with the CLI, you’ll see how to go from zero to working code in seconds. The CLI Guide dives deeper, showing how to add persistence, messaging, or observability with a single line.
And because every beginner runs into roadblocks, Quarkus for Beginners: Top Questions Answered gives you a map of the pitfalls most developers face. You’ll recognize your own questions in there.
The CLI isn’t just a nice-to-have tool. It sets the tone: Quarkus values speed, experimentation, and developer joy.
Step 3: Understand Dependency Injection
Once you’ve built your first endpoints, you’ll want to organize your code. That’s where Dependency Injection (DI) comes in. Quarkus uses Jakarta CDI lite, which might look different if you’re used to Spring annotations.
CDI Basics in Quarkus introduces @Inject and scopes. It’s a small step, but it transforms how you wire services together. Then Working with CDI Events shows how to decouple components with event-driven patterns. This makes applications easier to evolve without ripple effects.
Finally, Multiple Implementations with Qualifiers tackles a real-world issue: what happens when you have more than one implementation of the same interface? This is where qualifiers keep your wiring precise and predictable.
Developers should care about this step because CDI isn’t just about syntax. It’s about writing code that can grow with your team and requirements.
Step 4: Discover the Quarkus Philosophy
At this point you may be wondering: why does Quarkus feel so different? The answer lies in build-time optimizations. Instead of leaving classpath scanning and reflection to runtime, Quarkus resolves as much as possible when you compile.
Build-Time Optimizations Explained unpacks how this shift pays off: faster startup, smaller memory usage, and easier containerization.
But philosophy is more than numbers. From CDI Sorcery to Container Sanity is a developer’s reflection on how Quarkus trades clever runtime tricks for predictable behavior. And if you’re coming from Spring, What Spring Didn’t Teach You explains the deeper shift in expectations: today’s frameworks need to serve cloud-native platforms, not just web servers.
Why care about philosophy? Because once you understand how Quarkus thinks, you’ll write code that takes advantage of it instead of fighting it.
Step 5: Build Confidence With Testing
Speed is nothing without trust. The foundation of Quarkus isn’t complete until you know how to test effectively. This is where Quarkus shines: testing isn’t bolted on, it’s integrated into the developer experience.
In Mutation Testing in Quarkus, you’ll see why 95% coverage doesn’t always mean safety. By flipping small parts of your code and checking if tests catch it, mutation testing exposes weak spots.
Next, Test Coverage with JaCoCo shows you how to measure coverage in a way that makes sense for Quarkus apps. And Dev Services + Continuous Testing introduces the killer feature: tests that run automatically as you type, giving you near-instant feedback.
This step matters because trust scales. Once you’ve built a habit of testing with Quarkus, you’ll never want to go back to the old redeploy-and-pray cycle.
Where to Go Next On You Own
With these five steps, you’ve built a real foundation: REST endpoints, CLI mastery, dependency injection, philosophical grounding, and testing discipline. That’s enough to take on the next challenges:
-
Persistence with Panache and JPA
-
Security and fine-grained RBAC
-
Reactive messaging and WebSockets
-
AI integrations with LangChain4j
Each of these has its own journey. But don’t skip ahead. The stronger your foundations, the faster you’ll move later.
Keep On Innovating
Quarkus has changed the way I think about Java. It’s still the language and ecosystem I’ve worked with for decades, but with foundations that make sense for today’s cloud and AI-driven world.
The tutorials I’ve linked here are the same ones I use when mentoring developers who are new to Quarkus. They build confidence step by step, without overwhelming you with too much theory at once.
If this journey sparks your curiosity, I’d love for you to follow along. Subscribe to The Main Thread and get each new tutorial, deep dive, and experiment straight in your inbox. Let’s keep exploring modern Java together.
