Written by Huifer, solo developer and maintainer of TanStack Ship. I have shipped 3 SaaS apps as a solo founder in the last 18 months — PlanTier (B2B pricing pages), QuotedReply (cold-outreach reply assistant), and MicrosaasBench (a public leaderboard). Collective MRR crossed $2,000 in March 2026. None required me to write auth, billing, email, deploy, or cron glue, because TanStack Ship is built around that skip-list. This post is the field notes: the 9 modules I stopped building by hand, the hidden cost of each, honest tradeoffs vs ShipFast, Makerkit, and Open SaaS, and the cases where I would not pick Ship as a solo founder.

Verified sources: TanStack Start · Cloudflare Workers pricing · Cloudflare D1 · Cloudflare R2 pricing · Stripe subscriptions · Stripe webhooks · Better Auth · Resend · Drizzle ORM · PostHog Cloudflare

Last updated: 2026-05-19 · Changelog

TanStack Ship for Solo Founders: 9 Things You Skip Building

TL;DR: I have shipped 3 SaaS apps solo in 18 months on TanStack Ship — collective $2,000 MRR by March 2026, hosting bill $8–$14/mo at current traffic. The 9 modules I never write by hand anymore: auth, database, billing, transactional email, object storage, cron, analytics, AI gateway, deploy + observability. Honest tradeoffs vs ShipFast (community), Makerkit (UI), and Open SaaS (price) below — plus the cost math at 100 / 1k / 10k paying users and the 3 cases where I would still pick a different stack.

Why "I'll just build it myself" is the most expensive decision a solo founder makes

Solo founders hear "don't waste money on SaaS" and overcorrect into "I should build everything." That math only works if your time is worth $0 and your weekend supply is infinite. For most solo founders I have talked to in 2026, including myself, neither is true.

Time is the only resource you cannot buy back

A solo founder has ~30 productive hours a week once you subtract the day job and the sleep debt. Every hour spent wiring Better Auth or debugging a Stripe webhook is an hour you are not spending on the only thing that compounds — the product surface customers pay for. The 9 modules below are not "work" — they are substitution. The work is what the customer sees.

Context-switching has a measurable tax

The cost is not just the wiring time. It is the 25 minutes you lose re-loading the relevant docs each time you come back to a module you wired once and forgot. Across 3 products and 18 months, my calendar shows that I touch each of the 9 modules below at most twice per year — they are wired once and never reopened. The DIY version forces me to re-derive them on every project.

Maintenance compounds faster than you think

A solo founder who hand-wired Stripe on product 1 has to re-debug it on product 2 when Stripe ships a new API version. Then on product 3. The cost compounds per product; the savings of skipping it scale linearly. That is the economics of a boilerplate: the modules are amortized across the products you actually ship.

The 9 modules TanStack Ship removes from your solo-founder plate

Below is the skip list. For each module I cover what it does, what DIY actually costs, and the one gotcha that bites solo founders hardest. The full module spec lives on the features page; pricing is on the pricing page.

#1 — Authentication (Better Auth module)

Better Auth ships Google OAuth, GitHub OAuth, and email magic-link out of the box, with the JWT cookie session that works correctly on the Cloudflare Workers edge runtime. What DIY costs: 6–10 hours the first time, plus the edge-session race in the postmortem that costs another 4 hours at 2am.

// src/lib/auth.ts
import { betterAuth } from "better-auth";
import { magicLink } from "better-auth/plugins";

export const auth = betterAuth({
  database: context.env.DB, // D1 binding
  emailAndPassword: { enabled: true, requireEmailVerification: true },
  plugins: [
    magicLink({
      sendMagicLink: async ({ email, url }) => {
        await context.env.RESEND_API.emails.send({
          from: "[email protected]",
          to: email,
          subject: "Sign in to PlanTier",
          html: `<a href="${url}">Click to sign in</a>`,
        });
      },
    }),
  ],
  socialProviders: {
    google: {
      clientId: context.env.GOOGLE_CLIENT_ID,
      clientSecret: context.env.GOOGLE_CLIENT_SECRET,
    },
  },
});

#2 — Database schema and migrations (D1 + Drizzle)

D1 is SQLite at the edge, and Drizzle is the TypeScript schema layer. What DIY costs: 2–3 hours for the schema, another 2 hours for migrations, plus the type-safety work if you skip Drizzle. The skip buys you a typed schema that survives across 3 products.

// src/db/schema.ts
import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";

export const users = sqliteTable("users", {
  id: text("id").primaryKey(),
  email: text("email").notNull().unique(),
  stripeCustomerId: text("stripe_customer_id"),
  plan: text("plan").notNull().default("free"),
  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
});

export const projects = sqliteTable("projects", {
  id: text("id").primaryKey(),
  userId: text("user_id").notNull().references(() => users.id),
  name: text("name").notNull(),
  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
});

#3 — Billing and subscriptions (Stripe)

Stripe subscriptions ship as a server function plus a webhook route. What DIY costs: 8 hours the first time, including the customer-portal redirect, the trial-day logic, and signature verification. The skip: a verified route that survives Stripe API upgrades because it pins a specific API version.

// src/routes/api/stripe/webhook.ts
import Stripe from "stripe";

const stripe = new Stripe(context.env.STRIPE_SECRET_KEY, {
  apiVersion: "2024-06-20",
});

export async function POST({ request, context }: APIContext) {
  const sig = request.headers.get("stripe-signature")!;
  const body = await request.text();

  const event = await stripe.webhooks.constructEventAsync(
    body,
    sig,
    context.env.STRIPE_WEBHOOK_SECRET,
  );

  if (event.type === "customer.subscription.created") {
    const sub = event.data.object as Stripe.Subscription;
    await context.env.DB.prepare(
      "UPDATE users SET plan = ?, stripe_customer_id = ? WHERE id = ?"
    )
      .bind(sub.items.data[0].price.id, sub.customer as string, sub.metadata.userId)
      .run();
  }

  return new Response("ok", { status: 200 });
}

#4 — Transactional email (Resend)

Resend sends welcome, password-reset, receipt, and subscription-canceled emails. What DIY costs: 2 hours to wire plus a half-day on SPF/DKIM/DMARC once Gmail starts filtering you to spam. The skip: a verified sending domain configuration and the @resend/cloudflare SDK.

#5 — Object storage and uploads (Cloudflare R2)

R2 is S3-compatible storage with zero egress fees. What DIY costs: 4–6 hours the first time, including the signed-URL handler and the CORS configuration. The skip: a presigned-URL handler that POSTs to R2 directly from the browser.

#6 — Cron and scheduled jobs (Workers Cron Triggers)

Workers Cron Triggers run scheduled jobs on a cron expression. What DIY costs: 2 hours plus the "did this cron actually run" debugging when it silently fails. The skip: a single-instance cron handler with the right idempotency keys.

#7 — Analytics and product telemetry (PostHog)

PostHog's Cloudflare Workers integration wires up event tracking and session replay. What DIY costs: build-your-own analytics is a 20-hour trap. The skip: PostHog's free tier covers 1M events/month — enough for the first 1,000 paying users.

#8 — AI gateway and embeddings (Workers AI + Vectorize)

QuotedReply uses Workers AI for inference and Vectorize for embeddings. What DIY costs: a separate OpenAI bill plus a hand-rolled embedding pipeline. The skip: a unified gateway that routes between Workers AI (cheap), OpenAI (good), and Anthropic (great) with one config change.

#9 — Deploy, observability, and rollback (wrangler + Workers Logs)

wrangler is the deploy CLI; Workers Logs is the observability layer. What DIY costs: every solo founder who hand-rolled a deploy script has the "I deployed and broke prod on a Friday" story. The skip: pnpm run deploy → 30-second global rollout → one-command rollback via the Cloudflare dashboard.

Where other solo-founder boilerplates win, honestly

I have shipped or tested 4 solo-founder boilerplates. Each wins on a different axis.

ShipFast — wins on community

ShipFast has the largest founder Discord. If your MVP depends on a niche integration — Plaid, Twilio, Linear API — the Discord has a thread from someone who wired it. Where TanStack Ship pulls ahead: cold-start latency on edge AI. ShipFast is Vercel-first; the cold start shows up in the first second of every chat completion.

Makerkit — wins on UI polish

Makerkit ships the most polished UI for solo founders. For B2C MVPs where UI is the conversion lever, the shadcn/ui theming saves 2 design days. Where TanStack Ship pulls ahead: Cloudflare-native AI bindings and the deploy observability Makerkit does not ship.

Open SaaS — wins on free + MIT

Open SaaS is the highest-quality free + MIT-licensed boilerplate. If the budget is $0 and you must defend the choice to investors, Open SaaS is the safe pick. Where TanStack Ship pulls ahead: the AI gateway and the Drizzle schema layer that Open SaaAS hand-waves. For the side-by-side decision table, see the comparison hub.

When TanStack Ship is the wrong pick for a solo founder

When you need mobile-first

TanStack Ship is web-first. The shadcn/ui components are desktop-class. If your MVP needs a React Native or Expo shell, TanStack Ship is the wrong starting point. Pick a mobile-first boilerplate or budget a week for the Expo integration.

When your future employer is Vercel-mandated

If your runway plan is "join a Vercel-shop after this MVP," you are buying yourself optionality by shipping on Vercel. The Next.js App Router experience transfers cleanly; the TanStack Start experience does not. Be honest about which skill you are buying.

When you want to learn the layers, not skip them

If the goal of the project is to learn Stripe webhooks end-to-end — a legitimate learning goal — then skipping the wiring is the wrong choice. A solo founder in learning mode should hand-wire at least one of the 9 modules. A solo founder in shipping mode should skip all 9. Pick the mode before you pick the boilerplate.

The cost math, solo-founder edition

Below is the line-item cost at three scaling tiers. All costs assume the Cloudflare Workers free tier where it applies.

At 100 paying users

At 1,000 paying users

At 10,000 paying users

The cost math is the reason to skip — every module you wire yourself costs more in solo-founder hours than it saves in boilerplate fees, at every tier.

FAQ

Is TanStack Ship worth it for a solo founder with zero users?

Yes, but only if your time is worth more than $0/hr and you intend to ship. If you are at the "I have an idea and a notebook" stage, a free boilerplate like Open SaaS is the right pick. If you have 5 paying customers and a roadmap, Ship is the right pick.

How does TanStack Ship compare to ShipFast for a solo founder?

ShipFast has more community and a larger template library. TanStack Ship has Cloudflare-native depth and the AI gateway. For a web SaaS, see vs-shipfast. For an AI SaaS specifically, Ship pulls ahead on cold-start and Workers AI bindings.

Can I really skip auth and billing as a solo founder?

Auth — yes, skip it. Better Auth is verified on Cloudflare Workers edge runtime and saves the edge-session race in the auth postmortem. Billing — yes, skip the wiring, but you still own pricing. Pricing is product work; the webhook is plumbing.

What about the maintenance burden of using a boilerplate?

Boilerplate maintenance is real but bounded. TanStack Ship ships pinned dependency versions and a changelog for every breaking change. The solo-founder burden is reading the changelog before each upgrade — about 15 minutes per quarter.

How long does it take to ship a solo SaaS with TanStack Ship?

PlanTier shipped in 14 days, solo, ~10 hours/week. QuotedReply in 21 days. MicrosaasBench in 7 days. The bottleneck was always the customer-facing surface, never the 9 modules.

Next step: See the features page for the 9-module spec, the pricing page for tier breakdowns, or the comparison hub for the side-by-side matrix vs ShipFast, Makerkit, and Open SaaS. For the micro-SaaS cost math, see TanStack Ship for Micro-SaaS. For the 48-hour MVP sprint, see TanStack Ship for MVPs.