Running Quarkus?

Quarkus native build failing or dev mode frozen? We sort it out.

Quarkus promises Java services that start in tens of milliseconds and sip memory, which is true when the native image build has all the reflection config it needs. The friction shows up when a library ignores the GraalVM constraints, a dev-mode class-loader loop jams, or the build mode produces something that runs fine on the JVM and crashes native. We work both sides and ship something that actually boots cold.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

quarkus-build.log

still failing

What it is

Quarkus at a glance

Quarkus is a Java framework focused on container-first and native-image deployment, first released by Red Hat in 2019. It uses build-time augmentation to move configuration, classpath scanning and reflection work out of the runtime startup path, which cuts a Spring-era Java boot from seconds to tens of milliseconds.

The framework integrates with GraalVM native-image compilation and ships extensions for Hibernate, RESTEasy, SmallRye, Kafka, Hibernate Reactive and much of the Jakarta EE and MicroProfile surface. Kotlin is a first-class language alongside Java. Quarkus pairs naturally with OpenShift, Kubernetes and serverless targets where fast cold starts and small memory footprints are the point.

Type
Java and Kotlin framework for cloud-native workloads
First released
2019 public 1.0
License
Apache 2.0
Maintained by
Red Hat, Inc. and the Quarkus community
Typically used for
Microservices, serverless functions, container workloads, APIs that need fast startup and low memory

The honest version

Quarkus pros and cons

No technology is all upside. This is where Quarkus earns its place and where it tends to cause trouble.

Where Quarkus is strong

  • Native-image startup in millisecondsBuild-time augmentation plus GraalVM compilation produces a binary that starts in tens of milliseconds and uses a fraction of the memory a JVM Spring application needs.
  • Live reload that actually worksQuarkus dev mode detects source changes and hot-patches the running application, which is the closest a Java workflow gets to the feel of a scripting language.
  • Standards-based extension modelJakarta EE, MicroProfile, Hibernate, RESTEasy and others arrive through the extension system with sensible defaults and integrated testing.
  • Reactive and imperative in one stackThe same codebase can mix blocking and reactive endpoints, which lets teams adopt reactive gradually rather than in a rewrite.
  • Good Kotlin supportKotlin is a supported language with coroutines interoperability, which makes it a credible choice for teams who prefer Kotlin over Java.

Where Quarkus bites

  • Native-image builds are slow and strictA production native build can take ten minutes and will fail on any reflection, resources or proxies that are not declared. The error messages are blunt and the fix is often a reflection-config.json entry.
  • Not every library works in native modeJVM libraries that assume dynamic class loading, bytecode generation or unrestricted reflection need Quarkus extensions or workarounds. The ecosystem has grown, but not every dependency is native-ready.
  • Dev-mode class-loader has corner casesSome code paths trip the hot-reload mechanism and the dev server stops picking up changes until a restart. The failure is quiet, which is the worst kind.
  • GraalVM version couplingThe Quarkus version, the GraalVM version and the native-image plugin need to agree. Mismatches produce build errors that read like native-image errors but are really version drift.
  • Smaller community than Spring BootSenior Spring Boot engineers outnumber senior Quarkus engineers by a wide margin, and third-party integrations usually ship Spring support before Quarkus.
  • Hibernate ORM metadata is heavy at build timeLarge schemas push native-build memory requirements up noticeably, and reactive Hibernate has its own quirks in native mode.

Sound familiar?

Common Quarkus problems we fix

The Quarkus problems that bring people to us, and what you have once each one is fixed.

Classes that should be initialized at run time got initialized during image building

Native image refuses to build on a library's static init

A dependency runs code in a static initialiser that touches the environment at image-build time. The fix is RuntimeInitialization configuration for the offending class.

Native build succeeds with proper init

Proxy class defined by interfaces not found

Dynamic proxies missing from the native image

A JDK dynamic proxy generated at runtime from a set of interfaces that native image did not know to generate ahead of time. The proxy-config.json or an extension declaration solves it.

Proxies declared ahead of time

Unsatisfied dependency for type

CDI injection fails at startup

A missing bean producer, a wrong scope, or an ambiguous resolution. Quarkus validates the bean graph at build time rather than discovering it at first use, which is the right time to catch it.

Bean graph complete at build

cannot find class for native image

Reflection-dependent code crashes in native mode

A library uses reflection to find entities, serializers or handlers and native image eliminated them as unreachable. RegisterForReflection or an extension registration brings them back.

Reflection config complete

dev mode: unable to reload class, LinkageError

Dev mode hot reload stops working

A class change that is not compatible with the current loaded version, or a dependency that was not expected to change at runtime. A clean restart clears it; a pattern that keeps causing it needs investigation.

Dev reload reliable again

NoClassDefFoundError: javax.xml.bind.JAXBContext

JDK removal surprises an older library

A dependency expecting the old javax.xml.bind that is no longer on the classpath. Adding a jakarta.xml.bind implementation or swapping the library is the honest fix.

Classpath aligned with the JDK

Panache repository: lazy loading not supported in native

Panache behaviour differs between JVM and native

Lazy associations traversed outside a transaction work on the JVM and fail native. Explicit fetching in the query, or a DTO projection, works in both modes.

Code behaves the same in both modes

What we do

Quarkus help, from one failing build to a managed native estate

A single native build that will not green up, or the whole Quarkus application; both welcome.

Native image enablement
Reflection, proxy and resource config completed so the native build works first time, with CI integration to keep it that way.
Dev mode debugging
Finding the class-loader corner that broke hot reload, and arranging the code so it stays reliable.
Extension selection
Choosing the right Quarkus extensions for Hibernate, Kafka, messaging and HTTP against what your workload actually needs.
Performance
Build-time augmentation tuning, Hibernate metadata reduction and reactive vs blocking choices that match the traffic shape.
Spring Boot migration
Moving services from Spring Boot to Quarkus when startup time or memory footprint are the pain point, without rewriting business logic twice.
Managed Tech
Watching native builds, JDK and GraalVM upgrades, extension CVEs and startup metrics, with hands on the keyboard when a release breaks a build.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Quarkus alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Quarkus questions

Something else? Call+1 737 727 7327

Why does our Quarkus native build fail on reflection?

Native image removes classes it considers unreachable, and reflection-heavy libraries then fail to find them at runtime. The fix is declaring the needed classes via @RegisterForReflection, reflection-config.json, or by installing a Quarkus extension that already contains the configuration. Most mainstream libraries have an extension; the fallback is manual config, which is tedious but reliable.

Should we build native images in CI or JVM images?

Both. The JVM image boots in a second and uses modern Java well; the native image boots in tens of milliseconds and uses a fraction of the memory. For serverless and scale-to-zero workloads, native is the point. For long-running services under steady load, JVM is often fine and much faster to build. The honest answer is to have both pipelines and choose per workload.

Our Quarkus dev mode stops picking up changes, what causes it?

The common cause is a class-structure change that the hot-reload mechanism cannot apply in place, usually a method signature change or a field type change on a class that is referenced from a frozen context. A full restart clears it. If the pattern recurs often, it usually points at a code structure that the hot reloader struggles with, which is worth refactoring rather than restarting around.

Is Quarkus a safe replacement for Spring Boot?

For workloads where fast startup and low memory matter, yes. The hiring pool is smaller, so documentation, naming conventions and in-team training matter more. For a monolithic Spring Boot service with heavy legacy weight, migration is usually not worth it. For microservices, serverless functions and new builds in container-first environments, Quarkus is often a better fit.

How much does Quarkus help cost?

We quote free of charge. Send the service, the JDK and GraalVM versions, and what is stuck; the scope and price come back shortly after.

Free estimate

Quarkus giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.