Ask ten teams what their stack is and you used to get ten religions. Lately the answers have converged to a surprising degree, not because one vendor won, but because AI features impose similar requirements on everyone. Here is the shape of the stack that keeps showing up, layer by layer, and why each piece earned its place.

The web core: typed, full stack, boring on purpose

The application layer has settled on typed languages and full stack frameworks: TypeScript with a React-based metaframework is the common case, with server-side rendering and API routes in one codebase. The reason is only partly developer preference. Types are what make AI coding assistants reliable, a model editing untyped code has no guardrails, while a typed codebase lets the compiler catch most of what the model hallucinates.

The database story is equally unfashionable and equally settled: Postgres, usually managed, often with a vector extension so embeddings live next to the rows they describe. One database that does relational, JSON and vector work removes an entire class of synchronisation bugs.

The model layer: gateway first, provider second

Mature teams no longer call a model provider directly from application code. They route every call through a gateway layer, whether a product or a couple hundred lines of their own, that provides:

  • Provider fallback when an API degrades.
  • Central logging of prompts, outputs, latency and cost.
  • Routing: cheap small models for classification and extraction, frontier models for reasoning-heavy work.
  • One place to redact secrets and personal data before they leave your infrastructure.

This is the single highest-leverage architectural decision in the new stack. It turns "which model?" from a rewrite into a config change, which matters when model pricing and quality shift every few months.

Retrieval: the new default plumbing

Almost every serious AI feature is retrieval plus generation: answer from our docs, draft from our templates, summarise this customer's history. So ingestion pipelines, chunking, embeddings and hybrid search have become standard plumbing, the way image resizing once did.

The practical lesson teams learn quickly: retrieval quality is a data hygiene problem before it is an algorithm problem. A clean, well-labelled document store with mediocre search beats state-of-the-art search over a swamp.

Background jobs and queues: where AI work really lives

Model calls are slow and occasionally fail, so the new stack leans hard on durable background jobs. User-facing requests enqueue work; workers call models with retries and timeouts; results stream back over websockets or land as notifications. Teams that try to do AI work inside the request cycle discover the hard way why queues exist.

For teams serving customers from Mauritius to Europe and beyond, this asynchronous shape has a bonus: it tolerates the latency of calling model APIs hosted continents away, which is the everyday reality for developers in this region.

Evals and observability: the new test suite

The most genuinely new layer is evaluation. AI features cannot be verified with assertions alone, so shipping teams maintain eval sets, curated inputs with graded expected outputs, and run them in CI the way they run unit tests. A prompt change that drops eval scores gets blocked like a failing build.

Alongside evals sits AI-specific observability: tracing a user complaint back to the exact prompt, retrieved context and model version that produced the bad answer. Without that trace, every incident investigation starts from zero.

What deliberately stayed old

Just as telling is what has not changed. Authentication, payments, email delivery and error tracking are still bought, not built. Deployment still converges on containers or a platform-as-a-service with preview environments. Git, CI and code review still anchor the workflow, even when much of the code is machine-drafted, in fact especially then, because review is now the main quality gate.

Advice for a small team assembling this today

Do not adopt all of it at once. The minimum credible 2026 stack is: a typed full stack framework, managed Postgres with vectors, one queue, a thin model gateway you could write yourself, and an eval set you start on day one with twenty examples. Everything else can be added when pain demands it. Stacks are earned, not installed.