TanStack Ship Commercial: The Buying Decision for Indie SaaS

Written by Huifer, solo developer and maintainer of TanStack Ship. I maintain TanStack Ship and run five production SaaS apps on it. The commercial angle most boilerplate reviews skip: the $149 license pays back when the SaaS reaches ~12 paying customers, and the math compounds with every UTM-tagged conversion after that because the pricing engine and attribution layer are already built. This post is the buying-decision framework I use when a fellow indie founder asks whether TanStack Ship is worth the one-time price versus free or more expensive alternatives in 2026.

Verified sources: TanStack Ship pricing · Stripe pricing · Cloudflare Workers pricing · ShipFast pricing · Makerkit pricing · TanStack Ship features Last updated: 2026-06-18 · Changelog

TL;DR: TanStack Ship costs $149 once, not monthly. That is unusual in a 2026 SaaS template market where ShipFast is $199 one-time, Makerkit is $299 one-time, and Open-SaaS is free but ships fewer commercial modules. The buying decision is not "which is cheapest" — it is "which license fee pays back fastest given my roadmap". Below: the TCO formula, the 12-customer break-even rule for solo founders, a feature-fit scoring rubric, and the three trigger events that signal "buy now" versus "wait".

What "Commercial" Means in a TanStack SaaS Template

"Commercial" in 2026 SaaS template marketing usually means one of three things, and conflating them is how solo founders overpay. I have shipped enough TanStack apps on Cloudflare Workers between 2023 and 2026 to notice the pattern.

• Commercial features: Stripe webhooks, pricing engine, UTM attribution, referral credits, MRR dashboard.
• Commercial readiness: those features ship in a tested, idempotent, admin-shell-equipped form. The "I can deploy on Monday" test.
• Commercial fit: the template matches the buyer's roadmap, deployment stack, and growth model.

Most review posts stop at the first one. The buying decision lives in the second and third. TanStack Ship is built for the second; this post is a framework for evaluating the third. The architecture reasoning is covered in the TanStack-native explainer — here I focus on the dollar math.

The four commercial levers

When a founder asks me "is TanStack Ship worth it?", I score the project on four commercial levers. Every lever gets a 0–10 rating; the sum is the project-level commercial-fit score.

1. Time-to-revenue — how many days from git clone to a working Stripe checkout?
2. Cost-of-revenue — what is the monthly hosting + Stripe + email cost at 100 paying customers?
3. Growth-loop fitness — does the template ship attribution, referral credits, and A/B-able pricing?
4. Exit-option value — how portable is the data, runtime, and auth layer if I leave?

For TanStack Ship, the four scores are typically 8 / 9 / 8 / 8 because the 14 modules cover all four. For a Next.js + Vercel + Postgres starter, the same project usually lands at 7 / 5 / 6 / 6 — slower cost-of-revenue on object storage and database line items. The architecture explainer walks through the per-line-item cost comparison in detail.

Why "commercial" is a category, not a feature

Most comparison posts treat "commercial readiness" as binary. In practice it is a spectrum. A template with only a Stripe Checkout button is at level 1; one with an idempotent webhook handler is at level 2; one with a pricing engine, admin MRR dashboard, and UTM attribution is at level 4 — where TanStack Ship sits. The price gap between level 1 and level 4 is roughly $0 to $300, but the operational gap is roughly six months of a solo founder's life.

The $149 License vs Free and Premium Alternatives

The 2026 SaaS template market has three price tiers: free (Open-SaaS, Wasp, certain TanStack starters), one-time $129–$299 (TanStack Ship, ShipFast, Makerkit, Tanstarter), and SaaS subscriptions (some AI-app builders, monthly). The decision depends on what you value more: zero-day cost or zero-month cost.

The license-fee break-even formula

For an indie SaaS, the break-even formula is straightforward. The license fee pays back when the time saved covers its cost at your opportunity rate.

Break-even days = License fee / Daily revenue × Gross margin

For TanStack Ship at $149 with a $20/month plan at 80% gross margin:

Break-even = 149 / (20 × 0.8 / 30) = 149 / 0.53 ≈ 281 customer-days

That is roughly 9–10 paying customers for one month — the "12-customer test" I use in DMs: 12 customers on average lifetime pays back the $149 license. In practice, the license pays back inside the first quarter of any SaaS that reaches 25 paying customers, which most solo founders hit inside 18 months if they shipped the template. The opportunity cost of building the same 14 modules from scratch is 8–12 weekends of unpaid work; the real cost is the months of delayed MRR.

The Stripe pricing page lists $0.30 + 2.9% per transaction, so the formula already includes payment processing. Free templates cut the license fee but not the Stripe cost — and Stripe is the line item that compounds at scale.

// src/server/functions/break-even.ts
// A small calculator I keep in the admin dashboard.
import { createServerFn } from "@tanstack/start"
import { db } from "@/server/db"

export const computeBreakEven = createServerFn({ method: "POST" })
  .validator((input: { licenseFee: number; planPrice: number; grossMargin: number }) => input)
  .handler(async ({ data }) => {
    const dailyRevenue = (data.planPrice * data.grossMargin) / 30
    const breakEvenDays = Math.ceil(data.licenseFee / dailyRevenue)
    const subscriptions = await db.subscription.count({ where: { status: "active" } })
    return {
      breakEvenDays,
      activeSubscribers: subscriptions,
      paidBack: subscriptions >= data.licenseFee / data.planPrice,
    }
  })

The same Server Function pattern runs the MRR dashboard on the same subscription table. Every Stripe webhook event flows through one idempotent handler; every commercial metric is a query, not a separate pipeline. Building that yourself costs the same 8–12 weekends referenced above.

TanStack Ship vs ShipFast vs Makerkit vs Open-SaaS

The honest comparison, all priced as of June 2026:

TanStack Ship is the cheapest of the one-time licenses with the most modules, but module count is not the only variable. ShipFast's 8 modules cover the most common indie cases with cleaner checkout UI. Makerkit has a polished marketing-site component library. Open-SaaS is the right pick if you do not need referral credits or UTM attribution. Tanstarter is the right pick if your SaaS is single-tenant and does not need the admin shell. The buying decision hinges on which modules you need now.

The anchor: a single weekend of consulting work at $100/hour is $800. TanStack Ship is 19% of that. The decision is rarely about the dollar amount and almost always about the trust signal that the template will be there when the first paying customer lands.

The Three Trigger Events That Mean "Buy Now"

I keep a list of trigger events that mean the license is about to pay back faster than expected. If a founder describes two or more of these on a sales call, the deal closes itself.

Trigger 1 — A Stripe webhook is already biting you

The most common trigger: the founder is debugging a duplicate-charge bug, an idempotency failure, or a webhook signature mismatch on Cloudflare Workers. The Stripe webhook duplicate delivery writeup walks through one such incident. The license pays back the day the founder stops paying themselves in lost Sunday hours.

Trigger 2 — The first paying customer is inbound, not from your day-job network

When a customer arrives from an HN comment, a Product Hunt post, or a friend's tweet — and the founder has no idea which source drove them — the missing attribution layer costs more per month than the license fee. The dashboard that answers "for every $1 spent on HN, how much MRR returned" is not a luxury. It is the difference between scaling a paid channel and burning cash on it.

Trigger 3 — The product is moving from "free tool" to "paid SaaS"

The pivot from free to paid is when the commercial layer stops being optional. The pricing engine, the coupon system, the customer portal — none of those ship themselves. Buying the template at the pivot point is roughly 5× cheaper than buying it three pivots later, because each pivot usually changes the schema, the admin shell, and the email flow.

// src/server/functions/pricing/compute.ts
// Context-aware price calculation, the heart of the commercial layer.
import { createServerFn } from "@tanstack/start"
import { getContextPrice } from "@/server/db/pricing"

export const computePrice = createServerFn({ method: "POST" })
  .validator((input: { planId: string; couponCode?: string; referralCode?: string }) => input)
  .handler(async ({ data, context }) => {
    return getContextPrice({
      planId: data.planId,
      userId: context.session?.userId ?? null,
      couponCode: data.couponCode ?? null,
      referralCode: data.referralCode ?? null,
      utmSource: context.cookies["utm_source"] ?? null,
    })
  })

The pricing engine takes the plan, the coupon, the referral code, and the UTM source — and returns a single discounted price plus a breakdown the checkout UI renders. Stacking multiple discounts is where most hand-rolled implementations break; the engine handles it deterministically.

A Real Customer Profile From a Production App

To make the break-even math concrete, here is one of the five apps I run on TanStack Ship — anonymized as "App A".

• Plan: $19/month, $190/year.
• Customer count at 6 months: 47 paying, 8 in trial.
• MRR: $893; ARR run-rate: $10,716.
• Attribution: 41% UTM-tagged, 14% referral credits, 45% direct.
• Hosting: $5 (Workers) + $0.30 (R2, 21 GB) + $0 (D1, Resend) = $5.30/month.
• Stripe fees: $0.30 × 47 + 2.9% × $893 ≈ $40/month.
• Net contribution margin: ~95%.

The $149 license paid back in the third month. The UTM dashboard told me within the first month that one newsletter drove 22% of paying customers — which is why App A still runs that newsletter promotion seven months later.

When TanStack Ship Is the Wrong Commercial Choice

TanStack Ship is the wrong purchase if any of the following is true.

• You are pre-revenue with no roadmap: pre-revenue founders should start with Open-SaaS or a TanStack starter and upgrade when the first paying customer lands.
• You are standardized on Next.js + Vercel + Postgres: the lock-in math works in TanStack Ship's favor only if you operate on Cloudflare. Otherwise ShipFast alternatives is the right reading.
• You need a regulated workload (HIPAA, PCI-DSS Level 1, FedRAMP): check the Cloudflare compliance documentation before assuming the edge runtime is acceptable.
• You are building a content-only site: no commerce, no subscriptions — the TanStack Start docs plus a markdown CMS are enough.

I have had three refund requests in 18 months — all three were Next.js-first teams who bought without reading the runtime assumption.

The Commercial-Buy Decision Checklist

If you are an indie founder or two-person team with an idea, a Cloudflare account, and a willingness to learn TanStack Router, the decision reduces to four yes/no questions.

1. Will the SaaS have a Stripe checkout within the first 60 days?
2. Will the SaaS need at least one growth loop (UTM attribution, referral credits, or A/B pricing) within the first 90 days?
3. Are you comfortable operating inside the Cloudflare ecosystem (Workers, D1, R2, Queues)?
4. Is the SaaS targeting English, German, and Chinese-speaking customers in 2026?

Three or four "yes" answers: buy TanStack Ship this week. Two: read the features index and the pricing page, then decide. One or zero: start with a free template and revisit when the answer changes.

Closing — The 12-Customer Test

The single rule I use for any one-time SaaS template purchase: the license fee pays back when the SaaS has 12 paying customers, and the math compounds with every UTM-tagged conversion after that. A founder with a $20/month plan projecting 30 customers next quarter: trivially "yes". Projecting 3: "no".

For the full module list, see the TanStack Ship features index and the pricing page. For the architecture rationale, the TanStack-native explainer is the companion post. For the incident that convinced me to ship idempotent webhook handling, the Stripe webhook duplicate delivery writeup walks through it.

The 2026 SaaS template market is healthier than ever. The buying decision is rarely about the dollar amount; it is about the trust signal that the template will be there when the first paying customer lands.