Stack Full-Stack para Indie Hackers

What's in this pack (vs the side-hustle pack)

This is the stack for shipping the product itself. If ai-side-hustle-kit is about delegating marketing and research to agents (so a day-job founder can find customers in their lunch break), this pack is about delegating the code to AI tools so the product actually exists by Sunday night.

Different jobs, different picks. Side-hustle is GPT Researcher + n8n + Apify + AgenticMail — the pipeline that runs around a product. This pack is Next.js + Drizzle + Auth.js + Stripe MCP + Resend — the pipeline that is the product. You almost certainly want both eventually; this one comes first because you can't market what doesn't exist.

Every pick here earns its place by removing a week from a solo founder's build calendar. Every framework is production-ready out of the box — no "experimental, not for prod" footguns. The whole stack is wired to be readable by Claude Code / Cursor / Codex so an AI agent can scaffold features for you without inventing imaginary APIs.

Install in this order (scaffold → DB → auth → payments → deploy)

1. Next.js — the framework. Start here because every later pick assumes a Next.js app exists. App Router, Server Components, file-based routing. npx create-next-app@latest and you have a deployable repo in 60 seconds.
2. Create T3 App — opinionated typesafe Next.js starter (Next + TypeScript + Tailwind + tRPC + Drizzle/Prisma + NextAuth). Use this instead of step 1 if you'd rather have all the typesafe wiring done for you on minute one. Skip it if you want full control over the layout.
3. Tailwind CSS v4 — the styling layer. Don't argue with this in 2026. v4 dropped the PostCSS config and is faster than your build cache. Pairs natively with Next.js and every component library you'll consider.
4. Supabase — fast lane for DB + auth + storage + realtime. Hosted Postgres with row-level security, an auth server, and a JS SDK. If you don't have strong opinions about your DB layer, start here and you can skip picks #5 and #6 entirely. Free tier carries you through MVP.
5. Drizzle ORM — custom lane for when Supabase's BaaS shape doesn't fit (you want raw Postgres, complex schemas, or self-hosting). TypeScript-first, no codegen step, the SQL it generates is the SQL you wrote. Drop it on top of any Postgres (Neon, Railway, your own box).
6. Auth.js (NextAuth) — custom-lane auth that goes with Drizzle. 50+ OAuth providers, magic links, credentials, session adapters for every DB. If you skipped Supabase, this is how you get "Sign in with Google" in 20 minutes.
7. Stripe MCP — payments, exposed as MCP tools so Claude Code / Cursor / Codex can wire up checkout, subscriptions, webhooks, and customer portals without you context-switching to the Stripe dashboard. The MCP wrap is the difference between "Stripe in an afternoon" and "Stripe in a weekend."
8. Resend — transactional email API built for developers. React Email templates, dead-simple SDK, the closest thing to "npm install email" that actually works. Signup confirms, password resets, receipts — done.
9. Vercel CLI — managed deploy. vercel from a Next.js repo gives you a preview URL on every push. Free tier covers any pre-revenue MVP. The default destination for steps 1-8 unless you have a specific reason to move.
10. Kamal — self-hosted deploy when you outgrow Vercel (cost, region, compliance). Zero-downtime Docker deploys to any VPS. The escape hatch you reach for the day Vercel's bill catches your attention.

How they fit together

         npx create-next-app  (or)  Create T3 App
                          │
                          ▼
                    Next.js repo
                          │
                  Tailwind CSS v4
                  (styling layer)
                          │
            ┌─────────────┴─────────────┐
            │                           │
        FAST LANE                  CUSTOM LANE
            │                           │
        Supabase                    Drizzle ORM
  (DB + auth + storage)         (Postgres on Neon /
            │                    Railway / your box)
            │                           │
            │                       Auth.js
            │                  (OAuth + sessions)
            │                           │
            └─────────────┬─────────────┘
                          ▼
                     Stripe MCP
          (checkout, subs, webhooks via MCP)
                          │
                          ▼
                       Resend
         (signup, reset, receipt, drip emails)
                          │
            ┌─────────────┴─────────────┐
            ▼                           ▼
        Vercel CLI                   Kamal
   (managed, free tier)       (self-host on a VPS)

The two parallel lanes are the most important call you'll make this week. Supabase lane = ship faster, hand off less control, vendor lock-in is real but reversible. Drizzle + Auth.js lane = a few more hours of setup, no SDK between you and Postgres, every piece is replaceable. The lanes converge at Stripe — payments don't care which lane you took.

Tradeoffs you'll hit

• Next.js vs Nuxt vs SvelteKit — Next.js wins because (a) it's where the AI tooling is best (every Cursor rule, every Claude skill, every code agent assumes React/Next), (b) Vercel hosts it for free, (c) the hiring pool is 10x bigger when you're ready. Nuxt is the strictly-better choice if you already think in Vue. SvelteKit has the cleanest mental model but the smallest ecosystem. For a solo indie shipping fast in 2026, Next.js is the default.
• Supabase vs Drizzle + your own Postgres — Supabase is faster to ship and has a generous free tier. The cost is row-level-security debugging when policies get complex, and a hosted dependency you don't control. Drizzle + Neon (or Railway) gives you the same shape with full SQL access and easy migration off. Pick Supabase if your data model is straightforward CRUD; pick Drizzle if you already know your queries get gnarly.
• Auth.js vs Clerk vs Supabase Auth — Auth.js is free and self-hosted, but you wire your own session storage. Clerk is the polished SaaS choice (the in-pack alternative is OpenAuth if you want self-hosted Clerk-style). Supabase Auth is bundled if you took the fast lane. Don't mix two — pick one and commit.
• Vercel vs Kamal vs Fly — Vercel is the right answer until your bill crosses ~$50/mo or you need a region Vercel doesn't have. Then Kamal on a Hetzner box ($5/mo) wins on every axis except managed-DX. Don't optimize this on day one; ship on Vercel, migrate later when the numbers force it.
• Stripe MCP vs raw Stripe SDK — MCP wins if you're building features alongside Claude Code / Cursor, because the agent can call Stripe APIs directly instead of generating SDK code for you to paste. Raw SDK is fine if you're hand-writing every checkout flow. For a solo founder using AI tools, MCP cuts hours.

Common pitfalls (over-engineering for ship-by-Sunday)

• Picking the "perfect" stack instead of any stack — every hour spent comparing Drizzle vs Prisma vs Kysely is an hour not spent on the product. This pack picks for you: Drizzle if you're going custom, Supabase if you're going fast. Move on.
• Building auth from scratch "because it's just a login form" — it isn't. Email verification, password reset, session expiry, OAuth state, CSRF — Auth.js or Supabase Auth handle the 23 edge cases you haven't thought of yet. Use one.
• Setting up Stripe webhooks without ngrok or Stripe CLI — your webhook handler will silently fail in dev and you'll lose an afternoon. stripe listen --forward-to localhost:3000/api/webhooks/stripe is the first command you run when you wire payments.
• Self-hosting on day one — Kamal is in this pack because you will want it eventually, not because you should start there. Ship on Vercel, charge money, then worry about infra costs.
• Skipping email until "later" — "later" is after the user has signed up, paid, and is waiting for the receipt that's not coming. Wire Resend the same day you wire Stripe. They're a pair.
• Letting Next.js Server Actions tempt you into skipping your API layer — Server Actions are great for forms; they're a trap for anything you'll want to call from a mobile client or third party. Default to Route Handlers; reach for Server Actions only for in-page mutations.