tRPC & Remix 3: The Security Flaw in Scalability Benchmarks

Modern full-stack frameworks and RPC tools have redefined how developers build performant, type-safe applications. Two standout technologies in this space are tRPC (TypeScript Remote Procedure Call) and Remix 3, a full-stack React framework focused on web standards and performance. While both tools are widely praised for their developer experience and scalability claims, a critical security flaw has been uncovered in common scalability benchmarking setups for combined tRPC + Remix 3 stacks.

Background: tRPC and Remix 3 Scalability Claims

tRPC enables end-to-end type safety without code generation, letting frontend and backend share types seamlessly. Remix 3, built on React Router v7, optimizes for server-side rendering, nested routing, and minimal client-side JavaScript. Together, they’re often marketed as a scalable stack for high-traffic applications, with benchmarks citing low latency and high throughput under load.

Common scalability benchmarks for this stack test metrics like requests per second (RPS), p99 latency, and memory usage under simulated user traffic. These benchmarks often use default tRPC and Remix configurations, with no adjustments for production-grade security or traffic patterns.

The Flaw: Unvalidated Benchmark Configurations

The core security flaw lies in how most public scalability benchmarks for tRPC + Remix 3 stacks are configured. Benchmark authors frequently disable critical security middleware to isolate framework performance, but these disabled settings are often carried over to production-adjacent guidance, leaving applications vulnerable.

Specifically, two misconfigurations are rampant in these benchmarks:

• Disabled tRPC input validation: Benchmarks often skip tRPC’s built-in input validation (using Zod or similar) to reduce overhead, but this removes the only guard against malformed or malicious request payloads.
• Unrestricted Remix 3 resource routes: Benchmarks disable Remix’s default CSRF protection and rate limiting for resource routes to maximize throughput, but these routes often expose tRPC endpoints to unauthenticated, unthrottled traffic in production setups.

Worse, many benchmarks test only happy-path traffic, ignoring malformed requests, injection attempts, or abnormal load patterns that trigger unhandled errors in tRPC resolvers or Remix loaders. These unhandled errors can leak stack traces, expose environment variables, or crash worker threads in Node.js-based Remix deployments.

Real-World Impact

Teams adopting the tRPC + Remix 3 stack based on these flawed benchmarks risk deploying applications with gaping security holes. For example:

• Unvalidated tRPC inputs allow SQL injection or NoSQL injection if resolvers pass raw input to database queries.
• Unrestricted tRPC endpoints enable denial-of-service (DoS) attacks, as attackers can flood endpoints with large payloads or high-frequency requests without throttling.
• Unhandled errors in benchmark-optimized stacks can leak sensitive data like API keys or database credentials in error responses.

A 2024 audit of 47 production tRPC + Remix 3 applications found that 62% had at least one of these misconfigurations, directly traced to following benchmark-recommended setups without adding security layers.

Mitigation Steps

To avoid falling victim to this flaw, teams should:

1. Never use benchmark configurations in production: Benchmark setups are designed to measure raw framework performance, not production readiness. Always re-enable security middleware post-benchmarking.
2. Enforce tRPC input validation: Use Zod or Valibot to validate all inputs to tRPC procedures, even if benchmarks disable this. The performance overhead is negligible compared to the security risk.
3. Enable Remix 3 security defaults: Re-enable CSRF protection, rate limiting, and error masking for all resource routes exposing tRPC endpoints. Use Remix’s built-in headers function to set security headers like Content-Security-Policy.
4. Test with adversarial traffic: Supplement happy-path benchmarks with fuzz testing, injection attempts, and abnormal load patterns to uncover unhandled errors or performance bottlenecks under attack.

Conclusion

Scalability benchmarks are useful for comparing framework performance, but they are not production deployment guides. The security flaw in tRPC + Remix 3 scalability benchmarks stems from conflating raw performance metrics with secure configuration. By separating benchmark optimizations from production security requirements, teams can leverage the full power of this stack without exposing their applications to unnecessary risk.