Skip to content
Vertex Stack
Menu

Two build engagements per year

SaaS · 7 min read

The SaaS tech stack in 2026: what changes and what stays boring

Every year a new wave of frameworks promises to replace the stack. Most of the time, the right move is the opposite — pick boring tools for the load-bearing layers and reserve novelty for the edges. Here is the 2026 version of that split, with the pieces that actually changed and the ones that should stay exactly where they are.

By Adil Mir · · Updated

Choosing a SaaS stack in 2026 is less about chasing the newest framework and more about knowing which layers should change and which should remain aggressively boring. The load-bearing parts of a production SaaS — the database, the payment processor, the auth story, the job queue — reward maturity and punish novelty. The presentation layer, the AI-adjacent work, and the deployment edge are where the interesting shifts actually happened this year. The goal of this piece is to separate the two so engineering teams spend their curiosity budget where it pays off and their conservatism budget where it saves the product.

The boring parts are the point

There is a reason the term stack often implies permanence. Swapping a database in production can easily cost months of engineering time, and the payoff is rarely the speed improvement the migration promised. Swapping a payment processor is a similarly long project, and billing incidents along the way are common. The layers that touch money, identity, and persistence should be chosen once, chosen well, and then left alone. Everything else is fair game for iteration.

New versus boring, at a glance

LayerWhat's new in 2026What stays boring
FrameworkNext.js 15 App Router, React 19 server components and actionsServer-rendered pages, progressive enhancement, form POSTs
StylingTailwind 4 with the new engine and CSS-first configUtility classes, a small component layer, no runtime CSS-in-JS
DatabasePostgres extensions — pgvector, pg_cron, logical replicationPostgres itself, plus one primary and one read replica
CacheRedis 8 with a wider data-structure surfaceRedis for sessions, rate limits, and queue backing
AuthPasskeys-by-default, Clerk and NextAuth feature parityEmail + password + MFA still works and still ships
BillingHybrid usage + per-seat pricing, Stripe metered billingStripe subscriptions, webhooks, idempotency keys
JobsInngest and Trigger.dev for durable workflowsBullMQ on Redis when the workload is boring enough
DeployVercel Fluid Compute, Fly Machines, region-aware routingA single primary region, a static build, and health checks
ObservabilityOpenTelemetry everywhere, LLM traces as a first-class spanStructured logs, an error tracker, a status page

The framework and the edge

Next.js 15 is the default for greenfield SaaS work in 2026 for the same reasons it was in 2024 — good enough server rendering, a credible data-fetching story, and a deployment path that doesn't require a platform team. React 19 server components and server actions are finally stable enough that teams can reach for them without a caveat, which simplifies the pattern for forms, mutations, and progressive enhancement. The edge story has matured too. Vercel's Fluid Compute and Fly's Machines both make it cheap to colocate read-heavy workloads near users without paying for a separate edge runtime or rewriting handlers to a different mental model.

What did not change

Forms still submit. Pages still render on the server for the first paint. Progressive enhancement still wins. If a product's UX story depends on a framework feature that is less than a year old, that's a smell — not because the feature is bad, but because the framework team has not yet had enough time to settle the edge cases.

The data layer — Postgres and Redis, still

Postgres remains the answer for almost every SaaS workload. The interesting change in 2026 is that more work that used to live in a second datastore now lives inside Postgres as an extension. pgvector handles most embedding workloads up to a few million rows. pg_cron schedules recurring jobs. Logical replication feeds search, analytics, and CDC pipelines without a separate event bus for the first year of a product's life. Redis is still the cache, the session store, the rate-limit backend, and the queue substrate. The surface has widened slightly with Redis 8, but the pattern is unchanged: put it in Postgres first, move it to Redis when the read volume genuinely demands it.

// A boring rate limiter that works — Redis sliding window
// Put this in front of anything a bot can hammer: login, signup, webhook endpoints.
import { Redis } from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);
 
export async function allow(key: string, limit: number, windowMs: number) {
  const now = Date.now();
  const windowStart = now - windowMs;
  const pipeline = redis.multi();
  pipeline.zremrangebyscore(key, 0, windowStart);
  pipeline.zadd(key, now, `${now}-${Math.random()}`);
  pipeline.zcard(key);
  pipeline.pexpire(key, windowMs);
  const results = await pipeline.exec();
  const count = (results?.[2]?.[1] as number) ?? 0;
  return count <= limit;
}

Auth, billing, and the things that touch money

The auth landscape settled in 2026. Passkeys are the default path for new sign-ups on serious products, with email-plus-password retained as a fallback because real users still live on ten-year-old devices. Clerk and NextAuth reached feature parity on the things that matter — SSO, organizations, webhooks, audit logs — which means the choice is now about integration preferences and pricing, not capability gaps. Stripe remains the payment layer for most teams, with metered billing promoted from a curiosity to a default for any product that has a usage component. The boring advice still applies: idempotency keys on every write, webhooks validated with HMAC, and a state machine on the subscription row that survives out-of-order events.

Background work and durable execution

The background-jobs conversation has genuinely moved forward. Inngest and Trigger.dev are both mature enough to recommend for new work, and the choice between them comes down to where execution should happen. Inngest keeps the compute on existing infrastructure — Vercel functions, containers, Lambda — and handles the event bus, retries, and step state on its side. Trigger.dev v3 runs tasks on its own long-lived workers, which removes serverless timeout limits entirely. Either is a good answer. BullMQ on Redis is still the boring answer when the workload is a single queue, a handful of workers, and no desire for a second vendor.

Observability as the stack's nervous system

OpenTelemetry finally became the default in 2026. Every serious vendor — Datadog, Honeycomb, Grafana Cloud, Sentry — accepts OTLP out of the box, which means teams can instrument once and swap backends without rewriting the instrumentation. The practical shape of observability for a SaaS in 2026 is three layers: structured logs for retrospective debugging, traces for anything that crosses a service boundary, and a small set of product metrics that match the business dashboard. LLM calls get first-class treatment as trace spans — token counts, cache hits, and model versions all as attributes — so cost and latency regressions show up in the same place as every other performance issue.

The shiny-tech trap

Every year there is a pitch that a rewrite in the newest framework will make the product faster and the team happier. Occasionally it's true. Most of the time, the gain is a modest latency improvement on a path that was not the bottleneck, paid for with months of shipping nothing else. A good heuristic: if the pitch for a new tool is mostly about developer experience, and the product is already shipping, the tool is unlikely to be worth the migration. If the pitch is about a capability the product genuinely cannot express today, it's worth evaluating.

What a greenfield stack looks like today

  1. Next.js 15 on the App Router with React 19 server actions for mutations and forms.
  2. Tailwind 4 for styling, with a small set of shared components — buttons, inputs, dialogs — and no runtime CSS-in-JS.
  3. Postgres as the primary database, with pgvector for embeddings and a single read replica when the read volume justifies it.
  4. Redis for sessions, rate limits, and queue backing. Upstash if the team doesn't want to run it; a managed instance from the cloud provider if they do.
  5. Clerk or NextAuth for auth, with passkeys as the default and email plus password as a fallback.
  6. Stripe for billing, with metered billing wired in from day one even if the initial plan is per-seat only.
  7. Inngest for durable workflows and cron jobs; BullMQ on Redis for the simple stuff.
  8. Vercel for the web app, Fly for long-running services, and a single primary region until the product has a reason to go multi-region.
  9. OpenTelemetry everywhere, a single observability vendor, Sentry for errors, and a status page the team actually updates.

Key takeaways

  • The load-bearing layers — database, billing, auth, jobs — should be chosen for maturity, not novelty. The cost of changing them later almost always exceeds the perceived gain.
  • Postgres absorbs more work every year. Reach for a second datastore only when a measured limit forces the move.
  • OpenTelemetry is the default observability layer in 2026. Instrument once and let the backend be a swappable dependency.
  • Durable execution platforms like Inngest and Trigger.dev are worth adopting once the product has real multi-step workflows. Before that, BullMQ is enough.
  • The shiny-tech trap is the most expensive mistake a small team can make. Spend curiosity on the edges; stay boring where the product's reliability lives.

Frontend · 6 min read

Next.js 15 App Router production patterns: what's actually changed

Next.js 15 is the App Router past its awkward teenage phase. Async params, partial prerendering, a new cache model, and a Turbopack that finally ships production builds. Here is what works in production, what still hurts, and where teams keep tripping.

See it in practice: the MicroMoneyMinded case study.