Every new project opens with the same tax: a week spent choosing the stack. Framework, database, ORM, UI, auth, hosting - a dozen decisions, each with ten defensible answers, none of which feel wrong until much later. And that's the trap: the bad call doesn't bite on day one. It bites at month twelve, when you're scaling and the thing you picked for speed is now the thing you're paying to rip out.

So here's the stack we reach for - the one that lets us go from zero to production-grade fast, without signing up for that rewrite. It's opinionated on purpose. Every layer is here because it ships quickly and holds up as you grow, and each one earns its place below. Think of it less as "our exact setup" and more as the defaults we'd hand you to skip the week of deliberation.

Framework & language: Next.js + TypeScript

One framework, front to back. Next.js gives you server and client, SSR and static rendering, routing and API routes in a single mental model - and TypeScript makes the whole thing refactor-safe.

What you get: you ship a full product with one framework and one language, on a talent pool that's easy to hire from, and it scales from a landing page to a real app without switching tools. (Why Next.js specifically - over Remix, over a separate SPA + API - is its own post, coming soon.)

Data: Postgres + Drizzle

Postgres is the boring-scalable default - the database nobody gets fired for choosing. On top of it we use Drizzle: typed SQL that stays close to the database, with real migrations and almost no magic between you and your queries.

What you get: a data layer you actually understand, fully typed end to end, that won't surprise you at scale. Tradeoff: it's more explicit than a heavier ORM - you write closer to SQL. (Drizzle deserves its own deep-dive, and a Drizzle-vs-Prisma comparison - both are on the way.)

Validation: Zod

Types vanish at runtime; Zod is how you keep the guarantees where the real world gets in - form input, API payloads, environment variables, content frontmatter. We lean on it heavily, and it pairs naturally with the rest of the stack (it validates the edges Drizzle and your content layer can't).

What you get: bad data fails loudly at the boundary instead of quietly corrupting things three layers deep. (A dedicated Zod post is coming too.)

UI: components you own + Tailwind

We don't install a black-box component kit; we use copy-in components (shadcn-style) styled with Tailwind, so the code lives in our repo and bends to the brand.

What you get: beautiful, accessible UI, fast, that looks like yours and carries zero lock-in. The full picture - the four tiers of UI libraries and when to pick each - is its own post: the UI libraries we use to ship beautiful software fast.

Typography: self-hosted Google Fonts

Type is the cheapest way to make a product feel considered - and it's free. We self-host free Google Fonts via next/font (no external request, no layout shift). Our go-to picks: Outfit for app and product UI, where clean and calm wins; Plus Jakarta Sans for marketing sites, where a bit more character carries the brand.

What you get: a distinctive, fast type system - not the reflexive default that makes a site read as AI-generated.

Content: a Git-based CMS + typed reader

When non-developers need to edit, we give them a real editing UI whose changes commit straight to Git, and read that content back through a typed reader - no hosted database, no per-seat CMS bill.

What you get: marketers own the words, engineers keep everything in version control, and there's no runtime content service to pay for or page. The how - and the trade-off against a plain build-time layer - is covered in Keystatic + the Reader API and the case for Velite.

Auth: passwordless, done right

Login is where trust is won or quietly lost. We default to passwordless - one-time codes, social SSO, passkeys where phishing is the threat - chosen for how real users on real email actually behave.

What you get: logins that work for business users, not just in the demo. The unglamorous detail that decides it (and why magic links break in B2B) is in magic links vs OTP.

Deploy: a zero-config platform

We ship on a zero-config platform (Vercel-style): push to a branch, get a preview URL; merge, and it's live - with edge delivery and no server to babysit.

What you get: you deploy on day one and scale without hiring a DevOps team. (A full post on the deploy layer is coming later - this is the short version.)

The part that actually matters

Notice what this list isn't: a pile of trendy names. Every layer is here because it does two jobs at once - ships fast today and survives tomorrow - and because the pieces compose. That composition is the point. The tools are maybe 20% of the outcome; the other 80% is the judgment to pick the ones that fit your problem and wire them together so the result is fast to build, cheap to own, and painless to scale.

That judgment - choosing the right foundation and building the right thing on top of it - is what you're really hiring for when you bring in a team like Bruvora. Start from this stack and you've skipped the week of deliberation, and most of the expensive mistakes.