Back to Blog

How to Ship Your SaaS Fast in 2026 (Without Wasting Weekends on Plumbing)

By Aziz Ali••
saasindie hackership fastboilerplatetanstack start

Three weeks. That's how long it took me to set up auth, Stripe, and transactional email the first time I built a SaaS. Three weeks of pure plumbing — not a single line of actual product code shipped.

If you're building in 2026 and still wiring OAuth from scratch every project, you're burning your most valuable asset: time. Here's what actually ships fast.

The Real Time Sink Isn't Your Idea

Your idea takes an afternoon to validate. The tech setup takes your first month.

Here's what a typical "just build it from scratch" approach actually costs you:

  • Auth: 2–3 days (sessions, OAuth, refresh tokens, email verification, password reset)
  • Stripe: 2–3 days (checkout, webhooks, subscription lifecycle, failure handling)
  • Email: 1–2 days (transactional templates, deliverability config, unsubscribes)
  • Database + ORM: 1–2 days (schema, migrations, type-safe queries)
  • Deployment pipeline: 1–2 days (CI, env vars, domains, health checks)

That's 7–12 days before you've written a single feature your users will pay for. I've done this four times. It never gets faster — it just gets more frustrating because you know you've solved this before.

Pick a Stack That Doesn't Fight You

Framework choice matters more than most people admit. I've written a detailed breakdown of TanStack Start vs Next.js for SaaS — and I've landed firmly on TanStack Start.

Next.js has become a framework about itself. Server Components, App Router, client boundaries, the "use client" / "use server" dance — you spend your first week learning the paradigm instead of building your product. TanStack Start is simpler: file-based routing, server functions that behave predictably, and full TypeScript throughout without fighting the framework.

Pair it with Bun as your runtime — I covered the switch from Node.js to Bun in detail, and the cold start time difference alone justifies it — and you have a stack that stays out of your way.

Here's the architecture I run today:

graph TD
    A[TanStack Start + Bun] --> B[Better-Auth]
    A --> C[Drizzle ORM]
    A --> D[Stripe]
    A --> E[Plunk Email]
    B --> F[Sessions · OAuth · Email Magic Links]
    C --> G[Type-safe DB with zero runtime overhead]
    D --> H[Checkout · Webhooks · Subscriptions]
    E --> I[Transactional Email — self-hosted, free]
    A --> J[🚀 Ship in Days, Not Weeks]

Every piece earns its place. No magic. No vendor lock-in. No monthly SaaS bills eating your MRR before you've made any.

Auth Is a Solved Problem — Stop Re-Solving It

I wasted two weekends building a custom auth system in 2024. Sessions, bcrypt password hashing, Google OAuth, email magic links, token rotation on refresh — it's genuinely complex, and the edge cases will bite you in production.

The two common shortcuts have real tradeoffs. Clerk is polished but charges per MAU — by the time you hit 10k users you're paying $300+/month before you've even validated the business model. NextAuth is free but notoriously painful to configure and lacks first-class support for modern features like passkeys and multi-session.

Better-Auth is the option most people sleep on. It's self-hosted, fully open-source, has first-class TypeScript support, and handles everything — sessions, OAuth, email verification, multi-factor, passkeys. Here's how little code it takes in TanStack Start:

// src/lib/auth.ts
import { betterAuth } from "better-auth";
import { drizzleAdapter } from "better-auth/adapters/drizzle";
import { db } from "./db";

export const auth = betterAuth({
  database: drizzleAdapter(db, { provider: "pg" }),
  emailAndPassword: { enabled: true },
  socialProviders: {
    google: {
      clientId: process.env.GOOGLE_CLIENT_ID!,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
    },
  },
});

Sessions, OAuth, password auth — all working. No per-MAU billing. No weekend debugging. That's the whole setup.

Stripe Webhooks Don't Have to Be a Nightmare

Everyone knows the Stripe integration pain. Checkout takes two hours. Webhooks take two days — because to manage subscriptions reliably you need to handle checkout.session.completed, customer.subscription.updated, customer.subscription.deleted, invoice.payment_failed, and a handful of other events or you'll have users who paid but can't access features.

I have a full guide on Stripe webhooks in TanStack Start if you want the deep dive. The short version: verify the webhook signature, switch on event type, update your DB via Drizzle.

// src/routes/api/stripe-webhook.ts
export const APIRoute = createAPIFileRoute('/api/stripe-webhook')({
  POST: async ({ request }) => {
    const sig = request.headers.get('stripe-signature')!;
    const body = await request.text();
    
    const event = stripe.webhooks.constructEvent(
      body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET!
    );

    switch (event.type) {
      case 'checkout.session.completed':
        await db.update(users)
          .set({ plan: 'pro', stripeCustomerId: event.data.object.customer as string })
          .where(eq(users.id, event.data.object.metadata!.userId));
        break;

      case 'customer.subscription.deleted':
        await db.update(users)
          .set({ plan: 'free' })
          .where(eq(users.stripeCustomerId, event.data.object.customer as string));
        break;
    }

    return new Response('ok');
  },
});

Real code. Not pseudo-code. This pattern runs in production.

What "Ship Fast" Actually Looks Like

The goal isn't to build faster — it's to reach the only thing that matters faster: real users on a working product generating real signal.

Here's the timeline that's genuinely achievable when you solve infrastructure once:

Day What You're Doing
1 Idea validation, landing page live
2–3 Working auth + DB schema
4–5 Core product feature #1
6–7 Stripe checkout + payment flow wired
8–10 Beta invites to first 10 users
14 First paying customer

Two weeks from idea to revenue. Not two months.

This only works if you're not spending days 2–7 rebuilding infrastructure. That means either: (a) build it once yourself and save it as your personal boilerplate, or (b) buy a well-made starter that's already wired.

If you want to skip all of this, BetterStarter ships with Better-Auth, Drizzle ORM, Stripe subscriptions and webhooks, Plunk for transactional email, shadcn/ui, and TanStack Start — all pre-wired and production-ready. $99 one-time. Clone, set env vars, ship your product.

FAQ

How long does it actually take to build a SaaS from scratch in 2026? If you're wiring auth, payments, and email yourself, expect 3–6 weeks before writing your first product feature. With a solid boilerplate, you can be in product code within 1–2 days. The infrastructure problem is solved — stop re-solving it.

What's the fastest tech stack for SaaS in 2026? TanStack Start + Bun + Better-Auth + Drizzle ORM + Stripe is my current recommendation. Fully typed, fast runtime, simpler mental model than Next.js App Router, and no vendor lock-in on any layer.

Should I build auth from scratch or use a library? Use a library. Better-Auth is self-hosted, free, and handles every auth pattern you'll need. Building auth yourself is a great learning exercise and a terrible business decision when you're trying to ship.

Is $99 for a SaaS boilerplate worth it? If it saves two weeks of setup — and it will — absolutely. Two weeks of your time costs far more than $99. The real cost is the opportunity cost of not getting to users sooner.

Do I need Next.js to ship a SaaS fast? No. Next.js is the default, not the best option. TanStack Start gives you full-stack TypeScript with a simpler model and better performance on Bun. The ecosystem is smaller but growing fast, and you won't spend a week fighting RSC boundaries.