If we were starting an MVP tomorrow, here's the stack we'd pick, and what we'd deliberately skip.
This is not a universal architecture, and it isn't a personality test. It's a default for a common kind of product: a web app with accounts, a database, maybe payments, used by people in a browser. A lot of early startups are that product, even when the pitch deck makes them sound more exotic.
The point of a default is to spend less time arguing about tools, and more time on the part that's actually uncertain: whether anyone wants the thing.
What we'd pick
Next.js for the web app. One codebase for the marketing site and the product is a practical advantage at the start. You can render the public pages in a way that search — and people sharing links — can understand, and still build a signed-in app in the same project. The React ecosystem is familiar enough that hiring, examples, and libraries are easy to find. We'd start simple: a clear folder structure, server-side data where it helps, and no extra framework on top until we feel a real limitation.
A managed Postgres. A single relational database will carry a surprising amount of product. Postgres is well understood, easy to reason about, and good enough for the kinds of records most MVPs actually store: users, workspaces, objects, events. "Managed" matters as much as the database. Backups, upgrades, and disk space should not be a side quest in month two.
A hosted auth provider. Login looks small from the outside: an email field, a password field, a "forgot password" link. Underneath it's session handling, reset emails, OAuth, lockouts, and a long list of ways to get it slightly wrong. We almost never build that ourselves on day one. Buy it, wire it in, and spend the time on the product. (When we would consider building it is a separate, narrower conversation — usually a real constraint, not a fear that we "might want to customize it later.")
Stripe for payments. If you need to charge, use a payment provider that already does the hard parts: cards, invoices, customer portals, tax helpers, failed payments. Pricing page experiments are product work. Card-storage PCI scope is not the work you want in the first version.
One place for logs and errors. When something breaks — and it will — you need to see it without SSHing around or asking the user to forward a screenshot. One error tracker, wired up before launch, is enough. You don't need a full observability stack. You need to know that a test error actually arrives, and that someone will look at it.
That's the list. It is boring on purpose.
What we'd deliberately skip
Microservices. Splitting a young product into a constellation of services gives you deployment complexity, network failure modes, and coordination cost, in exchange for a scaling story you probably don't need yet. A modular monolith — clear boundaries inside one app and one database — is almost always the better first shape. You can extract a service later if a part of the system truly requires it. You cannot easily put a premature distributed system back in the box.
Kubernetes. If you do not have a platform team, and you do not have a reason that a managed host or a simple container service can't cover, Kubernetes is an operations product you have accidentally started. It can be the right tool later. It is a heavy default for an MVP.
A custom design system. You need consistent color, type, spacing, and a handful of components. You do not need a 200-component library, a token platform, and a design-system department. Design-system work pays off when the product is being extended by many people at once. Before that, a short source of truth and a little discipline will do. Build the system when v2 is about to multiply the mess, not as a prologue to v1.
A native app before the web version has proven anything. If the product is a URL — accounts, payments, content, work that happens at a desk or in a tab — start on the web. A native app is a real product of its own: store review, install friction, two platforms if you're honest about iOS and Android, and a slower loop for changes. Go native when the device is the product (serious offline, Bluetooth, background location, or a store presence you actually need this month). Don't start there because a competitor has an icon.
Why boring tech is the point
In year one, the risk usually isn't that your stack can't scale. It's that nobody uses the product.
Boring tech lets you spend your energy on that uncertainty. A managed database fails in documented ways. A hosted auth provider has already met the password-reset edge cases. A single Next.js app can be understood by the next person who joins. None of that is glamorous. All of it is time you get back to talk to users, tighten the offer, and ship the small version of the feature that actually matters.
There's also a hiring and focus effect. A fashionable stack can attract interest, and it can also lock the team into tooling debates. The question we like better is: if the product gets a burst of use next month, which parts would actually hurt? Usually it's a slow query, a missing index, an unpaid image, or a signup flow that asks for too much — not the absence of a service mesh.
When this list is wrong
It depends, of course.
Regulated data can change the answer: where you host, how you store records, whether a particular vendor is allowed, what you have to log. Offline-first field work can change it: a browser tab may not be enough. Heavy real-time collaboration, serious on-device work, or a product where identity itself is the product can also justify earlier departures.
Poor connectivity, a need to ship in an app store in the first month, or a hard real-time requirement should be written down as constraints, not as vibes. Then change the stack to meet those constraints, not to meet a blog post.
What we wouldn't do is copy someone else's architecture because they are a year ahead of you, or a decade bigger. Copy their questions instead. Do people need the App Store this month? Is a shareable link part of the product? Which device APIs are truly required? What happens if this database gets ten times the rows — is that even the problem in front of you?
How to decide without a two-week architecture debate
Write the product in a sentence, including the parts that have to exist on day one: accounts, payments, file uploads, a public site, a scheduled job. Then pick the default above unless a constraint knocks something out.
Set a rule for new tools: a library can come in when it removes a concrete piece of work. A new service can come in when a measured limit, a compliance need, or a clear operational pain appears. "We might need this later" is not a reason. Later is cheaper when you have more information.
And write down what you skipped, on purpose. Future-you will be tempted to add Kubernetes on a quiet week. The note is a reminder of why you didn't.
Takeaways
- Default stack for a typical web MVP: Next.js, managed Postgres, hosted auth, Stripe if you charge, and one place for errors.
- Skip, for now: microservices, Kubernetes, a custom design system, and a native app before the web product has proven anything.
- Year-one risk is usually "nobody uses this," not "this won't scale."
- Change the list for real constraints — regulated data, offline use, device APIs, genuine real-time needs — not for aesthetics.
- Don't copy a bigger company's architecture. Copy their questions.
- Add tools when they remove a concrete problem. "We might need it later" is not that problem.
What would you swap in this list?
We're nothink, a small team that designs and builds products for startups — more at nothink.site.
Top comments (0)