Better-T-Stack vs a Paid SaaS Starter Kit: The Honest Line Items

Last updated 15 August 2026. Every claim about Better-T-Stack is taken from its README, its site and public GitHub and npm data, all linked at the bottom.

Start here: it is very good and you should probably use it

Better-T-Stack is a CLI for scaffolding end-to-end type-safe TypeScript projects. It is MIT licensed, its README promises "free and open source: forever," it has 5,636 GitHub stars and it is pulled roughly 2,476 times a week from npm.

The option matrix is the best in the ecosystem, and it is not close:

Getting that many combinations to produce a project that actually type-checks and runs is genuinely hard engineering. It also ships as a Claude Code plugin with an MCP server, so an agent can plan and generate a valid stack rather than hand-rolling boilerplate, which is a thoughtful piece of work.

If you are building a prototype, an internal tool, a portfolio project, a non-SaaS app, or anything where you want to learn the plumbing, stop reading and run bun create better-t-stack@latest. It is free, it is excellent, and nothing below argues against it.

The rest of this is for one specific reader: the person who is trying to decide whether the free CLI is enough for a SaaS they intend to charge money for.

A stack is not a product

Better-T-Stack's README states its philosophy in four lines, and the second one is the whole comparison:

Roll your own stack: you pick only the parts you need, nothing extra. Minimal templates: bare-bones scaffolds with zero bloat. Latest dependencies: always use current, stable versions by default. Free and open source: forever.

That is not a limitation being hidden. It is the design, stated plainly, and the project delivers exactly what it promises. The evidence is in the last row of the table above: the shipped examples are Todo and AI. A todo list and a chat. Those are the canonical demonstrations that the wiring works, and they are the right examples for a tool whose job is wiring.

So the honest framing is not "free tool missing features." It is:

Better-T-Stack scaffolds a stack. A SaaS starter kit scaffolds a product.

Both are scaffolders. They stop at different lines. Better-T-Stack stops when the frontend can call the backend and the backend can reach the database, type-safely, with your choice of nine frontends and six backends. That is a defensible place to stop, and it is where most scaffolders should stop.

A SaaS starter stops somewhere else: when a person can sign up, join an organization, be assigned a role, be charged monthly, receive an email about it, and be looked at by you in an admin panel when they write in confused. Everything between those two lines is the bill.

The itemised bill

Here is what sits between bun create better-t-stack@latest and a product you can charge for. Estimates assume a competent developer building each item to a standard they would put in front of a paying company, and they exclude the time spent deciding how to do it, which for several rows is larger than the implementation.

At $150 an hour, that is $42,000 to $69,750. Put your own rate on it and the number moves, but not the conclusion. Against a one-time price of $249, the comparison is not close for anyone whose time has a price.

But the hours are the boring argument, and I would rather make the interesting one.

The part that is not hours

Look at four rows in that table: multi-tenant isolation, roles and permissions, webhook idempotency, and session revocation.

They share a property that none of the other rows have. The wrong implementation passes review, works in development, and demos correctly.

A tenant filter applied in the view layer instead of the query layer works perfectly with one tenant. It works perfectly in your tests, because your fixtures have one tenant. It fails on the day your second customer's data appears in your first customer's dashboard, and that is not a bug report, it is a phone call.

A webhook handler without an idempotency key works every time you test it, because you never send the same event twice. Stripe does, on retry, and then somebody has been charged twice or granted a plan twice.

A permission check that reads the role from the session rather than re-reading it from the database works until somebody is demoted and keeps their old session.

These are not hard problems. They are problems where being wrong is invisible until it is expensive, which is a completely different risk profile from "this takes 40 hours." You cannot buy your way out of them with more hours, because you do not know you need the hours. You avoid them by starting from a foundation where somebody already made the mistake and fixed it, and where a test now exists that fails if it comes back.

That, rather than the hour count, is what a paid starter kit is actually for.

What the paid side looks like concretely

To be specific rather than abstract, here is what "already solved" means in this codebase, with the numbers read out of the test run rather than typed into a marketing file.

A coverage gate rather than a coverage badge. 141 test files, 472 tests, and four thresholds in the config:

coverage: {
  thresholds: { branches: 100, functions: 100, lines: 100, statements: 100 },
}

The error branches in the previous section are exactly what a branch-coverage gate at 100 forces you to test. That is the mechanism, not the number.

Architecture the compiler agrees with. Three lint rules make the module boundaries executable:

{
  files: ["src/modules/*/domain/**/*.{ts,tsx}"],
  rules: {
    "no-restricted-imports": ["error", { patterns: [{
      group: ["react", "react/**", "next", "next/**", "drizzle-orm", "drizzle-orm/**",
              "~/src/app/**", "~/src/presentation/**", "~/src/platform/**",
              "~/src/integrations/**", "~/src/modules/*/infrastructure/**"],
      message: "Domain may only import shared-kernel domain and same-context domain code.",
    }] }],
  },
}

You cannot put a database query in a React component. The build fails and tells you why.

Strictness with no escape hatch. strict, plus exactOptionalPropertyTypes, noUncheckedIndexedAccess, noPropertyAccessFromIndexSignature and verbatimModuleSyntax. typescript/no-explicit-any is an error, and the linter runs with denyWarnings: true, so there is no warning you can learn to ignore.

Optional features, not a fixed template. The configurator asks twelve questions and offers four extras: a store with sample products, a subscription course, a visual page builder and a visual post editor. Turning one on adds a module. Leaving it off means that code does not exist in your repository.

None of this is a criticism of Better-T-Stack. It is a description of where the two products stop.

When Better-T-Stack is the right answer

Stated properly, because a comparison that always recommends the paid option is an advertisement rather than a comparison.

Use Better-T-Stack if:

• You are prototyping, and the thing may not exist in a month.
• You are learning, and the plumbing is the point. Building auth once is a genuinely valuable education and nobody should be talked out of it.
• Your product is not a SaaS. No organizations, no subscriptions, no admin. A tool, a game, an internal dashboard, a client site.
• You already have an internal library for the boring three quarters, which many agencies and experienced teams do.
• Your stack is outside what any paid kit offers. Nuxt, Svelte, Solid, Astro, React Native, Convex, tRPC. Better-T-Stack covers all of those and no paid starter covers most of them.
• Your budget is genuinely zero. That is a legitimate constraint and there is no shame in it. Better-T-Stack is a better free option than any paid product's free tier.

Consider paying if:

• You are building one product you intend to charge companies for, with seats, roles, invoices and a security questionnaire in your future.
• You have already built organizations and billing once and remember exactly how long the boring parts took.
• You want a test gate you did not have to write, because writing a coverage suite from zero is the item nobody ever gets to.
• You want the architectural boundaries enforced rather than intended.
• Your time has a price and 280 to 465 hours of it costs more than a few hundred dollars.

They are not really competitors

The most useful thing I can tell you is that this is not a two-horse race.

Better-T-Stack is a scaffolder for any TypeScript project, across nine frontends and six backends. A SaaS starter kit is a foundation for one kind of business. The overlap is the ten minutes at the start where both of them write a project. After that they are doing different jobs.

The mistake to avoid is not "choosing the free one." It is choosing either one without knowing which of the two jobs you needed doing. A founder who scaffolds a beautiful type-safe stack and then spends six months building organizations and billing has not saved money. They have paid the bill in the currency that does not show up on an invoice.

Related reading

Frequently asked questions

Sources

• Better-T-Stack, for the product description and the install command
• create-better-t-stack on GitHub, for the README, the philosophy quoted above, the full option list, the MIT license and the star count
• create-better-t-stack on npm, for weekly download figures
• SaaSy Land documentation and the configurator, for the module list and the scaffold questions
• This repository's vite.config.ts and tsconfig.json, for the coverage thresholds, lint rules and compiler flags quoted above

Written by Piotr J. Borowiecki, who builds SaaSy Land and therefore has an obvious interest in this comparison. Figures for Better-T-Stack were read from its public repository and npm on 15 August 2026. The recommendation to use it for prototypes, learning projects and non-SaaS work is meant literally.