When would you compile a Java service to a native image, and what do you give up?

Native image suits workloads where startup time and memory dominate: serverless functions, command line tools and services that scale to zero, since it starts in milliseconds with no warmup and a much smaller footprint. The cost is a closed world assumption, so reflection, dynamic proxies and resource loading must be known at build time, builds are slow, and peak throughput can be lower than the JIT achieves on a long running process.

I reach for it when startup time is on the critical path. A function that runs for two hundred milliseconds cannot afford a JVM that takes three seconds to start and another minute to warm up, and the same argument applies to a command line tool or a service that scales to zero between bursts of traffic. Memory is the other win, since a native image can run in a fraction of the heap. What you give up is the dynamism. Ahead of time compilation assumes a closed world, so anything discovered at runtime, reflection, dynamic proxies, service loading, resource bundles, has to be declared at build time. Modern frameworks generate most of that configuration for you during their build step, but a library that does something clever at runtime will fail in a way that only appears in the native binary, so the test suite has to run against the image too. Builds also take minutes rather than seconds, and observability tooling is less mature. For a long running service handling steady traffic I stay on the JVM, because the JIT eventually beats ahead of time compiled code on peak throughput.