The Case for a Middle Ground in Compute
Dedicated servers promise efficiency and always-on availability, but they tend to force over-provisioning and carry heavy operational overhead. Serverless computing solves the scaling problem with automatic adjustments and pay-as-you-go billing, yet it introduces its own trade-offs: cold starts and wasted idle cycles. Fluid compute from Vercel positions itself between these two models, replacing single-invocation functions with high-performance mini-servers. Early adopters have reported compute cost reductions of up to 85%, along with fewer cold starts and better resource utilization.
The model is built on a set of straightforward principles:
- Compute activates only when required
- Scaling spans from zero to peak traffic in real time
- Existing resources are exhausted before new instances spin up
- Billing reflects actual compute usage, reducing waste
- Pre-warmed instances keep latency low and prevent cold starts
- Advanced workloads like streaming and post-response processing are supported
All of this operates without configuration or maintenance overhead.
Scaling Without Hard Limits
Vercel Functions running on Fluid compute prioritize existing resources before creating new ones. This removes the hard scaling ceilings of traditional serverless and takes advantage of warm compute for faster scaling. By scaling functions rather than instances, the architecture uses a many-to-one model capable of handling tens of thousands of concurrent invocations.
Cost control is built into the same design. Functions waiting on backend responses can handle additional requests instead of sitting idle, and built-in recursion protection stops infinite loops before they generate excessive usage charges.
Cold Starts and Extended Execution
Fluid reduces both the frequency and impact of cold starts. When they do occur, a Rust-based runtime with full Node.js and Python support accelerates initialization, while bytecode caching pre-compiles function code to cut startup overhead further.
Function lifecycles can now extend beyond the final response to the client. With the waitUntil API, tasks like logging, analytics, and database writes continue running in the background, reducing time-to-response. For AI workloads, this means handling post-response operations like model training updates without affecting real-time performance.
Regional Placement and Reliability
The dense global compute model places execution close to where data resides, rather than attempting replication across every edge location. This avoids the complexity of widespread data distribution while optimizing for both performance and consistency. Dynamic requests route to the nearest healthy compute region among designated locations. Standard multi-availability zone failover is supplemented by multi-region failover, which is enabled by default for enterprise customers using Fluid.
Portability and Activation
Vercel Functions require no proprietary code, keeping workloads portable across any provider that supports standard function execution. Developers don't write functions specifically for the infrastructure; workloads are inferred and provisioned automatically. Full runtime support for Node.js and Python includes native modules and the standard library, so existing frameworks work without modification.
Fluid compute is available to all Vercel users today. It can be enabled from the Functions tab in Project Settings, with no migrations or code changes required. After activation, the Observability tab provides metrics on function performance and compute savings. Further details are available in the Vercel changelog and documentation.
Fluid builds on earlier work in autoscaling server infrastructure, with Vercel acknowledging products like Google Cloud Run as prior approaches to the same set of problems.
