Learn tRPC (TypeScript RPC) to build full-stack TypeScript applications with end-to-end type-safety without codegen and without schema duplication: pre-requisites & environment setup, history, background & why you need tRPC, core concepts & main architecture, building your first tRPC API, running the tRPC server and consuming from a client, input validation, error handling & response types, middleware, links & lifecycle interception, tRPC configuration and environment variables, state management & data fetching patterns, schema evolution, versioning & backward compatibility, HTTP and WebSocket transport, authentication & authorization in tRPC, API security, rate limiting & best practices, tRPC performance & optimization, observability, tracing & monitoring, resilience & fault tolerance, tRPC in Next.js, Remix and serverless, CI/CD, testing & production deployment, and modern tooling & the latest stable features with a total of 19 episodes.
Before touching tRPC, you need to master modern TypeScript, API contract concepts, and the differences between RPC, REST, and GraphQL. In this episode you will also set up Node.js, create a TypeScript project, install @trpc/server, @trpc/client, and zod, and verify your first installation.

This episode explores tRPC's history from its classical RPC roots to its rise in the TypeScript community, the problems it solves compared to REST and GraphQL, and when tRPC becomes the right choice for internal applications, monorepos, and rapid prototyping.

This episode breaks down tRPC's architecture: how TypeScript infers types from the server to the client, the role of router, procedure, input, output, and caller, as well as the adapter layer for HTTP, WebSocket, and serverless transport along with the proxy client and React client.

This episode builds a complete first tRPC API: a clean project structure, a router with query, mutation, and subscription, and the application of zod for modern input and output validation with type-safe schemas.

This episode brings the tRPC API to life through a real server: a standalone or Express server, an adapter for the Next.js App Router, and a tRPC client in React. You will make your first request and experience type-safe autocompletion from the editor.

This episode breaks down tRPC API quality: input validation with zod and superstruct, error handling with TRPCError along with formatError and HTTP status mapping, and managing response type inference and fallback default values.

This episode opens three interception points in tRPC: server-side middleware for authentication, logging, tracing, and rate limiting; client-side links such as loggerLink, httpBatchLink, wsLink, and custom links; as well as the lifecycle hooks onError, onSuccess, and onSettled in React Query integration.

This episode tidies up the configuration side: environment variables for the base URL, API keys, and development mode, a tRPC configuration structure shared between client and server, and the application of a conditional loggerLink between development and production.

This episode masters client-side state management: query, mutation, invalidate, and optimistic update patterns, modern integration with @tanstack/react-query, as well as caching, refetch, and stale data handling techniques.

This episode discusses safe tRPC API evolution: changing schemas without breaking old clients, versioning and procedure deprecation strategies, and input and output migration techniques while maintaining backward compatibility.
