The Full-Stack SaaS Architecture We Ship in 2026

We've shipped a lot of SaaS products. The stack has evolved substantially over the last few years some things we used in 2022 we'd never touch today, and some things we dismissed then are now non-negotiable. Here's what we actually use in 2026 and why.

The core: Next.js App Router

Next.js with the App Router is our default for every new web project. Server Components change the mental model significantly components that fetch their own data, no client-side waterfall for initial load, streaming with Suspense, and layouts that don't re-render on navigation.

We use the App Router for everything: marketing pages, auth flows, dashboard UI, and API routes. The route.ts convention is clean enough that we don't need a separate API server for most products.

Deployment: Vercel for most projects. It's not the cheapest option at scale, but for early-stage products the DX is unmatched preview deployments on every PR, instant rollbacks, built-in analytics.

Database: Postgres via Neon or Supabase

Postgres is the only database we reach for now. The JSON support is good enough for flexible schemas, the full-text search is usable for most apps, and the ecosystem (extensions, tooling, hosting options) is better than anything else.

For hosting: Neon for serverless (branches per PR is a killer feature each preview deployment gets its own DB branch), Supabase for anything that benefits from the built-in auth and realtime subscriptions. Both run Postgres, so migrating between them is straightforward.

ORM: Drizzle. We used Prisma for years and still use it on existing projects, but Drizzle's performance profile is better and its SQL-first API makes complex queries readable. The migration story is also simpler.

Type-safe APIs: tRPC

tRPC gives end-to-end type safety between your Next.js API layer and your React client with zero code generation. Define a procedure on the server, call it from the client, TypeScript infers the input and output types automatically.

For apps where the frontend and backend are in the same repo (the SaaS monorepo pattern), tRPC is a significant DX improvement over REST. No OpenAPI spec, no type generation step, no drift between schema and implementation.

We use tRPC over HTTP for client-side calls and RSC-compatible server callers for Server Components.

Auth: Clerk or Auth.js

Auth is one of the few things we've stopped building ourselves. The surface area for bugs is too large and the liability too high.

Clerk for most products hosted auth UI, social logins, MFA, organisations, and a generous free tier. The Next.js integration is first-class. Auth.js (formerly NextAuth) when we need self-hosted auth or more control over the session model.

Payments: Stripe

Always Stripe. The API design is excellent, the documentation is the best in the industry, and the hosted checkout covers most cases without a custom UI. We use Stripe Billing for subscription management and Stripe Connect for marketplaces.

The one thing that bites people: Stripe webhooks. Test them locally with the Stripe CLI before you ship stripe listen --forward-to localhost:3000/api/webhooks/stripe. And validate the webhook signature on every event.

Email: Resend + React Email

Resend is what Postmark was in 2018 clean API, reliable delivery, reasonable pricing. Pair it with React Email and you write email templates in React components with full TypeScript support. Preview them in the browser before sending.

Background jobs: Trigger.dev or Inngest

Serverless functions have a timeout. Anything that runs longer than 60 seconds (AI inference, bulk exports, report generation) needs a background job runner. Trigger.dev and Inngest both solve this well with a similar model: define jobs as TypeScript functions, trigger them from your app, run them reliably with retries.

Observability: Sentry + Vercel Analytics

Sentry for errors and performance monitoring. Vercel Analytics for web vitals. For logging, Axiom if the budget allows. The query interface is significantly better than Datadog at a fraction of the price.

The stack in one table

• Framework: Next.js 15 (App Router)
• Language: TypeScript (strict mode)
• Database: Postgres (Neon / Supabase)
• ORM: Drizzle
• API layer: tRPC
• Auth: Clerk
• Payments: Stripe
• Email: Resend + React Email
• Jobs: Trigger.dev
• Styling: Tailwind CSS v4
• Deployment: Vercel
• Visual QA: Prodix

This isn't the only way to build a SaaS. It's what works for us right now, in 2026, for B2B SaaS products shipping to 10–10,000 customers. Your constraints may differ. But if you're starting fresh and don't have strong opinions yet, this stack will not slow you down.