The Modern SaaS Tech Stack I'd Choose in 2025

Every week, founders ask me: "What tech stack should we use for our SaaS?" After building 50+ products and seeing what actually works in production, here's my 2025 recommendation.

The Non-Negotiable Principles

Before diving into specific technologies, understand these principles:

• Boring is beautiful - Proven tech > bleeding edge
• Developer velocity matters - Fast iteration > perfect architecture
• Scale when you need to - Don't optimize for 1M users at 100 users
• Full-stack TypeScript - One language, less context switching

The Core Stack

Frontend - Next.js 14+ with App Router

Why: Next.js has become the de facto standard for React applications with good reason:

• Server Components reduce client bundle size by 30-40%
• Built-in image optimization and font loading
• Edge runtime support for global performance
• Streaming and partial pre-rendering

Alternative considered: Remix (great option, but smaller ecosystem)

UI Components - shadcn/ui + Tailwind CSS

Why: This combination gives you:

• Copy-paste components you own and can modify
• Consistent design system out of the box
• Accessibility built-in with Radix UI
• 60% faster development than custom components

What we use:

// Beautiful, accessible components in minutes
import { Button } from '@/components/ui/button'
import { Card } from '@/components/ui/card'
import { Dialog } from '@/components/ui/dialog'

Backend API - tRPC or Next.js Route Handlers

For most SaaS: Next.js Route Handlers are sufficient When you need more: tRPC for type-safe APIs

Why Route Handlers for most cases:

• No additional complexity
• Works with any frontend
• Easy to add authentication
• Simple to test and debug

Database - PostgreSQL with Prisma

Why PostgreSQL:

• Battle-tested for 30+ years
• Handles 99% of SaaS use cases
• Amazing extensions (pgvector for AI, PostGIS for location)
• Scales from 0 to Notion-size

Why Prisma:

• Type-safe database queries
• Automatic migrations
• Great developer experience
• Works with edge runtimes

Authentication - Clerk or NextAuth.js

For speed: Clerk (5 minutes to production-ready auth) For control: NextAuth.js (more configuration, more flexibility)

What Clerk gives you:

• Social logins
• Multi-factor authentication
• User management UI
• Webhooks for user events
• SOC 2 compliance out of the box

Hosting - Vercel + Neon

Why this combination:

• Vercel: Zero-config deployments, automatic scaling
• Neon: Serverless Postgres with branching for development
• Total cost at 10k MAU: ~$50/month

Alternative: Railway or Render for everything (simpler, one vendor)

The AI Layer (Because It's 2025)

LLM Integration - Vercel AI SDK

import { openai } from '@ai-sdk/openai'
import { generateText } from 'ai'

const { text } = await generateText({
  model: openai('gpt-4-turbo'),
  prompt: 'Generate a product description',
})

Vector Database - pgvector

No need for a separate vector database. PostgreSQL with pgvector handles:

• Semantic search
• RAG implementations
• Recommendation systems

AI Development - Cursor + Claude

This isn't part of your stack, but it's how you build faster:

• 60% reduction in boilerplate code time
• Instant refactoring across files
• Better error messages and debugging

The Payment Stack

Payments - Stripe

Still unmatched for:

• Developer experience
• Global coverage
• Subscription management
• Revenue recognition

Alternative - Paddle (if you want to avoid tax compliance headaches)

The Observability Stack

Analytics - PostHog

One tool for:

• Product analytics
• Session recordings
• Feature flags
• A/B testing
• Error tracking

Monitoring - Vercel Analytics + Sentry

• Vercel Analytics: Web vitals and performance
• Sentry: Error tracking and performance monitoring

The Communication Stack

Transactional Email - Resend

await resend.emails.send({
  from: 'onboarding@example.com',
  to: user.email,
  subject: 'Welcome to SaaS!',
  react: WelcomeEmail({ name: user.name }),
})

Marketing Email - ConvertKit or Loops

ConvertKit for creator-focused products with advanced automation needs. Loops for modern SaaS with a cleaner UI and better developer experience. Both handle compliance and deliverability so you don't have to.

In-app notifications - Knock or build your own

Knock gives you a complete notification system in minutes - in-app, email, SMS, and push. Building your own is feasible for simple needs but gets complex fast when you add preferences, batching, and delivery tracking.

The Testing Stack

Unit/Integration - Vitest

Faster than Jest, with native TypeScript support and compatibility with your existing test suite. Runs tests 10x faster with better error messages.

E2E - Playwright

Microsoft's answer to Cypress, but better. Cross-browser testing that actually works, with auto-wait capabilities and parallel execution out of the box.

Visual Regression - Percy (optional)

Catch unexpected UI changes before your users do. Integrates with your CI pipeline to screenshot every deployment and highlight visual differences.

The Development Workflow

Version Control - GitHub

Still the industry standard. Great Actions integration, Copilot AI assistance, and where all the open source lives. GitLab is fine too, but why swim upstream?

CI/CD - GitHub Actions + Vercel

Push to main, deploy to production. Vercel's preview deployments for every PR mean stakeholders can review changes before they ship. No more "works on my machine" problems.

Code Quality - ESLint + Prettier + Husky

Enforce consistent code style automatically. Husky runs checks before commits, preventing broken code from entering your repository. Set it up once, never think about formatting again.

What I Deliberately Leave Out

GraphQL

Unless you have multiple frontends consuming the same API, it's complexity you don't need.

Microservices

Start with a monolith. You're not Netflix.

Kubernetes

You don't need container orchestration below $1M ARR.

Redis

PostgreSQL can handle caching for most use cases.

Separate API Server

Next.js API routes scale to millions of requests.

Cost Breakdown at Different Stages

MVP Stage (0-100 users)

• Total: $0-20/month
• Vercel free tier
• Neon free tier
• Clerk free tier

Growth Stage (100-1,000 users)

• Total: $50-150/month
• Vercel Pro: $20
• Neon: $20
• Clerk: $25
• PostHog: $0 (free tier)

Scale Stage (1,000-10,000 users)

• Total: $300-800/month
• Vercel Pro: $20
• Neon Pro: $70
• Clerk: $250
• PostHog: $200
• Others: $100-200

Migration Path

As you scale, your needs change. Here's the typical evolution:

• Year 1: Stack as described above
• Year 2: Add Redis for caching, consider dedicated backend
• Year 3: Evaluate microservices for specific domains
• Year 4+: Custom solutions where needed

The Decision Framework

Choose this stack when:

• ✅ Building B2B SaaS
• ✅ Team knows React/TypeScript
• ✅ Need to move fast
• ✅ Want proven, boring technology
• ✅ Planning for under 100k users initially

Consider alternatives when:

• ❌ Building consumer social apps (consider React Native)
• ❌ Heavy real-time requirements (add Socket-io or consider Elixir)
• ❌ Complex computational needs (add Python services)
• ❌ Team expertise in other stacks

Conclusion

The best tech stack is the one that lets you ship features quickly while maintaining code quality. This stack has been battle-tested across dozens of successful SaaS products and consistently delivers.

Remember: your tech stack is a means to an end. The goal is to build something customers love, not to have the most sophisticated architecture.

Next Steps

• Start with the basics: Next.js + PostgreSQL + Tailwind
• Add complexity as needed: Don't prematurely optimize
• Measure and iterate: Use analytics to guide decisions
• Get help when needed: Consider fractional CTO support

Need help choosing or implementing your tech stack? Book a quick-win audit for personalized recommendations based on your specific needs.