Appendix C — Skill Mastery Checklist

Verified against @tanstack/react-start v1.168.x — July 2026.

This isn’t a test — it’s a map. Use it to find the gaps: if a line doesn’t feel solid, the linked chapters are where to go fix that, in the order listed. Prerequisite skills covers the baseline this whole book assumes; this checklist is the finish line, not the start line.

Vite depth

• Understand why plugin order matters (tanstackStart() before viteReact(), host plugins before tanstackStart()) and can debug a build that breaks when it’s wrong. → Scaffolding and the Vite plugin, Cloudflare Workers
• Know what Vite’s environments API is for, and why SSR-targeting plugins (like @cloudflare/vite-plugin) need to be told which environment to attach to. → Cloudflare Workers
• Can read a bundle analyzer report and identify server-only code that leaked into the client bundle. → Performance tuning

TanStack Router mastery

• Comfortable with file-based routing conventions, nested layouts, and how a folder tree becomes a route tree. → File-based routing and project structure
• Know the difference between loader, beforeLoad, and route context, and when each runs. → Loaders and deferred data
• Can configure preload strategy (defaultPreload, per-Link preload) and reason about its cost. → Performance tuning

React 19 fundamentals

• Suspense, use(), and transitions — not just syntax, but what they change about request/response timing. → Prerequisite skills, SSR and streaming
• Understand the Flight protocol at a conceptual level — what “a stream of React elements, not JSON” actually means. → RSC streaming mechanics

Streaming SSR & Suspense boundary placement

• Know how Start streams a response and why boundary placement (not just presence) determines what the user sees first. → SSR and streaming, Boundaries and hydration
• Can choose ssr: true / 'data-only' / false per route deliberately, not by default. → Selective SSR

HTTP / caching fluency

• Comfortable with Cache-Control, stale-while-revalidate, and what a CDN actually does with those headers. → Caching and env vars
• Know when prerendering/ISR is the right cache strategy versus per-request SSR. → Prerendering and SPA mode, ISR, CMS pattern

The RPC / server-function mental model

• Understand createServerFn’s validator → middleware → handler pipeline, and that the handler never ships to the client. → Server function anatomy
• Know what the RPC compile boundary actually strips, and why a shared module can leak server code into the client bundle anyway. → The RPC compile boundary
• Can test a server function’s handler logic without standing up a real HTTP request. → Testing server functions and loaders

Edge-runtime awareness

• Know why module-scope state (including cached env reads) is dangerous on a runtime that reuses isolates across requests. → Caching and env vars, The singleton-leak bug class
• Can apply that discipline concretely on a specific host (not just in the abstract). → Cloudflare Workers

TypeScript generics (end-to-end inference)

• Can predict a server function’s inferred data type from its validator without running the code. → Prerequisite skills, Server function anatomy
• Comfortable reading a broken-inference error and finding where the chain actually breaks, rather than widening a type to make it go away.

Nitro / deployment-preset literacy

• Know the difference between a host-specific Vite plugin and a Nitro preset, and which shape a given host uses. → Deployment model overview
• Can stand up both a long-running Node/Docker deployment and an edge deployment from the same app. → Node, Docker, and Nitro, Cloudflare Workers
• Know where to look for a host not covered in depth (Vercel, Netlify, Bun, Railway). → Config-delta reference

TanStack Query integration patterns

• Understand streaming dehydration/hydration via the official Router-Query integration, and Start’s staleTime conventions. → TanStack Query
• Know when reaching for Query alone is enough, versus needing DB or client UI state on top of it. → Decision framework
• Can reason about defaultPreloadStaleTime and Query’s staleTime as two layers answering related questions. → Performance tuning

Tip

This framework moves fast enough that “mastery” has a shelf life. Re-check the version and stability legend periodically — a 🔴 pattern you learned here might have gained official docs by the time you next need it, and a 🟢 API might have shifted.