Summary

Summary

In this learning path, you learned the fundamental concepts of Quarkus. This learning path covered:

• The Quarkus CLI, dev mode, and its performance benefits.
• Creating a Quarkus project
• Building a REST API using Quarkus REST
• Working with relational data in Quarkus using Hibernate ORM with Panache
• Configuring Quarkus profiles
• testing Quarkus apps
• Containerizing and running Quarkus apps in Kubernetes

Next steps

Now that you know the basics, explore where to go next. Continue with advanced learning paths about:

• Reactive programming
• Security
• Messaging
• Observability
• AI-infused applications with LangChain4j.

Quarkus is designed to grow with your needs. You can start small and expand into advanced areas as your applications evolve.

With IBM Enterprise Build of Quarkus, you get high performance plus long-term support, curated builds, security patching, and enterprise-grade stability that goes beyond the fast-moving open source stream for Quarkus. Learn more about what IBM Enterprise Build of Quarkus adds to your Java stack on the product page.

Reactive programming

“Reactive” can sound intimidating, but with Quarkus it doesn’t have to be. Reactive simply means building applications that stay responsive under load, can scale up or down easily, and recover gracefully from failures. In practice, it is about handling many requests efficiently without wasting threads and memory.

Quarkus has a reactive engine built in (based on Vert.x and Netty) that uses non-blocking I/O. This allows a small number of threads to handle a large number of concurrent requests. You don’t need to switch entirely to a new style of programming to benefit. Quarkus unifies imperative (classic Java) and reactive styles, so you can start with the blocking code you know, and only use reactive APIs when you want higher efficiency. For those who want to go deeper, Quarkus provides Mutiny, a library that makes reactive programming easy to read and write, and supports Kotlin coroutines as well.

Learn more with the Quarkus Reactive Guides.

Security

Every real-world application needs security. Quarkus includes powerful security features out of the box, such as:

• JWT authentication for REST APIs
• Role-based access control (RBAC)
• Integration with OAuth2 and OpenID Connect

These features let you protect endpoints, enforce access rules, and integrate with enterprise identity providers.

Learn more with the Quarkus Security Guides.

Messaging and event-driven systems

Many applications today are event-driven. They don’t just respond to REST calls, they also react to messages from Kafka, AMQP, or MQTT. Quarkus has extensions for messaging that make it easy to publish and consume events. This is a foundational element for building scalable microservices and real-time systems.

Learn more with the Quarkus Messaging Guides.

Observability

In production, you need to see what your application is doing. Quarkus integrates with metrics, health checks, and distributed tracing so you can monitor performance, uptime, and dependencies. Observability ensures you can find problems quickly and keep services reliable.

Learn more with the Quarkus Observability Guides.

AI integration

AI is becoming a standard part of modern applications. With Quarkus and the LangChain4j extension, you can connect to large language models (LLMs) as easily as you call REST APIs. Quarkus gives you a smooth developer experience, so you can add AI features without leaving the Java ecosystem.

What you can do with LangChain4j in Quarkus:

• AI services. Define Java interfaces that map directly to AI calls, turning prompts into typed methods.
• Prompt engineering. Use templates, few-shot examples, and structured prompts directly in Java.
• Memory and chat history. Keep track of conversations so your AI can answer with context.
• Function calling: Let the model trigger real methods in your code (for example, “check the database” or “call an API”).
• RAG (retrieval augmented generation). Combine LLMs with your own data using vector stores like PostgreSQL (pgvector), Redis, or Milvus.
• Multimodal. Pass images to models, extract text from documents, and even generate images.
• Observability and guardrails. Track calls to AI services, handle failures with fault tolerance, and filter responses with validation rules.

Quarkus LangChain4j also supports many backends: OpenAI, Anthropic, IBM watsonx.ai, HuggingFace, Ollama (local models), and more.

Learn more about the Quarkus LangChain4j integration.

With Quarkus, adding AI isn’t about reinventing the wheel. You use the same developer tools you already know (CDI, REST, configuration), but now you can build AI-powered services alongside them.