My new favorite stack Nuxt 4 Nuxt UI MongoDB and Quarkus
After half a dozen stacks over the past year, the one I kept is not the one I expected: Nuxt 4 on the frontend, Quarkus on the backend, MongoDB underneath, and Nuxt UI for the components. It's not a combination you see in tutorials. But it lets me prototype in hours what used to take me days, and the apps that come out of it are fast without me having to fight for it.
The other thing that sold me was the documentation. All four pieces have solid docs, guides that work when you copy them, and examples that aren't from a version two years old. It sounds like a minor detail, but it's the difference between moving forward and spending your afternoon deciphering.
The question I wanted to answer for myself was why four pieces from such different worlds fit together without friction. Let's go piece by piece.
Nuxt 4: the reorganization wasn't cosmetic
Nuxt 4 has been stable since July 15, 2025 and, as I write this, it's on 4.5.x. What convinced me most wasn't a new feature but the reorganization: all application code now lives in app/, separated from the configuration and from the framework's internal folders.
It sounds like a coat of paint, but it isn't. File watchers have less to watch and hot reload feels smoother, especially on Windows and Linux, where it used to be a pain. The IDE wins too: it tells your code apart from the framework's much better, and autocomplete stops returning noise.
my-app/
ββ app/
β ββ components/
β ββ pages/
β ββ app.vue
ββ shared/
ββ server/
ββ nuxt.config.tsThe other point in its favor is that the ecosystem scales with you. You can start with Nitro server routes for a simple API and, when the system grows, move the backend to another technology without changing how the frontend consumes data. That path from simple API to serious system is exactly what I need when prototyping: an endpoint today, something real tomorrow.
Nuxt UI: the toll that went away
There was an emotional moment here. Nuxt UI 4 shipped on September 21, 2025 and merged the free version and Pro into a single MIT library, with more than 125 components. Tables, sidebars, and dashboards used to cost money. Now they come included, under an open license.
It's not that Pro cost a fortune. It's the mental toll: every time a prototype needed a decent table, along came the decision to pay or to improvise. That friction is gone, and with it one more excuse for not taking care of the interface.
Installation changed too, and I like it better this way. Instead of module options in nuxt.config.ts, it's now two lines in the entry CSS, @import "tailwindcss"; and @import "@nuxt/ui";. The project config stays almost empty:
export default defineNuxtConfig({
modules: ['@nuxt/ui', '@pinia/nuxt'],
devtools: { enabled: true }
})MongoDB: my default until the schema settles
MongoDB is my default when the schema is going to evolve. If I'm prototyping and requirements change every week, SQL migrations slow me down. With documents I add a field and keep going, and the JSON model talks naturally with TypeScript, so I'm not translating between worlds. The current 8.x hasn't given me a single reason to complain.
In Nuxt the glue is a Nitro plugin that opens the connection once, before the first request arrives:
export default defineNitroPlugin(async () => {
if (!mongoose.connection.readyState) {
await mongoose.connect(process.env.MONGODB_URI)
}
})It's the only non-obvious glue in the whole stack, and it's thin.
The honest part: I wouldn't use it for a system with strict referential integrity, the kind where a badly closed transaction costs money. For that, it's still PostgreSQL. MongoDB works for me when the shape of the data isn't decided yet, not when consistency is non-negotiable.
Quarkus: Java without the wait
On the backend I got to Quarkus coming from Spring Boot, and the difference that matters is the waiting. In development it runs on the JVM with practically immediate hot reload: I save the file and the new response is already there. For production it compiles to native, and that's where the contrast with a traditional Spring Boot shows the most, especially in startup time and in how much memory the containers drink. I'm not going to throw figures around because an isolated number tells me little; on my machine, you feel it the moment the whole stack comes up.
I run the 3.33 LTS, published in March 2026, which is the current LTS. With an LTS I don't have to revalidate half the project every three months.
What hooked me was Panache. A MongoDB entity looks like this:
@Entity
public class Product extends PanacheMongoEntity {
public String name;
public BigDecimal price;
public String category;
public static List<Product> byCategory(String category) {
return list("category", category);
}
public static List<Product> inStock() {
return list("stock > 0");
}
}That list("category", category) is what I love: a query written as a sentence, with no ceremonial repository for the obvious. When the query gets complicated, then yes, I write the full query, but almost none of the day-to-day needs it. Ceremony was my historical complaint about the JVM world, and Panache took it off my shoulders.
For now, this is my starting point
I don't think I've found the definitive stack. I found one that takes me from idea to working prototype without fighting the tools, and that holds up when the prototype deserves to grow. In the projects I've shipped with it, the ratio between speed and result is the best I've had.
I'm not going to pretend it's risk-free either. The Nuxt plus Quarkus combination barely shows up in tutorials, so when something breaks I search alone, with no net of ready answers. And versions move fast: Nuxt UI went from Pro to MIT in a single major version jump, and that kind of change breaks things when you upgrade.
Like everything I use, sooner or later I'll question it again. For now, it's the stack I return to every time I start something new.