Handling 50 Million Requests a Month: How Interfaze Rebuilt Its AI Backend on Vercel

While most AI startups are still scrambling over GPU clusters and inference latency, a company called Interfaze has taken a completely different path: running its entire backend—including the model API, code sandbox, and vendor routing—on Vercel. Behind 50 million requests per month, there's no standalone Kubernetes cluster and no dedicated ops team—just a set of serverless functions and a handful of carefully chosen Vercel products.

Deterministic Models: Building a Moat Where LLMs Fall Short

Interfaze's positioning is rather counterintuitive. It doesn't build general-purpose chat models; instead, it focuses on deterministic tasks where general LLMs perform poorly: document processing, OCR, object detection, web scraping, speech-to-text, and classification.

Founder Yoeven Khemlani's explanation is spot on: "Most models aren't inherently deterministic. That's fine when you're writing an article, but when a hospital or a legal team is processing documents, you're not going to use an LLM." He gives a concrete example—ask an LLM to calculate an invoice total, and you get a number, but you can't easily verify where it came from. Interfaze's models return not just the number, but also the bounding box on the page (indicating where the number came from) and a confidence score. Every result is verifiable, while the model still accepts prompts like an LLM.

This "verifiable output" has hard value in healthcare, legal, and financial scenarios. Engineering teams in these industries need AI results that can be audited and traced, not a black-box probability. Interfaze's customer profile is squarely aimed at these three domains.

Zero Infrastructure Backend: A Folder Is a Backend

Both Interfaze's frontend and backend run on Vercel, all existing as serverless functions in the same codebase. API requests, file uploads, and model calls all go through the same deployment system. When a request needs computation, the model hands the code to Vercel Sandbox for isolated execution.

Khemlani compares the experience with other platforms: "On other platforms, setting up a backend means first sorting out networking, security, and function limits before you can serve your first request. On Vercel, I create a folder and I have a backend."

This difference in developer experience is a real time cost for early-stage teams. There's no separate log vendor to configure, no load balancer to tune, and preview deployments automatically come with their own logs and URLs. Interfaze runs multiple model versions simultaneously, each with its own URL—when errors occur, logs are already archived by version, making troubleshooting straightforward.

Serverless Functions and Cold Starts

Serverless functions are an event-triggered, on-demand compute model where developers don't need to provision or manage servers. The platform handles elastic scaling and availability, and bills based on actual invocations and resource consumption. The trade-off is cold starts: after a function hasn't been called for a while, the platform reclaims the instance, and the next request requires reinitializing the runtime environment, adding extra latency. For a backend like Interfaze's that handles API requests and model calls, cold starts directly affect time-to-first-byte. Vercel mitigates cold start frequency through mechanisms like Fluid compute that reuse instances, which is one of the prerequisites for it to confidently handle production traffic.

Vercel Sandbox

Vercel Sandbox is an isolated code execution environment provided by Vercel, allowing untrusted or dynamically generated code to run in controlled containers. It's commonly used in AI Agent scenarios: model-generated code needs to be executed but must not affect the main service. Sandbox provides restrictions on filesystem, network, and resource quotas, and returns execution results in a structured format. Interfaze hands the parts of the model that need computation to Sandbox for isolated execution, ensuring security while avoiding introducing uncontrolled execution logic into the main function.

Fluid compute and AI Gateway: The Two Pieces for Heavy Lifting and Routing

Scalability is Khemlani's primary requirement. The goal is to serve models to millions of users, and Vercel's Fluid compute scales automatically with traffic. More importantly, it handles the truly resource-intensive workloads.

Interfaze's web scraping runs on Puppeteer, which has high memory and timeout requirements. Khemlani admits: "We never thought we'd use Vercel for the backend. Underneath Fluid compute is a real Node.js server, so even the heaviest workloads can run directly."

The other piece is AI Gateway. Interfaze distributes a large number of data cleaning tasks to open-source models hosted by third-party vendors. A single vendor is a weak link—when rate-limited or down, cleaning stalls unless traffic can automatically switch. A more subtle issue is that two vendors claiming to host the same open-source model may deliver vastly different quality. Khemlani points out: "One runs 4-bit, another runs 8-bit. With AI Gateway we can route between them and see who actually performs better."

AI Gateway automatically fails over when a vendor fails or is rate-limited, while also allowing Interfaze to select providers for specific models and allocate traffic through actual load testing. This mechanism turns "multi-vendor failover" from an engineering burden into a configuration item.

The Technical Positioning of Fluid compute and AI Gateway

Fluid compute is an extension of Vercel's serverless execution model. It preserves a real Node.js runtime underneath and allows instances to be reused between requests, thereby mitigating cold starts and supporting longer execution times and higher memory limits. Traditional serverless functions typically have strict timeout and memory limits, while browser automation tools like Puppeteer require sustained memory and longer running windows—Fluid compute is designed precisely for such heavy workloads.

AI Gateway is a routing layer between applications and model vendors. It unifies API protocols across different vendors and provides key management, usage tracking, rate limiting, and failover. For Interfaze, the value of AI Gateway lies in turning "multi-vendor failover" and "quality-based routing" from self-built engineering into configuration items: when a vendor is rate-limited or down, the gateway switches automatically; when the same open-source model exists in different quantized versions, the gateway allows traffic allocation based on actual performance.

Workflow SDK: Email Sequences Spanning Months

Interfaze's lifecycle email system is built on Workflow SDK, with send conditions depending on product usage—tracking which API the customer called, how much they called, and how it changed compared to the first week. Retries are handled automatically, and a single step failure won't bring down the entire sequence.

What the team values most is durable execution: a workflow can pause at a step and resume months later with full state. Khemlani says other systems can't maintain state for such long periods. For SaaS products that need to observe long-term user behavior before triggering outreach, this capability directly determines the feasibility of operational strategies.

Durable Execution

Durable execution is a workflow orchestration pattern where the state of each step is persistently stored, allowing the process to resume from the last successful step after interruption rather than restarting from scratch. It's typically implemented through event logs or state machines, giving long-running workflows that span days or even months fault recovery capabilities. Unlike ordinary function calls, durable execution guarantees "exactly-once" or "at-least-once" step semantics and supports pause and resume. Interfaze's email sequences rely on this capability: the system can pause at a step and continue months later with full context, without keeping the process resident. This is crucial for SaaS products that need to observe long-term user behavior before triggering outreach.

Preview Deployments: A Co-creation Channel for Model Versions

Interfaze's release process deserves special mention. A new model version is just a new branch, and the Vercel-side build takes about three minutes—the slow part is hosting the weights on GPUs. Once the build is complete, the team sends the preview URL to a few customers, tests for a month, and then merges.

This process embeds "customer co-creation" into the engineering pipeline. Error attribution is also simplified by deployment isolation: each URL has its own logs, and errors naturally attach to the version that caused them. For teams maintaining multiple model versions simultaneously and needing to quickly locate regressions, this structure saves a lot of troubleshooting cost.

Preview Deployments and Branch Builds

Preview deployments are one of Vercel's core workflows: each time a branch is pushed to the code repository, the platform automatically builds and generates a temporary environment with its own URL for the team or customers to verify before merging. Each preview environment has independent logs, environment variables, and domains that don't interfere with each other. This mechanism makes "version isolation" the default behavior. For a team like Interfaze that maintains multiple model versions simultaneously, each version corresponds to a branch and URL, and error logs are naturally archived by version, allowing regression issues to be quickly traced to a specific version without troubleshooting in a shared environment.

Next Up: Search Gateway and Open Weights

Interfaze recently released Interfaze 1 Lite, an open-weights version that can run on a single GPU and is served through the same API. The next step is a web search gateway—an API that routes to the search vendor chosen by the developer, the same pattern as what AI Gateway does for models, also running on the existing Vercel backend.

A signal can be seen from this company's technical choices: AI application backend infrastructure is migrating from "self-built clusters" to "managed primitives." When serverless compute limits, memory ceilings, and timeout windows are sufficient to cover heavy workloads like Puppeteer scraping, startup teams focusing their energy on model quality and customer validation rather than ops becomes a more rational resource allocation. Interfaze's 50 million monthly requests are a reference sample—it proves the actual carrying capacity of the Vercel stack in AI backend scenarios, and also exposes its applicable boundaries: heavy GPU inference still happens elsewhere; what Vercel handles is the orchestration layer around the models.