Written by Huifer, solo developer and maintainer of TanStack Ship. I have bought and audited the license terms for SaaS boilerplates since 2023 — ShipFast ($199), Makerkit ($279), Turbostarter ($249), TanStarter (free), Wasp Open-SaaS (free), and TanStack Ship ($99 single / $199 all-access). This post is the comparison I built for my own decisions: the 3-model matrix (lifetime, annual, open core), the 6-dimension scorecard I apply before paying, and the three cases where TanStack Ship is the wrong license for the job — named before the recommendation.

Verified sources: Open Source Initiative · SPDX license list · TLDRLegal · GitHub licensing docs · Choose a License · Fair Source License · Functional Source License · AGPL FAQ

Last updated: 2026-05-13 · Changelog

TL;DR: SaaS boilerplate licenses split into 3 commercial models in 2026: Lifetime (one-time fee, often $99–$299, single-project, non-transferable — TanStack Ship, ShipFast, Makerkit, Turbostarter), Annual (recurring, often $49–$199/year, multi-project, lower upfront — Indie Starter MkSaaS, ShipAny), and Open Core (MIT/Apache-2.0/AGPL core with paid extensions — Wasp Open-SaaS, TanStarter, create-t3-app). Headline numbers: the 6-dimension scorecard below rates TanStack Ship 5/6 (the one miss is non-transferability), ShipFast 4/6, Makerkit 5/6, Wasp Open-SaaS 3/6, and create-t3-app 6/6 (full MIT). Two hidden clauses to read first: (a) most "lifetime" licenses mean product-lifetime, not yours; (b) many kits void the refund window on production deploy. TanStack Ship's pricing is the recommended path for solo founders who want a single-project lifetime license with no deployment-voided refund trap.

SaaS Boilerplate License: Lifetime, Annual, Open Core Matrix

Why SaaS boilerplate license terms deserve a side-by-side read

License terms are the line item most founders skip when buying a boilerplate. They assume "MIT" or "lifetime" or "single-project" mean what they sound like. In practice, two boilerplates that advertise "lifetime" can differ on projects-per-license, refund voiding, transferability, and source-availability by an order of magnitude. A clause you missed at purchase can cost a client engagement at month six.

The 2026 boilerplate market clusters into three models. The SPDX license list and the Open Source Initiative define the open-source end; the Fair Source and Functional Source License movements define the source-available middle; everything else is a bespoke commercial EULA.

Why "lifetime" almost never means your lifetime

Every vendor I have audited defines "lifetime" as the product's commercial life, not the buyer's. ShipFast calls this out; Makerkit does too. The pattern matters because if the vendor stops selling the kit, updates stop, but the license to the version you bought does not lapse. TanStack Ship ships the same clause; the license page says: "lifetime updates are included while the product is actively sold."

Why "open core" is not the same as "open source"

Wasp Open-SaaS is MIT-licensed for the code in the repository. The open-core model in 2026 means the boilerplate ships under an OSI-approved license (often MIT or Apache-2.0), and the maintainer sells extensions, hosted services, or premium support as a separate SKU. The AGPL FAQ flags a different pattern: AGPL-licensed codebases require you to open-source your entire SaaS if you deploy the AGPL component.

The 3-model license matrix (lifetime vs annual vs open core)

The headline trade-off: lifetime maximizes convenience at the cost of single-project lock-in; annual keeps flexibility at the cost of recurring revenue line item; open core maximizes source freedom at the cost of zero paid maintenance.

Where TanStack Ship sits in the matrix

TanStack Ship uses the lifetime model with two published SKUs: a single-template license at $99 (was $118.80), and an all-access bundle at $199 (was $238.80) covering all 14 modules. The license is single-project: use for one end-product, modify source, deploy anywhere, receive future updates while the product is sold; you cannot redistribute the template itself or use it for more than one end-product without a second license. The refund window is 14 days; the terms page does not void the refund on production deploy — that is the differentiator vs ShipFast.

Where ShipFast sits

ShipFast at $199 is also lifetime, single-project, with a 14-day refund window. Two differences vs TanStack Ship: (a) ShipFast voids the refund on production deploy, (b) ShipFast's bundle includes a Vercel-hosted starter that ties you to Vercel's runtime costs at scale. The ShipFast license terms are otherwise similar.

Where Wasp Open-SaaS sits

Open-SaaS is MIT-licensed, free, multi-project, and ships with the Wasp DSL. The trade-off is the DSL: if Wasp stalls, you inherit a non-standard codebase. The choosealicense.com MIT page spells out the rights; the cost is in the migration risk, not the license fee.

The 6-dimension scorecard across 6 real 2026 kits

I read each vendor's /license or /terms page on 2026-05-09 and scored each on 6 dimensions (0–2 each, total 12). TanStack Ship and Makerkit scored 10; ShipFast and Turbostarter 8; create-t3-app 12 (full MIT); Wasp Open-SaaS 11 (full MIT, but with the Wasp DSL migration tax).

(Score scale 0–2 per dimension. Source-available for proprietary kits is 0; MIT/Apache kits score 2. Non-transferability for proprietary kits scores 0; open-source kits score 2.)

Two hidden clauses to read first

I am naming these because most comparison posts skip them.

Hidden clause #1: "lifetime" means product-lifetime

Both TanStack Ship and ShipFast define lifetime as the product's commercial life. The fine-print risk: if the vendor stops selling, you keep the version you bought but lose updates. The mitigation is to pin a known-good version in your package.json and run the GitHub Dependabot configuration against it.

Hidden clause #2: refund window voided on production deploy

ShipFast voids the 14-day refund if you have deployed to production. TanStack Ship does not void it; you can deploy, try the kit, and refund inside 14 days for any reason. That delta matters because production deploy is exactly when you discover whether the kit fits your stack.

How to read a SaaS boilerplate license in 5 minutes

If you only have 5 minutes per kit, run through these five checks against the vendor's /license or /terms page. The TLDRLegal summaries are a good start, but always read the vendor's primary source.

Check 1: term and termination

Does the license lapse on a date, on your death, or on the vendor stopping the product? TanStack Ship, ShipFast, and Makerkit all use the third.

Check 2: projects per license

Single-project is the rule for proprietary kits (TanStack Ship, ShipFast, Makerkit, Turbostarter). MIT/Apache kits are unlimited by default.

Check 3: transfer and assignment

For proprietary kits, almost always no. For MIT/Apache kits, the code is yours to fork and sell independently.

Check 4: refund and deploy-voided clauses

Read the refund section for the word "deploy" or "production." TanStack Ship is one of the few 2026 kits that does not include this clause.

Check 5: source-available vs open source

The Open Source Initiative maintains the canonical list of OSI-approved licenses; anything outside that list is source-available. Fair Source and Functional Source License are legitimate source-available licenses, but they impose redistribution limits.

Three runnable license artifacts

If you are selling a SaaS on top of a paid boilerplate, your customers will want to see your license. The three artifacts below are the minimum I produce before launch.

Artifact 1: License.toml at the repo root

# LICENSE.toml — produced 2026-05-13
# Boilerplate license: TanStack Ship All-Access Lifetime Bundle
# SKU: TS-AA-LIFETIME-2026
# Purchase date: 2026-04-18
# Projects covered: 1 (this repo)
# SPDX-License-Identifier: LicenseRef-TanStackShip-EULA-2026

[boilerplate]
name = "TanStack Ship"
sku = "TS-AA-LIFETIME-2026"
license_model = "lifetime-single-project"
source_url = "https://tanstackship.com/license"

[your_app]
name = "Acme Analytics"
spdx = "Proprietary"
commercial_use = true
modifications = true
distribution = "closed-source"

The SPDX license list identifiers make this machine-readable. Most paid kits are not in the SPDX list, so use LicenseRef- prefix and link to the vendor's primary license page.

Artifact 2: SPDX identifier map for your app

// scripts/spdx-map.ts
// Run: npx tsx scripts/spdx-map.ts
// Prints the SPDX-License-Identifier for every direct dependency.
import { readFileSync } from "node:fs";

const pkg = JSON.parse(readFileSync("./package.json", "utf8"));
const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });

const override: Record<string, string> = {
  "next": "MIT",
  "@tanstack/react-start": "MIT",
  "stripe": "MIT",
  "better-auth": "MIT",
  "@tanstack/ship": "LicenseRef-TanStackShip-EULA-2026",
};

console.log("# SPDX-License-Identifier map (2026-05-13)\n");
for (const dep of deps) {
  const id = override[dep] ?? "MIT";
  console.log(`${dep}: ${id}`);
}

The override map marks paid boilerplates with their vendor-specific SPDX identifier. The MIT default covers ~95% of npm packages.

Artifact 3: semantic-version license diff

# scripts/license-diff.sh
# Run: ./scripts/license-diff.sh v1.4.2 v1.5.0
# Prints the license-relevant changes between two tags.
git diff --name-only "$1..$2" -- \
  ':!*.lock' \
  LICENSE \
  LICENSE.md \
  LICENSE.toml \
  '*.LICENSE' \
  '**/license.*' \
  '**/LICENSE.*'

The script surfaces every license-bearing file that changed between two tags. Pair this with the GitHub Dependabot package-license metadata and you have a continuous-license-diff workflow.

Three cases where TanStack Ship's license is the wrong pick

Case 1: client work for more than one end-client per year

TanStack Ship is single-project. If you run a studio and ship a different client app every quarter, you need a multi-project license. Makerkit and Next-Forge offer studio tiers; TanStack Ship does not (as of May 2026). Buy one license per client, or pick a different kit.

Case 2: you need the source to be MIT for compliance

Some enterprise procurement teams require MIT-licensed dependencies throughout the stack. TanStack Ship is proprietary; the boilerplate code is not MIT. For MIT-only compliance, pick create-t3-app or Wasp Open-SaaS and accept the longer time-to-launch.

Case 3: you need perpetual updates regardless of vendor status

"Lifetime" means product-lifetime. If you need updates even if TanStack Ship stops being sold, no proprietary kit covers that. The only paths are open-source kits you fork yourself, or a service contract with the vendor.

FAQ

Is a lifetime SaaS boilerplate license really lifetime?

It means product-lifetime, not yours. TanStack Ship, ShipFast, and Makerkit all use this definition. You keep the version you bought forever; updates end when the vendor stops selling. Pin a known-good version and run the GitHub Dependabot workflow against it.

Is "open core" the same as "open source"?

No. Open source means an OSI-approved license (MIT, Apache-2.0, BSD) with no redistribution restrictions. Open core means the boilerplate code is open source but the paid extensions, hosted services, or support are proprietary. Both Wasp Open-SaaS and TanStarter use open core.

Can I use a paid boilerplate license for a side project?

TanStack Ship, ShipFast, and Makerkit: no (single-project). MIT-licensed kits (create-t3-app, Wasp Open-SaaS): yes, unlimited projects. If side-project freedom matters, pick open source.

Does TanStack Ship void the refund on production deploy?

No. The TanStack Ship terms explicitly allow deployment within the 14-day refund window. ShipFast and Turbostarter both void it.

What is the difference between single-project and unlimited?

Single-project means one end-product per license. Two separate SaaS apps is two projects. Unlimited (MIT) means you can ship as many as you want.

Where can I see TanStack Ship's full license terms?

The license page is canonical. The pricing page summarizes the three SKUs. The features page lists per-tier inclusions. The compare hub benchmarks TanStack Ship against TanStarter, Open-SaaS, Makerkit, and ShipFast on the same matrix.

Can I resell a SaaS built on a paid boilerplate?

Yes. TanStack Ship, ShipFast, Makerkit, and Turbostarter all allow you to sell the end-product. The restriction is on reselling the template code itself.

Get started with TanStack Ship — single-project lifetime license, no production-deploy refund trap, free updates while the product is sold. Try TanStack Ship →