TanStack Start is a full-stack React framework powered by TanStack Router, offering full-document SSR, streaming and type-safe server functions. Its 1.0 announcement on 13 October 2026 calls it ready for production. It builds with Vite or Rsbuild. Next.js still has the bigger ecosystem and the more mature React Server Components story, so the choice is not automatic. Below you get what Start is made of, how routing, loaders and server functions fit together, what "stable" does and doesn't settle, where it deploys, and the same small app sketched in both frameworks with a pick-by-project table.
What TanStack Start is
The official overview defines it in one line: a full-stack React framework powered by TanStack Router, with full-document SSR, streaming, server functions and client/server builds. (The homepage also pitches it for Solid, but this guide sticks to React.)
Think of it as three layers. At the bottom sits your application: components, data clients, product behaviour. In the middle sits TanStack Router, holding the route tree, URL state, loaders, links and boundaries. On top, Start adds the server layer: SSR, streaming, server functions, server routes and middleware.
That middle layer matters more than it sounds. The docs say Start relies 100% on TanStack Router for routing. If you already like the router, you already know most of the framework.
Router, Vite and the Nitro question
The overview names two dependencies: TanStack Router, and Vite or Rsbuild as the build tool. That's the official line.
Third-party write-ups add more detail, and they don't agree. MakerKit and Kanopy Labs both describe Nitro as the server layer, and TurboStarter says Vercel and Node/Docker targets go through Nitro. Build with Matija instead describes Vinxi as the bundler abstraction. The overview page doesn't mention either. My advice: treat the docs for the exact version you install as the source of truth, and treat blog posts about internals as dated snapshots (several were written while Start was still a release candidate).
Router alone, or the whole framework?
The docs are refreshingly direct here. If you know with certainty you won't need SSR, streaming, server functions, middleware or full-stack builds, use TanStack Router by itself. A client-only SPA doesn't need a server framework. Most products eventually want a server, though, and that's where Start earns its place.
The history is short. By around December 2023 the repo already had server utilities that became the first beginnings of Start, and by May 2024 a commit renamed the react-router-server package to start, per the 1.0 post. Router came first, and Start grew around it.
Routing and loaders
Tanner Linsley's account of the origin is worth reading: he wanted routes that knew which paths existed, which params they needed, which search params were valid, what loader data returned and what context was available down the tree. Types flow through the route tree, so changing one thing makes your editor tell you what else broke.
That's the pitch, and it's a good one. Anyone who has hand-typed useSearchParams results knows the pain.
The request lifecycle
The Start homepage shows what happens on a full page load. On the server:
beforeLoadruns.loaderruns.- The component renders.
- HTML streams to the browser.
Then in the browser, the HTML hydrates and client-side navigation takes over. Same route tree on both sides.
So where do you put an auth check? beforeLoad runs before the loader, which makes it the natural gate (and middleware is there for context and policy, more on that below). Data fetching belongs in the loader. The component stays a component.
What the router gives you for free
The overview lists nested routing, search params and data loading as Router features. Start adds the server half: Server Routes and API Routes for backend endpoints beside your frontend, plus middleware and context. If your app is full of filters, tables and URL state (dashboards, admin tools, search UIs), that typed search-param story is the strongest argument for Start. If it's mostly marketing pages, it matters much less.
Server functions versus Server Actions
Both let you call server code from client code without hand-writing a fetch. The philosophies differ.
Start's server functions are plain, explicit and typed. The homepage example looks like this: createServerFn({ method: 'GET' }), then .validator(projectSchema), then .handler(({ data }) => db.projects.find(data.id)). Validated request in, server-only handler, typed result out. The docs describe them as type-safe RPCs between client and server.
A small caution. That snippet is from the homepage at the time of writing, and MakerKit's October 2026 comparison notes Start's APIs change more often than Next.js's. Check the Server Functions guide for the version you're on before copying anything.
Three tools for the server boundary
The homepage splits server work into three tools:
- Server functions for type-safe calls from your own app.
- Server routes for outside callers (webhooks, third parties, mobile clients).
- Middleware for authentication, context, logging and policy.
I like that split. It forces a decision about who is calling, and that decision usually shapes the right design.
Where Server Actions fit
Next.js is the more mature option for Server Actions and RSC, per TurboStarter, which ships production starters on both frameworks. The Next.js docs say the App Router supports new React features like Server Components and uses built-in React canary releases. You get newer React features earlier, at the price of more framework-level behaviour to learn.
Caching is the sharpest contrast. TurboStarter lists "explicit server functions instead of framework-level caching" as a reason to pick Start. On the Next.js side, 16.4 (6 October 2026) recommends Cache Components, according to the same post. Neither is wrong. One gives you more built-in machinery; the other gives you fewer surprises.
Is TanStack Start production ready?
The official answer is yes. The overview carries a note that Start is stable and points release-candidate users to a migration guide. The 1.0 post, dated 13 October 2026, says it's finally stable and officially ready for production.
Two details from that post are worth weighing. First, the author says teams put Start into production through almost every stage of its development, from small projects and startups to enterprise teams and Fortune 500 companies. Second, 1.0 is described as a formal commitment to the APIs and the people building on them. That second point is the real news. Usage was already there; the promise not to rewrite your application model is new.
Why you may have read "still RC"
If you've seen older comparisons saying the docs still call it a release candidate, that's explainable. A TurboStarter post dated 9 October 2026 reported exactly that, four days before the 1.0 announcement. The current overview says stable. Dates matter with this framework, so check them on every comparison you read (including this one).
The caveats I'd actually care about
Maturity isn't only a version number. Here's what I'd weigh:
- Younger ecosystem. Fewer tutorials, fewer starter kits, fewer answers when you get stuck. Netlify's comparison (11 August 2026) is blunt that the maturity gap is real.
- RSC is experimental. The Server Components guide says the API may see refinements, it isn't enabled by default, and it needs React 19+ plus Vite 8+ or Rsbuild 2+. Don't build your architecture on it yet.
- A supply-chain incident. On 2026-05-11, between 19:20 and 19:26 UTC, an attacker published 84 malicious versions across 42
@tanstack/*packages. TanStack's postmortem says only the Router/Start repo was affected and issued an all-clear on 2026-05-15. It's a good postmortem, and it's still a reason to pin versions and use a lockfile with any fast-moving dependency.
None of that disqualifies it. It does mean a team without TypeScript confidence or time to read source will feel more friction than on Next.js.
Where you can deploy it
Start's portability claim is specific: deployment configuration changes; route authoring and server boundaries do not. The hosting guide says Start supports Vite and Rsbuild, giving flexible build outputs for different providers and runtimes.

Per TurboStarter's 9 October 2026 summary of the hosting guide, the official partners are Cloudflare, Netlify and Railway. Documented targets also include Vercel and Node/Docker (both through Nitro), Bun and Appwrite Sites. That's a wide list for a framework this young, and every host on it has a working path.
Rendering modes
The docs list several: Selective SSR, SPA Mode, Static Prerendering and Incremental Static Regeneration. One third-party review (Kanopy Labs) calls Start SSR-first and says static generation isn't a primary use case. The docs show it's supported, so I'd read that as an emphasis, not a limit. If your site is mostly static content, test the prerendering guide against your real pages before committing.
Picking a target
- Cloudflare Workers: TurboStarter reports shipping Start there and likes the small runtime.
- Netlify: supports both Start and Next.js as first-class frameworks, per its own comparison.
- Vercel: works through Nitro, and it's still the home of first-class Next.js hosting.
- Your own server: Node or Docker, same route code.
No bad option on that list. The real question is which one your team already runs.
TanStack Start vs Next.js: when to pick which
The full three-way framework comparison lives in Next.js vs Remix vs Astro, and the wider set sits in the web frameworks hub. This section stays on Start versus Next.js.
The same small app, side by side
Take a tiny app: one page behind a login, data for that page, and one server-side call. Here's how each piece maps. This is an illustrative sketch of the shape, not code taken from either project's docs.
| Piece of the app | TanStack Start | Next.js (App Router) |
|---|---|---|
| Auth-gated page | A route whose beforeLoad runs on the server first; middleware can attach the user to context | A check in the server-rendered page or layout, or proxy.ts (which replaced middleware.ts in Next.js 16) for coarse gating |
| Data for the page | A route loader, typed through the route tree | A Server Component fetching data in the component itself |
| Server-only call | createServerFn with a validator and a handler, called from the loader or a component | A Server Action or a Server Component call |
| Types across the boundary | Flow from the validator and handler through the route tree | Standard TypeScript; how far it carries depends on how you structure code |
| Caching | Decided explicitly by you | Framework-level, with Cache Components recommended since 16.4 |
The Next.js column leans on the App Router, which the Next.js docs describe as the newer router (the Pages Router is still supported and being improved). Same app, different centre of gravity: Start puts the route tree in charge, Next.js puts the server component in charge.
Pick by project
| Project | Lean towards | Why |
|---|---|---|
| SaaS dashboard with filters and tables in the URL | Start | Type-safe routing and search params |
| Content-heavy public site where RSC is central | Next.js | Mature RSC today |
| Web app sharing a backend with React Native | Next.js | TurboStarter's pick for that setup |
| Payload CMS project | Next.js | Payload runs natively inside Next.js; with Start it's a separate app consuming Payload as an API |
| Cloudflare Workers target | Start | Small runtime that deploys cleanly there |
| Vercel-first workflow | Next.js | First-class Vercel hosting |
| Team already on TanStack Router and Query | Start | Same mental model, per Netlify's guide |
| Need to hire fast, or genuinely unsure | Next.js | Bigger hiring pool and more documentation |
That last row isn't me being timid. MakerKit's advice is to default to Next.js when unsure, because of more documentation, more candidates to hire and a stable RSC implementation. I agree with it.
How I'd decide
Start with the data. If your app is a typed, URL-driven tool and your team writes strict TypeScript, Start fits naturally. If your pages are mostly content and you want RSC, Next.js fits. Then look at where it deploys and who you can hire, because those usually decide it. Netlify's guide frames the governance point fairly: Start suits teams that prefer a framework governed independently of any single host.
If you land on Next.js and need people to build it, you can hire a Next.js developer. And if you're already on it and weighing a version jump, the Next.js 16 upgrade guide covers that path (Turbopack as default bundler and the proxy.ts change are the headline items).
FAQ
Is TanStack Start free?
Yes. The overview says TanStack is 100% open source, free to use, and always will be. TanStack.com is owned by TanStack LLC, a privately held, bootstrapped company with no venture backing. Active partners provide financial support and resources.
Can I move an existing Next.js app to Start?
The Start docs include a dedicated Migrate from Next.js guide in the getting-started section, so that's the place to begin. Budget for rewriting data fetching and caching, since the two frameworks handle them differently.
Does Start only work with React?
The homepage describes it as a full-stack framework for React and Solid. This guide covers the React side, and the React docs are the ones I've linked.
Should I use it for a mostly static brochure site?
Probably not as your first choice. Start supports Static Prerendering and ISR, but third-party reviewers describe it as SSR-first, and Next.js has the deeper rendering modes plus mature RSC. A simple content site rarely needs Start's typed-routing strengths.
Start is stable as of the 13 October 2026 1.0 post, but it's younger than Next.js, its RSC support is experimental, and pinning versions is sensible. Pick it when typed routes and search params matter most to your app, and pick Next.js when ecosystem, hiring or RSC lead your list.