Anthony Ruvinov

REST vs RPC: Why RPC (Specifically tRPC) is the Future of API Design

Published December 28, 2024 ⋅ 3 minute read

In the ever-evolving landscape of web development, the debate between REST and RPC architectures continues to spark discussions. While REST has been the de facto standard for API design over the past decade, I'm here to make a case for why RPC, particularly tRPC, might be the better choice for modern web applications.

The Traditional REST Approach

REST (Representational State Transfer) has served us well. Its resource-oriented approach, stateless nature, and HTTP method semantics have provided a standardized way to build APIs. However, as our applications grow more complex, REST's constraints can become limiting.

Enter RPC: A Function-First Approach

Remote Procedure Call (RPC) takes a different approach. Instead of thinking in terms of resources and HTTP methods, RPC treats API endpoints as function calls. This might seem like a subtle distinction, but it fundamentally changes how we design and consume APIs.

Why RPC Makes More Sense

  1. Natural Programming Model

    • RPC mirrors how we actually think about programming
    • Instead of mapping actions to HTTP methods, we simply call functions
    • More intuitive for complex operations that don't fit REST's resource model

  2. Type Safety

    • Modern RPC implementations like tRPC provide end-to-end type safety
    • No more guessing about payload shapes or response structures
    • Catch errors at compile time rather than runtime

The tRPC Game-Changer

This is where tRPC truly shines. Built on top of React Query, tRPC brings several game-changing advantages to the table.

React Query Integration: A Match Made in Heaven

The integration with React Query is more than just a technical detail—it's a fundamental advantage. React Query has established itself as the leading asynchronous state management solution in the React ecosystem, and tRPC leverages this foundation to provide:

  • Automatic caching
  • Background data synchronization
  • Optimistic updates
  • Infinite scrolling
  • Real-time polling
  • Loading and error states

The Type-Safety Revolution

./root.ts
// Example tRPC procedure
const appRouter = router({
  getUserPosts: publicProcedure
    .input(z.object({ userId: z.string() }))
    .query(async ({ input }) => {
      return await prisma.post.findMany({
        where: { userId: input.userId }
      });
    })
});

// Client-side usage with full type inference
const { data, isLoading } = trpc.getUserPosts.useQuery({ 
  userId: "123" 
});

The beauty of this setup is that everything is typed. Your editor knows exactly:

  • What procedures are available
  • What input they expect
  • What they return
  • All the loading and error states

When to Choose RPC Over REST

While I believe RPC (especially tRPC) is superior for many use cases, the choice ultimately depends on your specific needs:

Choose RPC When:

  • Building full-stack TypeScript applications
  • Working with complex domain logic
  • Prioritizing developer experience
  • Needing strict type safety
  • Using React Query already
  • Building internal APIs

Stick with REST When:

  • Creating public APIs
  • Requiring broad client compatibility
  • Working with simple CRUD operations
  • Needing to adhere to specific architectural constraints

The Developer Experience Factor

One aspect that cannot be overstated is the improvement in developer experience. With tRPC:

  • No more API documentation to maintain
  • No more OpenAPI specifications to generate
  • No more type mismatches between frontend and backend
  • Instant autocompletion in your IDE

Performance Considerations

RPC with tRPC isn't just about developer experience—it can lead to better performance:

  • Smaller bundle sizes due to better tree-shaking
  • Reduced network overhead with batching
  • Optimized re-renders through React Query
  • Efficient caching strategies out of the box

Conclusion

While REST has served us well, RPC—specifically tRPC—represents a step forward in API design for modern web applications. Its integration with React Query, combined with end-to-end type safety and superior developer experience, makes it a compelling choice for new projects.

The key is understanding that API design isn't about following trends—it's about choosing the right tool for your specific problems. For many modern web applications, especially those built with TypeScript and React, tRPC provides a more efficient, type-safe, and developer-friendly approach to API design.

Remember: The best API architecture is the one that solves your specific problems while maximizing developer productivity and application performance. For an increasing number of projects, that architecture is RPC with tRPC.

signature
BlogsProjects