Spring Boot 3 vs Quarkus vs Micronaut 2026

TL;DR

• Spring Boot 3 (Java 21 LTS): default enterprise Indonesia. Ekosistem terbesar, hiring termudah, Spring AOT matang.
• Quarkus 3.x native: startup 50-200ms, memory 40-60MB, ideal serverless + event-driven.
• Micronaut 4.x: AOT compile-time throughput tinggi, cloud-native first.
• Verdict: Conditional — Spring Boot default, Quarkus untuk service startup-sensitive, Micronaut alternative niche.

Konteks

Saya jalankan 3 framework paralel 26 bulan di 2 konteks enterprise Jakarta:

• BUMN energy (2024-2025): Spring Boot 3 + Java 21 LTS, 22 microservice core. Legacy Java 8 di-upgrade ke 21 dalam scope migrasi terpisah.
• Fintech series-B (2024-2026): Spring Boot 3 untuk 14 service, Quarkus native untuk 4 service event-driven greenfield, eval Micronaut 1 service 6 bulan lalu kembali ke Quarkus untuk consistency.

Pengalaman Spring sebagai engineer: 11 tahun (sejak Spring 3.x era). Quarkus: 2,5 tahun. Micronaut: 1 tahun (eval + 1 service production).

Pricing + cost model

Framework gratis (semua open source). Cost real = compute + ops time.

Spring Boot 3 + JVM

• Pod sizing typical untuk 1k RPS: 1 vCPU, 1GB RAM heap + 200MB overhead
• 14 service × 3 replica = 42 pod
• GKE Jakarta e2-medium equivalent: 42 × Rp 600 ribu / 3 (pod per VM) = ~Rp 8,4 juta/bulan compute
• Plus 2 service GC-tuned dengan ZGC butuh 2GB RAM = Rp 1,8 juta/bulan

Quarkus native

• Pod sizing typical untuk 1k RPS: 0,5 vCPU, 256MB RAM
• 4 service × 3 replica = 12 pod
• GKE Jakarta: 12 × Rp 230 ribu = ~Rp 2,8 juta/bulan compute

Total

Item	Cost/bulan
Spring Boot 3 (14 service, 42 pod)	Rp 10,2 juta
Quarkus native (4 service, 12 pod)	Rp 2,8 juta
Build infrastructure (CI compute extra untuk native build)	Rp 850 ribu
Total compute	Rp 13,85 juta/bulan

Bandingkan kalau 18 service full Spring Boot: ~Rp 14,4 juta/bulan compute (tanpa CI overhead native). Hybrid pattern saving Rp 550 ribu/bulan = ~Rp 6,6 juta/tahun. Saving lebih besar muncul kalau service Quarkus = 50%+ stack: untuk fintech full Quarkus akan saves Rp 7-8 juta/bulan compute.

Performance benchmark

Setup: 1 pod GKE Jakarta asia-southeast2 e2-medium, REST endpoint JSON + 1 Postgres query via connection pool, framework configuration default + production-tuned.

Metrik	Spring Boot 3 JVM	Quarkus JVM	Quarkus native	Micronaut JVM	Micronaut native
Cold start	4,2 detik	1,8 detik	65ms	1,2 detik	180ms
Memory RSS idle	420MB	220MB	48MB	180MB	75MB
Memory RSS active	680MB	380MB	95MB	320MB	120MB
First request latency	850ms	320ms	12ms	240ms	35ms
Throughput max RPS	1.450	1.380	1.250	1.520	1.420
p50 di 1k RPS	18ms	19ms	22ms	16ms	18ms
p99 di 1k RPS	145ms	138ms	165ms	128ms	142ms
Build time	1,2 menit	1,5 menit	5,8 menit	1,1 menit	4,2 menit

Insight key

• Cold start: Quarkus native menang besar (50-65ms vs 4 detik Spring). Game changer untuk scale-to-zero scenario.
• Memory footprint: Quarkus native ~10% dari Spring Boot. Untuk pod density tinggi atau Knative serverless, signifikan.
• Throughput: JVM modes comparable. Native sedikit di belakang JVM (tradeoff GraalVM AOT vs JIT optimization).
• Latency: serupa di range 1k RPS. Native ada overhead startup-per-request kecil tapi negligible setelah warmup.
• Build time: native compile 4-6x lebih lambat. Impact CI cost.

Workload riil

Service: payment notification dispatcher, terima event dari Kafka, validate, enrich, push ke external API.

Aspek	Spring Boot 3 (sebelum migrate)	Quarkus native (setelah migrate)
Pod count	6 (handle 3k events/sec)	3
Memory per pod	720MB	110MB
Compute cost/bulan	Rp 2,1 juta	Rp 580 ribu
Cold start (saat scale-up)	8-12 detik	80ms
MTTR pod restart	35 detik	< 5 detik

Migrate 4 service event-driven ke Quarkus native saves Rp 5-6 juta/bulan compute + MTTR meaningful improvement.

Capability comparison

Capability	Spring Boot 3	Quarkus	Micronaut
DI container	Spring	CDI (Arc)	Compile-time DI
Web framework	Spring MVC + WebFlux	RESTEasy / Vert.x	Netty-based
Data access	Spring Data JPA / R2DBC	Hibernate Reactive / Panache	Micronaut Data
Messaging Kafka	Spring Kafka	Quarkus Kafka (SmallRye Reactive)	Micronaut Kafka
Messaging RabbitMQ	Spring AMQP	Quarkus RabbitMQ	Micronaut RabbitMQ
Scheduler	@Scheduled	Quartz / SmallRye Scheduler	Micronaut Scheduling
Health check	Actuator	SmallRye Health	Micronaut Management
Tracing OpenTelemetry	ya	ya (first-class)	ya
Native compile	Spring AOT 3.4+	Quarkus GraalVM native	Micronaut GraalVM
Hot reload dev	Devtools (slow)	Quarkus Dev Mode (fast, < 1 detik)	Continuous mode
Configuration	application.yml + Profile	application.properties + profile	application.yml + env
Testing framework	JUnit + Spring Test	JUnit + QuarkusTest	JUnit + MicronautTest
Security framework	Spring Security	Quarkus Security + Keycloak	Micronaut Security
GraphQL	Spring GraphQL	SmallRye GraphQL	Micronaut GraphQL
OpenAPI / Swagger	Springdoc	SmallRye OpenAPI	Micronaut OpenAPI

Spring Boot 3 strengths

• Ekosistem terbesar: 50.000+ Spring Boot starter / library, hampir semua enterprise integration ada
• Hiring di Indonesia: paling mudah cari engineer Spring Boot berpengalaman
• Spring AOT (3.4+): native compile via Spring AOT + GraalVM matang di 2026, alternative ke Quarkus untuk full Spring stack
• Documentation: paling lengkap, Stack Overflow paling banyak

Spring Boot 3 weaknesses

• Memory footprint: 4-6x lebih besar dari Quarkus native
• Cold start: 4-6 detik JVM, problematic untuk serverless / scale-to-zero
• Build time native (Spring AOT): 6-10 menit per service, lebih lambat dari Quarkus native

Quarkus strengths

• Native compile cepat startup: 50-200ms
• Dev mode: hot reload < 1 detik (Spring Boot Devtools 3-5 detik)
• First-class reactive: SmallRye Reactive + Vert.x integration native
• Memory efisien: 40-100MB per service

Quarkus weaknesses

• Hiring di Indonesia: lebih jarang. Senior Quarkus engineer butuh kompensasi premium atau training Spring engineer.
• Ekosistem lebih kecil: 1.500-2.000 extension (Spring Boot starter 10x lebih banyak)
• Migration dari Spring Boot: butuh effort signifikan (annotation berbeda, configuration berbeda)

Micronaut strengths

• AOT compile-time DI: zero reflection runtime, fast startup tanpa GraalVM native (JVM mode startup 1,2 detik)
• Cloud-native first: AWS Lambda, GCP Functions, Azure integration first-class
• Memory tipis: 180-320MB JVM mode

Micronaut weaknesses

• Adoption Indonesia sangat rendah: hiring susah, community kecil
• Ekosistem lebih kecil dari Quarkus: 600-800 module
• Compile-time DI complexity: debugging build error butuh experience

HA + DR

Spring Boot 3 production setup

• Pod: 3 replica minimum, HPA scale 3-10 based on CPU+memory
• Postgres: regional HA dengan read replica
• Cache: Redis sentinel HA
• RPO: 5 menit (Postgres PITR)
• RTO: 8-15 menit untuk regional failover
• Spring Cloud (kalau dipakai): Config Server HA + Discovery (Eureka / Consul)

Quarkus native setup

• Pod: 2 replica minimum (lebih kecil OK karena startup cepat)
• HPA scale-to-zero possible (Knative) — saves cost untuk low-traffic service
• RPO/RTO: similar Spring Boot, plus advantage scale-up 100x lebih cepat

Micronaut

• Similar dengan Spring Boot tapi memory footprint Micronaut lebih kecil

Trade-off arsitektural

Pilih Spring Boot 3 kalau:

• Tim engineering > 80% familiar Spring (BUMN, bank, enterprise besar Indonesia)
• Investment Spring deep (custom starter, Spring Cloud config, dll)
• Memory + startup time bukan constraint utama (service always-on, traffic predictable)
• Hiring pool engineer di area Indonesia (pasar Java enterprise dominan Spring)
• Ekosistem integration enterprise (Oracle DB native driver, IBM MQ, SAP integration)

Pilih Quarkus kalau:

• Service event-driven dengan scale spike (campaign payday, flash sale)
• Serverless / Knative deployment
• Greenfield project dengan budget engineering untuk train tim
• Cost compute matter (saving 50%+ vs Spring Boot JVM at scale)
• Reactive programming first-class

Pilih Micronaut kalau:

• Cloud-native serverless (AWS Lambda heavy)
• AOT compile-time DI sebagai differentiator
• Tim familiar dengan compile-time framework (less reflection magic)

Migration risk

Spring Boot 2 → 3

Saya jalankan di BUMN energy: 22 service Spring Boot 2.7 → 3.2, paralel dengan Java 8 → 21.

• Major change: javax → jakarta namespace
• Spring Security 5 → 6 (config API berbeda)
• Hibernate 5 → 6 (entity scanning behavior beda)
• Total elapsed: 6 bulan paralel migration (2 dev part-time)

Painful tapi straightforward — well-documented migration guide dari Spring team.

Spring Boot → Quarkus

Saya tidak rekomendasi migrate, lebih efektif rewrite per-service:

• Annotation berbeda (Spring @RestController vs JAX-RS @Path)
• Configuration berbeda (application.yml vs application.properties + MP Config)
• DI berbeda (Spring @Autowired vs CDI @Inject)
• Testing berbeda

Per service rewrite estimate: 3-6 minggu engineering, plus 2-4 minggu validation paralel. Untuk 18 service: 1,5-2 tahun kalau full migration. Lebih masuk akal: Quarkus untuk service baru, Spring Boot untuk service existing.

Spring Boot AOT → Quarkus native

Kalau goal sama (native compile), Spring AOT 3.4+ adalah alternative. Trade-off:

• Spring AOT: stay Spring ekosistem, native compile available, tapi build time lebih lambat (8-12 menit per service)
• Quarkus native: ekosistem berbeda, build time 4-6 menit per service, lebih mature native experience

Untuk BUMN dengan Spring investment deep: Spring AOT lebih masuk akal walaupun lebih lambat build.

Common pitfall

1. JVM tuning default untuk Spring Boot. Default -Xmx512m untuk service 1k RPS = OOM risk. Setup heap + GC sesuai workload. ZGC untuk latency-sensitive, G1 default OK untuk batch.
2. Quarkus native build di laptop dev. Native compile memory-intensive (4-8GB). Pakai CI runner powerful, jangan local build untuk feedback loop. Dev mode (JVM) untuk iteration.
3. Reflection di code untuk Quarkus native. Library yang heavy reflection (Jackson custom, Hibernate proxy) butuh registration di GraalVM config. Audit dependency sebelum commit ke native.
4. Spring AOP magic di Quarkus. Quarkus CDI tidak support semua Spring AOP pattern. Refactor cross-cutting concern jadi interceptor explicit.
5. Health check default. Default Spring Actuator / Quarkus Health check terlalu kasar. Implement custom liveness + readiness yang reflect business logic (DB connection, Kafka connection, downstream API).

Cost of ownership 36 bulan

Skenario: 18 microservice fintech series-B, full Spring Boot vs hybrid (14 Spring + 4 Quarkus native).

Komponen	Full Spring Boot 3	Hybrid Spring + Quarkus
Compute 3 tahun	Rp 545 juta	Rp 432 juta
CI compute 3 tahun	Rp 95 juta	Rp 125 juta (native overhead)
Ops time engineer	Rp 540 juta	Rp 595 juta (multi-framework overhead)
Training tim Quarkus	Rp 0	Rp 45 juta one-time
Hiring premium Quarkus	Rp 0	Rp 60 juta (2 senior engineer)
Total 3 tahun	Rp 1,18 miliar	Rp 1,26 miliar

Hybrid sedikit lebih mahal di 3 tahun. Justify-nya bukan cost — justify-nya: scale-up MTTR + serverless capability untuk service event-driven yang punya traffic spike 10-20x baseline.

Untuk service always-on traffic predictable: full Spring Boot lebih ekonomis. Untuk service scale-bursting: Quarkus worth premium.

Yang surprising

Setelah 26 bulan: hiring Quarkus engineer ternyata lebih sulit dari ekspektasi di Jakarta. 4 senior Quarkus engineer dalam 18 bulan recruiting effort — vs 12 Spring Boot senior dalam waktu sama. Pool talent Indonesia masih dominan Spring. Strategy saya: train Spring engineer existing ke Quarkus (4-6 minggu ramp-up), lebih hemat dari hiring spesialis.

Surprise lain: Spring AOT 3.4 ternyata mature lebih cepat dari ekspektasi. Saya re-evaluate di Q1 2026: native compile Spring AOT untuk 2 service test, hasil startup 350-500ms (vs Quarkus native 60ms). Lebih lambat dari Quarkus, tapi acceptable untuk service yang tidak perlu serverless scale-to-zero. Mengurangi tekanan untuk migrate ke Quarkus full.

Verdict

Conditional dengan rule konkret:

• Default enterprise Indonesia (BUMN, bank, fintech): Spring Boot 3 + Java 21 LTS. Hiring + ekosistem unmatched.
• Service event-driven dengan scale spike: Quarkus native. Cost compute 50% lower, MTTR 10x lebih cepat.
• Service event-driven tetap di Spring Boot: Spring AOT native (3.4+) untuk avoid multi-framework overhead.
• Skip Micronaut untuk enterprise Indonesia kecuali ada use case spesifik cloud-native + tim familiar.

Threshold konkret untuk introduce Quarkus ke stack Spring: 3+ service dengan pattern scale-to-zero atau traffic spike > 10x baseline. Di bawah ini, multi-framework overhead > saving compute.