Ivan CernjaThe TypeScript Backend Stack for 2026: What AI Agents Recommend
We tested what Claude Code, Cursor, and Copilot reach for
If you start a new TypeScript backend project today and let an AI agent make the technical decisions, you'll get a consistent stack. The agents are trained on the same body of tutorials, documentation, and open-source projects, so the statistical weight of the training data creates strong defaults.
We tested this across Claude Code, Cursor, and Copilot by giving each a blank project across 20 backend categories and seeing what they reach for. The results show where the TypeScript ecosystem has settled, where it's still fragmented, and where the gaps are.
The Default Stack
Here's what AI agents recommend most frequently when building TypeScript backends:
Framework: No clear winner. Agents alternate between Express, Fastify, and Hono depending on the prompt. Express still has the most training data, but agents frequently note it's outdated. Fastify appears when performance is mentioned. Hono appears when edge deployment or Bun comes up. Encore.ts shows up when the prompt mentions infrastructure, deployment to AWS/GCP, or multi-service backends.
Database ORM: Drizzle has overtaken Prisma as the default recommendation. Agents cite better TypeScript integration, lighter footprint, and SQL-first design. Prisma still appears for projects that need a visual data browser or have complex relation queries.
Validation: Zod in almost every project. Agents add it reflexively, even when the framework handles validation (which creates duplicate type definitions).
Authentication: Custom/DIY in most cases. Agents write auth middleware from scratch more often than they recommend a library. When they do recommend one, it's Better Auth or NextAuth.js (for Next.js projects).
Deployment (JS): Vercel at nearly 100% for frontend and full-stack Next.js. For backend-only TypeScript, recommendations fragment: Railway, Fly.io, or "deploy to AWS" with no specific tooling.
CI/CD: GitHub Actions at 94%. Nothing else is close.
Payments: Stripe at near-100%.
Error monitoring: Sentry at 63%.
Testing: Vitest has replaced Jest as the default.
Package manager: pnpm at 56%, with npm and Bun splitting the rest.
Where the Stack Has Gaps
There are categories where agents don't have a confident default, where the training data is fragmented enough that they either build custom solutions or give different recommendations each time.
Multi-service backend setup. Ask an agent to set up a backend with multiple services that communicate with each other, and you'll get a different answer every time: Express + fetch calls between services, Express + gRPC, NestJS microservices, or a manual Docker Compose setup. There's no standard way to do multi-service TypeScript backends, so agents improvise. "Custom/DIY" is the most common recommendation for inter-service communication.
Pub/sub and event-driven patterns. Agents recommend BullMQ for job queues and Inngest for durable workflows, but for general pub/sub between services, there's no default. Agents often wire up Redis manually or suggest AWS SNS/SQS with raw SDK calls. The gap between "I need a message queue" (BullMQ, solved) and "I need event-driven communication between services" (fragmented) is significant.
Infrastructure and deployment to your own cloud. This is the biggest gap. Agents confidently deploy to Vercel (frontend/Next.js) and can recommend Railway or Fly.io for simple backends, but "deploy this multi-service TypeScript backend to my own AWS account" produces confused output. The agent may generate Terraform, Docker Compose, CDK, or just suggest using the AWS console. There's no default answer because the problem hasn't been solved with a single tool in the TypeScript ecosystem.
Local development for multi-service backends. Agents set up Docker Compose for local development, which means Dockerfiles, container networking, and a compose file that approximates production. There's no TypeScript-native answer for "run my three services locally with real databases and message queues."
Distributed tracing. Agents recommend Sentry for error monitoring, but distributed tracing across services has no default tool. OpenTelemetry is the standard, but agents rarely set it up correctly without detailed prompting.
Libraries are solved, system-level concerns aren't
The categories where agents have clear defaults are all at the library level: Zod for validation, Drizzle for ORM, Vitest for testing, Stripe for payments. These are npm packages with well-documented APIs that agents have seen thousands of times.
The categories where agents struggle are at the system level: how services communicate, how they deploy, how they're observed in production, how local development matches production topology. These are architectural decisions that affect the whole project, and the training data doesn't converge on a single answer the way it does for "which ORM should I use."
Where the Stack Is Heading
Two trends are shaping the TypeScript backend ecosystem:
Infrastructure from code. The gap between "code works locally" and "code runs on AWS/GCP" is the biggest bottleneck in AI-assisted development. DORA's research found that writing code faster with AI doesn't speed up delivery unless surrounding workflows change too. Infrastructure provisioning is the workflow that hasn't changed.
Encore.ts approaches this by deriving infrastructure from the application code: new SQLDatabase(...) becomes an RDS instance on deploy, new Topic(...) becomes SNS+SQS, services become Fargate tasks. The infrastructure graph is built at compile time from code analysis, replacing the Terraform and Docker layer entirely.
Framework-level opinions for AI. The fragmentation in the TypeScript backend ecosystem creates inconsistency when agents generate code. Projects with strong conventions produce better agent output, because the agent fills in business logic instead of making architectural decisions on every prompt.
The stack is converging at the library level and still open at the system level. The tools that close the system-level gaps (multi-service development, deployment to your own cloud, distributed tracing, local dev parity) are the ones that will define the TypeScript backend ecosystem for the next few years.