One of the most paralyzing decisions for a non-technical founder is picking a tech stack. The internet is full of conflicting opinions from developers who've never had to ship something in 15 days with a $6K budget. I'm going to give you the opinionated answer we've converged on after 40+ builds at V12 Labs — the complete stack, what it costs, and exactly when to swap something out.
Table of Contents
- The Core Philosophy
- Frontend: Next.js
- Database: Supabase (Postgres)
- Backend: Node.js + API Routes
- AI Layer: OpenAI or Anthropic Claude
- Hosting: Vercel + AWS
- Auth: Clerk
- Payments: Stripe
- Monitoring: Sentry
- Email: Resend
- Total Monthly Cost at Zero Scale
- When to Upgrade Each Choice
- What We Deliberately Excluded
- Ready to Build?
The Core Philosophy
Before the stack: the principle behind it. At pre-seed, the only thing that matters is shipping. Not performance at 1 million users. Not infinitely scalable architecture. Not the most technically impressive implementation. Shipping.
Every tool in this stack was chosen because it lets a small team move fast. That means managed services over self-hosted, convention over configuration, and boring reliable choices over interesting experimental ones. You can always refactor later. You can't get back the time you spent yak-shaving your infrastructure.
Frontend: Next.js
Why: Next.js gives you React with server-side rendering, API routes, and optimized deployment out of the box. It's the most widely used React framework, which means your developer (or the next one you hire) will know it. Vercel — the company behind Next.js — makes deployment trivial.
For AI products specifically, Next.js server components and API routes handle streaming responses from LLMs cleanly, which matters for any AI-powered UI.
Alternatives we've tried: Create React App (dead, effectively), Vite + React (good, but you lose the server component layer), Remix (excellent, but smaller ecosystem and steeper learning curve for most developers we work with).
When to upgrade: You basically don't need to. Next.js scales to production-grade applications. We've seen it handle millions of requests. The only reason to move away is if your specific use case has requirements that are genuinely better served by another framework.
Database: Supabase (Postgres)
Why: Supabase gives you a managed Postgres database with a generous free tier, built-in authentication, real-time subscriptions, and an auto-generated REST API. For most MVPs, you don't need to write a single line of database migration code — Supabase's dashboard handles schema management.
The free tier covers most early-stage startups completely. You're looking at 500 MB database storage, 1 GB file storage, and 50,000 monthly active users before you pay anything.
Alternatives: PlanetScale (MySQL, good for teams comfortable with that ecosystem), Neon (serverless Postgres, strong option), Firebase (good for real-time heavy apps, but the query model is different and can bite you later), MongoDB (avoid unless you have a specific document-model requirement).
When to upgrade: When your database is at 80%+ of the free tier limits consistently. Supabase Pro is $25/month — still very cheap. The architecture doesn't change; it's just a plan upgrade.
Backend: Node.js + API Routes
Why: For most AI MVPs, your backend lives inside Next.js API routes or server components. You don't need a separate backend service in the beginning. This is a meaningful simplification — one repo, one deployment, one place to debug.
When you need more (background jobs, heavy data processing, complex business logic), we add a lightweight Node.js service on AWS Lambda or a dedicated EC2 instance. Python is a strong alternative for data-heavy work, and we use it when a founder's use case requires heavy data processing or when ML libraries are in play.
When to break it out: When your API route is doing something that doesn't belong in a web server — long-running jobs, heavy computation, scheduled tasks. That's when you pull it into a separate service.
AI Layer: OpenAI or Anthropic Claude
Why both: The honest answer is that different use cases call for different models. For most conversational AI features and RAG systems, GPT-4o or Claude 3.5 Sonnet are the defaults. For structured output and instruction-following (getting the AI to return JSON reliably), Claude tends to be more consistent in our experience. For cost-sensitive high-volume use cases, we use GPT-4o Mini or Claude 3 Haiku.
LangChain: We use it selectively. For straightforward single-prompt interactions, you don't need LangChain — direct API calls are simpler and easier to debug. LangChain earns its place when you need agent orchestration, complex chains, or integrations with vector stores like Pinecone.
Pinecone: For anything RAG-based (retrieval-augmented generation — letting your AI query against a document corpus), Pinecone is our vector database of choice. The free tier covers most MVP use cases.
When to change models: When your production cost analysis shows a cheaper model performs adequately for your use case. We routinely build with GPT-4o for development and then test downgrading to Mini for cost reduction once the product is live.
Hosting: Vercel + AWS
Vercel for the Next.js frontend and API routes. Automatic deployments on git push, excellent CDN, edge functions for low-latency AI streaming. The free tier works for most MVPs in early stages; Pro is $20/month when you need more.
AWS for anything that doesn't fit Vercel — background workers, scheduled jobs, file processing, long-running tasks. We typically use Lambda for serverless functions and S3 for file storage. If a product needs a persistent server (WebSockets, for example), we use a small EC2 instance.
The combination covers 95% of what a pre-seed startup needs without overcomplicating infrastructure.
When to change: You're unlikely to need to change Vercel until significant scale. AWS is already the endgame for most companies — you grow into more of it, you don't replace it.
Auth: Clerk
Why: Auth is not your competitive advantage. Don't build it. Clerk handles user registration, login, social auth (Google, GitHub, etc.), session management, and JWT tokens. Integration with Next.js is genuinely painless — it's the smoothest auth developer experience we've used.
The free tier covers 10,000 monthly active users. That's more than enough for any MVP.
Alternatives: NextAuth.js (free, self-managed, more configuration work), Auth0 (enterprise-grade, overkill for pre-seed, expensive at scale), Supabase Auth (good if you want to stay within the Supabase ecosystem).
When to upgrade: At 10,000+ MAU you move to Clerk's Pro plan ($25/month). The code doesn't change.
Payments: Stripe
No debate here. Stripe for payments. It's the industry standard, has the best developer experience, the most complete documentation, and handles subscriptions, one-time payments, and invoicing. The integration into Next.js is well-documented and fast to implement.
Cost: 2.9% + 30¢ per transaction. No monthly fee.
When to change: Almost never. Companies with massive payment volume sometimes negotiate directly with payment processors for lower rates. That's a problem you want to have.
Monitoring: Sentry
Why: You need to know when things break before your users tell you. Sentry captures errors, tracks performance, and gives you stack traces that make debugging production issues fast. The free tier handles most MVPs.
We also add basic logging to the application itself (console.log to structured JSON in production, shipped to CloudWatch or Logtail). Sentry is for error alerting; logs are for investigation.
When to upgrade: When error volume exceeds the free tier, or when you need more sophisticated performance monitoring. Sentry's Team plan is $26/month.
Email: Resend
Why: Resend is the cleanest developer experience for transactional email. React-based email templates (yes, you write your emails in JSX), solid deliverability, and a free tier of 3,000 emails/month. For MVPs that need to send verification emails, password resets, and notifications, this covers everything.
Alternatives: SendGrid (works, worse DX), Postmark (excellent deliverability, slightly more expensive), AWS SES (extremely cheap, but you manage deliverability yourself).
Total Monthly Cost at Zero Scale
| Service | Free Tier | Paid Tier | |---|---|---| | Vercel | ✅ Free | $20/month (Pro) | | Supabase | ✅ Free | $25/month (Pro) | | Clerk | ✅ Free | $25/month (Pro) | | Sentry | ✅ Free | $26/month (Team) | | Resend | ✅ Free | $20/month | | OpenAI/Claude | Pay per use | ~$20-100/month typical | | Pinecone | ✅ Free | $70/month (Standard) | | AWS | Pay per use | ~$10-30/month (Lambda + S3) | | Total at zero scale | ~$0–$30/month | — |
At zero scale, you're looking at essentially nothing — just OpenAI/Claude API costs as you develop. A typical MVP in active development uses $20–50/month in AI API costs. That's it. The rest is free until you have real users.
When to Upgrade Each Choice
| Service | Trigger | |---|---| | Vercel Free → Pro | >100GB bandwidth or needing team features | | Supabase Free → Pro | Database at >400MB or >45,000 MAU | | Clerk Free → Pro | >10,000 MAU | | OpenAI GPT-4o → Mini | Cost analysis shows quality holds at lower model tier | | Resend Free → Paid | >3,000 emails/month | | Single Vercel → Add AWS | Need background jobs, WebSockets, or heavy processing |
None of these upgrades require architectural changes. They're plan bumps or additive services.
What We Deliberately Excluded
Docker/Kubernetes: Pre-seed overkill. You don't need container orchestration when you have Vercel and Lambda.
GraphQL: REST API routes in Next.js are simpler to build and debug. Use GraphQL when you have a genuinely complex data graph and multiple clients. Not for most MVPs.
Redis: Add it when you need caching or rate limiting at scale. Not before.
Microservices: One service. One repo. Ship the thing. You can split later when you understand what needs splitting.
Separate CMS: Next.js with markdown files or Supabase-backed content is usually sufficient. Add Contentful or Sanity when non-technical editors need to manage content regularly.
Ready to Build?
This is the stack we use at V12 Labs on almost every build. $6K flat fee, 15-day delivery, full source code ownership. You get the code, you get the architecture, you get the documentation.
Book a discovery call at v12labs.io and let's scope what you're building.