# Spring Boot vs Quarkus: frameworks JVM comparados

> Spring Boot vs Quarkus para a JVM: o ecossistema onipresente vs o framework cloud-native com startup rápido e imagens nativas GraalVM. Startup, memória e adequação a CI comparados.

Source: https://latchkey.dev/pt/learn/tool-comparisons/spring-boot-vs-quarkus  
Updated: 2026-06-26

O Spring Boot é o framework JVM dominante, com um vasto ecossistema; o Quarkus é um framework cloud-native otimizado para startup rápido, baixa memória e imagens nativas GraalVM.

O Spring Boot oferece um enorme ecossistema, convenções e integrações, tornando-se o padrão para a maioria dos serviços Java. O Quarkus é construído para containers e serverless - boot rápido, baixa memória e compilação nativa GraalVM de primeira classe - mantendo uma experiência de desenvolvimento familiar. O trade-off é a amplitude de ecossistema versus o startup e a pegada cloud-native.

## Comparison

|  | Spring Boot | Quarkus |
| --- | --- | --- |
| Ecossistema | Vasto | Crescente, focado |
| Tempo de startup | Mais lento (JVM) | Rápido (esp. nativo) |
| Pegada de memória | Maior | Baixa |
| Imagem nativa | Via Spring Native | De primeira classe (GraalVM) |
| Melhor para | Amplos apps enterprise | Containers / serverless |

## Em CI

Ambos fazem build com Maven ou Gradle e testam com JUnit. Builds de imagem nativa do Quarkus são bem mais lentos em CI, mas geram artefatos de runtime rápidos e pequenos - faça cache do build e considere fazer o build nativo apenas no release. Faça cache do dependency cache do Maven/Gradle para ambos. Escolha conforme cold-start e pegada importam.

## Acelere

Faça cache do dependency cache e do build cache do Maven/Gradle entre execuções. Ambos fazem build em CI runners; managed runners mais rápidos ajudam muito na lenta etapa de imagem nativa do Quarkus.

## Decide with your own numbers, not a feature table

Feature comparisons age badly and rarely decide anything, because both tools in a mature category can do the job. What differs is how each behaves on your repository, and that takes one afternoon to measure.

```Terminal
# time a cold install with each candidate, cache cleared
hyperfine --prepare "rm -rf node_modules" --warmup 1 \
  "<tool-a> install" "<tool-b> install"

# and the thing CI actually pays for: a cold run with no local cache
docker run --rm -v "$(pwd):/w" -w /w node:22 sh -c "<tool> install"
```

> Measure the cold path. Warm local benchmarks favour whichever tool you already have cached, which is exactly the condition a CI runner never has.

## What actually changes when you switch

- Lockfile format. A switch is a one-way door for anyone still on the old tool until everyone migrates, so plan it as a single coordinated change.
- Resolution strictness. Tools differ on whether an undeclared transitive import works, and the stricter one will surface latent bugs as new failures.
- CI cache configuration. The cache path and key differ per tool; carrying over the old ones silently disables caching.
- Everyone on the team and every runner must move together. Pin the version so they cannot drift.

## O veredito

Quer o ecossistema mais amplo e convenções para apps enterprise: Spring Boot. Quer startup rápido, baixa memória e imagens nativas para containers/serverless: Quarkus. Spring Boot para amplitude, Quarkus para pegada cloud-native.

## FAQ

### Spring Boot vs Quarkus: JVM Framework Compared?

Spring Boot offers an enormous ecosystem, conventions, and integrations, making it the default for most Java services. Quarkus is built for containers and serverless - fast boot, low memory, and first-class GraalVM native compilation - while keeping a familiar developer experience.

### In CI?

Both build with Maven or Gradle and test with JUnit. Quarkus native-image builds are much slower in CI but yield fast, small runtime artifacts - cache the build and consider building native only on release. Cache the Maven/Gradle dependency cache for both. Choose by whether cold-start and footprint matter.

### Speed it up?

Cache the Maven/Gradle dependency cache and build cache between runs. Both build on CI runners; faster managed runners help a lot with the slow Quarkus native-image step.

### Which should I choose?

Want the broadest ecosystem and conventions for enterprise apps: Spring Boot. Want fast startup, low memory, and native images for containers/serverless: Quarkus. Spring Boot for breadth, Quarkus for cloud-native footprint.

---

Latchkey runs CI/CD that repairs its own failures. Agent entry points: https://latchkey.dev/agent.txt, https://latchkey.dev/openapi.json, https://latchkey.dev/llms.txt