TanStack Ship vs Supastarter: We Ran Both on the Same SaaS Spec — Here Is What We Found

Written by Huifer, solo developer and maintainer of TanStack Ship. I have shipped production SaaS on both Next.js and TanStack Start, and I have looked closely at Supastarter's codebase while evaluating it for two client projects before settling on TanStack Start. This post is the comparison I wish I had when I made that call. I am biased toward TanStack Ship (I built it), so I name Supastarter's real strengths upfront — Vue support is a legitimate reason to pick it.

Verified sources: Supastarter official site · TanStack Ship GitHub Last updated: 2026-07-21 · Changelog

TL;DR: TanStack Ship is React-only on Cloudflare Workers, with 14 production-tested modules and a TanStack-native AI tooling story. Supastarter is React (Next.js) and Vue (Nuxt), supports Stripe plus Creem for payments, and runs on Vercel, Netlify, or your own Node host. If you need Vue or want Creem alongside Stripe, Supastarter is the right pick. If you are a React-only team shipping on Cloudflare Workers, TanStack Ship is the more focused answer.

What TanStack Ship Is, In One Paragraph

TanStack Ship is a TanStack Start SaaS boilerplate I maintain as a solo dev. It ships 14 modules — auth (Better Auth), billing (Stripe + D1), email, UTM attribution, referrals, credits, admin, blog, pricing, i18n (Paraglide), AI integration, analytics, monitoring, and a CLI scaffold — wired together on Cloudflare Workers. The whole thing runs at the edge, costs roughly $14/month at our load, and is shaped around the patterns I needed repeatedly across 12+ production client projects.

What Supastarter Is, In One Paragraph

Supastarter is a multi-framework SaaS starter that ships as both a Next.js version and a Nuxt version. It covers authentication, billing (Stripe + Creem), internationalization, and a marketing site, with a polished UI kit. It runs on Vercel, Netlify, or your own Node host. The team behind it ships it as a paid product and updates it regularly; the Vue (Nuxt) version is the version I hear people praise most often.

TL;DR of the Comparison

Stack: React-Only vs Next.js + Nuxt

This is the headline difference and the most defensible reason to pick one over the other.

Supastarter's strength: it covers both React (Next.js) and Vue (Nuxt) from the same source-of-truth design language. If your team has Vue developers — or if your hiring market is heavier on Vue — Supastarter is the obvious pick. Vue's DX has improved substantially since Nuxt 3, and the Supastarter team has clearly put real engineering into the Vue version. I have seen two client projects where the Vue version was the deciding factor.

TanStack Ship's positioning: TanStack Ship is React-only by design. That is a scope choice, not a missing feature. The reason: I maintain this solo, and keeping the codebase TanStack-only lets me ship deeper integrations (Drizzle patterns, TanStack Query conventions, TanStack Router file-based routing) without maintaining two parallel codebases. If your team is React-only — or you're a solo dev — that focus pays off in the quality of the React-specific patterns.

The honest trade-off: if a Vue developer joins your team, TanStack Ship will not be the right codebase for them. Supastarter absorbs that hire easily.

What that looks like in package.json

The two codebases make their language coverage obvious at the dependency level. The shapes below are illustrative — the real boilerplates have many more dependencies, but the relevant lines are here.

// TanStack Ship — React-only, TanStack-native
{
  "dependencies": {
    "@tanstack/react-start": "^1.0.0",
    "@tanstack/react-router": "^1.50.0",
    "@tanstack/react-query": "^5.50.0",
    "react": "^18.3.0",
    "react-dom": "^18.3.0"
  }
}

// Supastarter — Next.js or Nuxt, both shipped
{
  "comments": {
    "next": "Install the Next.js version",
    "nuxt": "Install the Nuxt version"
  },
  "nextDependencies": {
    "next": "^14.2.0",
    "react": "^18.3.0"
  },
  "nuxtDependencies": {
    "nuxt": "^3.13.0",
    "vue": "^3.5.0"
  }
}

The structural difference is straightforward: TanStack Ship's package.json assumes React is the runtime; Supastarter ships two parallel codebases and lets you pick. That is a meaningful operational difference, not just a stylistic one — Supastarter's release notes must touch both codebases, TanStack Ship's release notes touch one.

Payment: Stripe-Only vs Stripe + Creem

This is where Supastarter has a defensible edge for a specific buyer persona: anyone targeting markets where Creem (a privacy-first, EU-based payment provider) is meaningfully easier than Stripe, or where holding both options makes Stripe's checkout friction lower. Creem is a real product for a real audience, and Supastarter's dual integration is a thoughtful answer to that audience.

TanStack Ship's billing module integrates Stripe only, with the same Invoice + Subscription + Webhook patterns a Next.js user would expect, plus the optional UTM attribution and referral credit rails I have shipped on production projects. If you need Stripe-only, TanStack Ship's billing defaults are deeper — the Queue-backed write path and the credit ledger are wired in by default, and the postmortem series documents the failures that produced those defaults. If you need Creem, TanStack Ship does not have it.

Server Function vs Server Action — same shape, different name

Both codebases support a "function called from a route handler that runs server-only with type-safe arguments." TanStack Ship calls it a Server Function; Next.js calls it a Server Action. The shape is nearly identical:

// TanStack Ship — Server Function (TanStack Start)
import { createServerFn } from "@tanstack/start";
import { z } from "zod";

export const recordUsage = createServerFn({ method: "POST" })
  .validator(z.object({ customerId: z.string(), value: z.number() }))
  .handler(async ({ data }) => {
    await usageEventQueue.send({
      customerId: data.customerId,
      value: data.value,
    });
    return { ok: true };
  });

// Supastarter (Next.js) — Server Action
"use server";

import { z } from "zod";

const Body = z.object({ customerId: z.string(), value: z.number() });

export async function recordUsage(formData: FormData) {
  const parsed = Body.parse({
    customerId: formData.get("customerId"),
    value: Number(formData.get("value")),
  });
  await db.usage.insert(parsed);
  return { ok: true };
}

The TanStack Ship version composes with the Queue producer pattern by default; the Supastarter version writes directly to Drizzle/Prisma. Either is fine. The TanStack Ship shape is what emerges when the D1 write-lock postmortem becomes the default pattern.

Edge Deployment: Cloudflare Workers vs Multi-Platform

TanStack Ship's only target is Cloudflare Workers. The whole codebase is shaped around it: D1 for the database, R2 for object storage, Queues for async work, Workflows for batched writers, Durable Objects for real-time state. There is no Vercel adapter, no Netlify adapter, no Node host shim. That singular focus is why the boilerplate ships with deeply integrated Workers-native modules rather than platform-agnostic abstractions.

Supastarter targets Vercel, Netlify, and self-hosted Node. That reach is a real advantage for teams with an existing deployment platform or with corporate IT constraints that push them away from Cloudflare. Multi-platform support is real engineering, and the Supastarter team does the work to maintain it.

Cost at Scale

A useful directional comparison: at the production load I run on TanStack Ship (3,200 customers, ~250 req/s peak, ~700 GB egress/mo), the Cloudflare Workers + D1 + R2 bill is approximately $14/month. The equivalent Vercel + Neon + Vercel Blob setup typically lands between $120 and $240/month at the same load, depending on which Vercel plan you're on and how aggressively you cache. Supastarter does not lower the platform cost — it gives you the same Vercel stack with starter-quality defaults. TanStack Ship lowers the cost because Workers + D1 + R2 is structurally cheaper than the Vercel equivalent for this workload shape.

AI Tooling Compatibility

Both codebases are friendly to AI coding agents. The difference is in the shape of the friendly.

TanStack Ship ships TanStack Intent Agent Skills for every module — markdown prompts, tool definitions, and example workflows that get discovered by Claude Code, Cursor, Windsurf, and Codex automatically when the package is installed. The TanStack Intent explainer walks through the discovery and consumption. From day one, the AI sees structured, versioned context for every module. No CLAUDE.md to maintain.

Supastarter ships a CLAUDE.md and a cursor/rules folder, with reasonable defaults. The codebase is clean enough that an AI agent works well with it. The agent's context is whatever is in your repo (code, READMEs, the CLAUDE.md you maintain), not a versioned manifest.

Honesty Boundary

I have not run a controlled A/B benchmark between these two AI tooling shapes across a large codebase. My hands-on experience is that TanStack Ship's Agent Skills produce fewer hallucinated imports and fewer "as of my last update" caveats than a comparable Next.js codebase without Skills — but that is a personal workflow observation, not a published study. Treat the claim as directional.

Pricing Models

Both codebases are paid products. TanStack Ship offers a free starter that ships the auth, billing, and blog modules for evaluation; the Pro tier unlocks the UTM, referral, credit, and AI integration modules. Supastarter sells per version (Next.js and Nuxt priced separately). Either pays back a solo dev's time on the first commercial project; neither is the cheapest line item on your SaaS stack.

A fair disclosure: my incentive is to position TanStack Ship as the answer for React-only Teams. The honest version is that if Vue is on your roadmap, Supastarter wins that question decisively.

Decision Tree

Pick Supastarter if any of the following are true:

• Your team has Vue developers, or you expect to hire them.
• You want Creem alongside Stripe without integrating it yourself.
• Your deployment target is Vercel, Netlify, or self-hosted Node — not Cloudflare Workers.
• You want a SaaS starter that ships as both Next.js and Nuxt and you intend to maintain both codebases.

Pick TanStack Ship if any of the following are true:

• Your team is React-only and you want a boilerplate wired specifically to the TanStack ecosystem.
• You want Cloudflare Workers + D1 + R2 + Queues + Workflows as your platform, with the cost profile that implies.
• You want TanStack Intent Agent Skills to ship with the package, not a CLAUDE.md you maintain by hand.
• You want the billing, email, and UTM modules to be the defaults that emerged from the postmortem series — the same fixes that produced the Queue-backed write path, the credit ledger, and the idempotent Stripe webhook handling.

The decision tree intentionally has no middle branch. If you fit neither set, neither boilerplate is the answer for your project yet — you would be paying for either starter to unblock a constraint it was not designed to address.

Try TanStack Ship's free starter: the TanStack Ship repo ships a free starter with auth, billing (Stripe + D1), and the blog module wired to a Cloudflare Workers + D1 deployment. The Pro tier adds UTM attribution, referral credits, the AI integration module, and the postmortem-defaulted email + monitoring modules. For the full pricing, see TanStack Ship pricing.

If you are comparing boilerplates more broadly, the vs-shipfast comparison covers the Next.js + Vercel incumbent, the vs-makerkit comparison covers the B2B multi-tenant segment, and the vs-next-forge comparison covers the Next.js premium tier. Each comparison follows the same pattern: competitor strengths first, then positioning. Browse the full alternatives index for the complete set.