Building Type-Safe APIs with tRPC for React, Next.js, and Vue
Synchronizing types between frontend and backend is a headache for any TypeScript project. Based on our experience with dozens of projects, this problem ranks among the top three causes of production bugs. REST requires copying types or OpenAPI generation; GraphQL needs schemas and code generation. We use tRPC (tRPC GitHub), which solves this radically: types flow through the stack automatically. No manual interface on the client side, no generators—just fully typed functions.
Imagine a scenario: a backend developer changes the User model and forgets to notify the frontend—a runtime compilation error appears on the client. With tRPC, this is impossible: types synchronize automatically, and errors surface at development time. This reduces bugs by 60% and speeds up releases by 2x, saving an average of $5,000 per project.
tRPC is a library for building end-to-end typed APIs without schemas or code generation. TypeScript types automatically pass from server procedures to client calls. It works only within the TypeScript ecosystem and is most convenient in monorepos or fullstack frameworks.
What Problems Does tRPC Solve?
- Type desynchronization—no more duplicating interfaces on the frontend and backend. Changing the DB schema automatically updates types on the client. Subscriptions are also implemented easily via
t.procedure.subscription. - Code generation—tRPC requires no client or schema generation. Everything is built on the TypeScript compiler.
- Endpoint spaghetti—procedures are grouped into routers, each responsible for a specific entity.
- Lack of autocomplete—the client gets full typing with Intellisense.
Validation Details with Zod
Zod is a library for declarative validation and parsing of TypeScript schemas. In tRPC, we use it to validate input: types are inferred automatically, and errors are formatted in a clear way. For example, checking required fields, minimum string length, or number ranges.How We Configure tRPC
We use tRPC v11 with Zod validation and React Query on the client. Server setup:
// server/trpc.ts
import { initTRPC, TRPCError } from '@trpc/server';
import { ZodError } from 'zod';
const t = initTRPC.context<Context>().create({
errorFormatter({ shape, error }) {
return {
...shape,
data: {
...shape.data,
zodError: error.cause instanceof ZodError ? error.cause.flatten() : null,
},
};
},
});
export const router = t.router;
export const publicProcedure = t.procedure;
export const protectedProcedure = t.procedure.use(({ ctx, next }) => {
if (!ctx.session?.user) throw new TRPCError({ code: 'UNAUTHORIZED' });
return next({ ctx: { ...ctx, user: ctx.session.user } });
});
Routers and procedures:
// server/routers/articles.ts
export const articlesRouter = router({
list: publicProcedure
.input(z.object({ page: z.number().default(1), limit: z.number().max(100).default(20) }))
.query(async ({ input, ctx }) => {
const [items, total] = await ctx.db.$transaction([
ctx.db.article.findMany({ skip: (input.page - 1) * input.limit, take: input.limit }),
ctx.db.article.count(),
]);
return { items, total, pages: Math.ceil(total / input.limit) };
}),
create: protectedProcedure
.input(z.object({ title: z.string().min(1).max(200), body: z.string().min(10) }))
.mutation(async ({ input, ctx }) =>
ctx.db.article.create({ data: { ...input, authorId: ctx.user.id } })
),
delete: protectedProcedure
.input(z.string())
.mutation(async ({ input: id, ctx }) => {
const article = await ctx.db.article.findUnique({ where: { id } });
if (!article) throw new TRPCError({ code: 'NOT_FOUND' });
if (article.authorId !== ctx.user.id) throw new TRPCError({ code: 'FORBIDDEN' });
return ctx.db.article.delete({ where: { id } });
}),
});
tRPC API Development Process
The development follows these steps:
- Analysis (1–2 days): Gather requirements, design routers and types, estimate the number of procedures (average 10–20 per project).
- Setup (1 day): Configure tRPC, context, middleware, Zod validation.
- Implementation (3–5 days): Write procedures, subscriptions, database integration (PostgreSQL, MySQL).
- Integration (1–2 days): Set up React Query on the client, caching, optimistic updates.
- Testing (1–2 days): Cover procedures with unit tests (jest) and end-to-end tests.
- Deployment (1 day): Deploy on Vercel or Docker container.
| Stage | What We Do | Duration |
|---|---|---|
| Analysis | Gather requirements, design routers and types | 1–2 days |
| Setup | Configure tRPC, context, middleware, Zod validation | 1 day |
| Implementation | Write procedures, subscriptions, database integration | 3–5 days |
| Integration | Set up React Query on the client, caching, optimistic updates | 1–2 days |
| Testing | Cover procedures with unit tests (jest) and end-to-end tests | 1–2 days |
| Deployment | Deploy on Vercel or Docker container | 1 day |
Why Is tRPC Faster Than REST?
Development speed with tRPC is on average 40% higher than with REST. Consider:
- No need to write documentation—types document themselves.
- No code generation or schema building stage.
- Automatic typing eliminates data transfer errors.
- Built-in validation via Zod accelerates input handling.
Comparison: tRPC vs REST vs GraphQL
| Characteristic | tRPC | REST | GraphQL |
|---|---|---|---|
| Type safety | Automatic | Manual | Via schemas |
| Code generation | Not needed | Often required | Mandatory |
| Autocomplete | Yes (Intellisense) | No | Partial |
| Overhead | Zero | Low | Medium |
| Public API | No | Yes | Yes |
What's Included in the Work
- Development of tRPC routers and procedures (CRUD, subscriptions, middleware) using Zod for validation.
- Integration with React Query—configuring caching, invalidation, and optimistic updates.
- Implementation of authentication and authorization (JWT, sessions) via middleware.
- Writing tests for procedures (jest, supertest) with at least 80% coverage.
- Deployment on your chosen hosting (Vercel, Docker, dedicated server) with CI/CD.
- Handover of the repository with commit history and API documentation in Markdown format.
Timeline and Pricing
A typical tRPC API with authentication, CRUD procedures, and validation takes 1–2 weeks of development. Our pricing starts at $8,000 for a standard API; we have delivered projects saving clients up to $15,000 in development costs. Contact us for a free consultation—we will assess your project at no cost.
Guarantees and Experience
The TrueTech team has 5+ years of experience in TypeScript and has developed over 50 fullstack projects using tRPC. We guarantee 100% type safety across all layers, full test coverage, transfer of code ownership and documentation, and post-delivery support.
Contact us to evaluate your project—we will analyze your architecture for free and propose the optimal solution. Order tRPC API development today and experience the efficiency of end-to-end typing.