When the React ecosystem pivoted to React Server Components (RSC) a few years back, plenty of us felt a bit dizzy. On paper, the pitch sounded great: render heavy pieces right on the server, stop shipping megabytes of dependencies to the browser, and pull database rows straight inside your components without extra API endpoints.
In practice, though, day-to-day development quickly turned into an obstacle course. Pass a callback across a 'use client' boundary by accident, and the bundler greets you with a wall of cryptic serialization errors. Open the Network tab in DevTools to inspect what came back from the backend, and instead of clean JSON you get a soup of internal virtual DOM stream chunks. Add tight coupling to a specific cloud provider's platform servers, and the joy of building for the web starts fading fast.
That is why the first stable release of TanStack Start 1.0—arriving after a year of public Release Candidate testing—feels like a breath of fresh air for the frontend community. Tanner Linsley and the TanStack team swam against the current and made a bold engineering call: drop mandatory RSC entirely in favor of a transparent, battle-tested architecture.
Walking Away From Server Components
The most intriguing part of this release happened behind the scenes. Early on, during the first alpha builds, the TanStack team genuinely tried to implement full React Server Components support. Tanner Linsley openly admitted that at one point RSC felt like a formal "entry ticket"—without it, the community and larger companies might not take a new meta-framework seriously.
As the spec grew more complex, however, the developers realized it was a dead end. Keeping RSC stable meant piling on gnarly compiler workarounds, breaking the familiar hook lifecycle model, and sacrificing debugging clarity. So the team made a radical call: they didn't just rip RSC out of TanStack Start's core—they also rewrote their own official portal, tanstack.com, without server components.
Without that extra layer, the site became faster, more predictable, and far easier to maintain. We already touched on that philosophy in our earlier piece on the TanStack Start 1.0 release, and now this declaration of independence is locked in as a stable major release.
Architectural Foundation: Router, RPC, and Nitro
So how does TanStack Start work under the hood without server components? The model is refreshingly honest and straightforward—you don't need a PhD in Computer Science to follow it:
- The client side stays good old React. You write components the way you always have: with state, hooks, effects, and contexts.
- Routing runs entirely on TanStack Router, a file-based router with uncompromising end-to-end type safety. URL params, search params, and loader return types are strictly checked by the TypeScript compiler. Rename a route parameter, and your project simply won't build until you update every reference across the codebase.
- Server code lives inside the
createServerFnprimitive. It is an explicit server function declaration that the compiler automatically turns into a type-safe remote procedure call (RPC). No need to wire up Express routes or invent REST endpoints by hand: you just call the function, and the framework handles the network request and serialized response. - Build and server runtime are powered by Vite, Vinxi, and Nitro. Nitro is the Swiss-army engine that outputs lightweight, self-contained artifacts for dozens of hosting targets.
Want to pack your app into a minimal Docker container and deploy it on a cheap VPS with Node.js or Bun? Go for it. Prefer serverless platforms like AWS Lambda, Cloudflare Workers, or Vercel? No problem—switching deployment targets takes a single line of configuration. Zero vendor lock-in and no proprietary hosting contracts.
In Practice: Creating a Project and Defining a Server Function
Let's see how this stack looks in real code. Spinning up a fresh project takes one official CLI command:
npm create @tanstack/start@latest my-start-app
cd my-start-app
npm install
npm run dev
Inside the project, client and server code stay cleanly separated. Let's create a server function in app/functions/posts.ts. Notice how natively Zod plugs in for validation:
import { createServerFn } from '@tanstack/react-start';
import { z } from 'zod';
// Declare a strictly typed server function
export const getPostById = createServerFn({ method: 'GET' })
.inputValidator(z.object({ id: z.string() }))
.handler(async ({ data }) => {
// This code is guaranteed to run only on the server:
// safe for database queries and private secrets
const response = await fetch(`https://api.example.com/posts/${data.id}`, {
headers: { Authorization: `Bearer ${process.env.INTERNAL_API_SECRET}` },
});
if (!response.ok) {
throw new Error('Запрошенная статья не найдена на бэкенде');
}
return (await response.json()) as { title: string; body: string };
});
Now let's wire that function into a file-based route at app/routes/posts/$postId.tsx. The loader fetches data on the server during initial SSR, or triggers a background RPC call on client-side navigation:
import { createFileRoute } from '@tanstack/react-router';
import { getPostById } from '../../functions/posts';
export const Route = createFileRoute('/posts/$postId')({
loader: async ({ params }) => {
// Direct server function call with full type autocomplete
return await getPostById({ data: { id: params.postId } });
},
component: PostComponent,
});
function PostComponent() {
const post = Route.useLoaderData();
return (
<article className="post-container">
<h1>{post.title}</h1>
<p>{post.body}</p>
</article>
);
}
Everything is clean, transparent, and debuggable in seconds. In the Network tab you see a tidy HTTP request, in your editor you get rock-solid TypeScript autocomplete, and the bundler never yells about unserializable hidden classes.
Benchmarks: Hard Numbers Over Hype
Dropping that heavy architectural layer paid off in real hardware dividends. In synthetic and load benchmarks on identical reference apps, TanStack Start posted impressive numbers:
Comparative infographic of SSR throughput and build speed benchmarks for TanStack Start.
- SSR throughput: the framework handles 2.9–8.6x more dynamic requests per second than Next.js 16.4. The reason is simple: the server doesn't have to build an RSC serialization tree or parse complex metadata on every incoming request.
- Cold and hot build speed: thanks to pure Vite and an optimized type-generation pipeline, total project compile time including typecheck dropped by roughly 1.7x.
Notice the difference: the server spends CPU cycles delivering bytes to the user instead of servicing an intricate internal component-streaming protocol.
If you check the npm registry, you'll see that @tanstack/react-start is published at version 1.169.x rather than a neat 1.0.0. Don't be alarmed: the team synced Start's versioning with the core TanStack Router packages to keep the monorepo manageable and avoid dependency mismatches. The public 1.0 announcement marks architectural stability and a locked backward-compatibility contract.
A Sober Look at Trade-offs and Security
It wouldn't be fair to paint a flawless picture. Every architectural choice has a price, and TanStack Start is no exception:
- Mutation security (CSRF): Since
createServerFnserver functions can accept HTTP POST requests directly, any state-changing action needs explicit cross-site request forgery protection (createCsrfMiddleware). Next.js bakes baseline protection for Server Actions deeper into the framework. - Plugin ecosystem maturity: Next.js has been around for over eight years, with thousands of ready-made integrations for CMSs, analytics platforms, and auth libraries like NextAuth/Auth.js. In TanStack Start, you'll wire up pieces like authentication more deliberately by hand, though Better Auth and Clerk already work out of the box.
- Migration boundaries: If your existing app is deeply tied to Next.js async server components with intricate Suspense island streaming throughout the DOM tree, rewriting it to Start one-for-one makes little sense—migrating would mean rethinking your data layer.
Still, if you're starting a new project—or you're just tired of fighting the black box of someone else's platform conventions—TanStack Start 1.0 offers the sanest, most pragmatic stack in modern frontend: honest React, crystal-clear types, and full control over your own code.


