TechPrufer
Get started
Vercel
Vercel logoVercel · Feature trail

Fluid Compute

8 posts · Apr 2024 – Sep 2026

What this trail covers

Fluid compute is Vercel's next-generation compute model designed to handle modern workloads with real-time scaling, cost efficiency, and minimal overhead. It dynamically adjusts to traffic demands, reusing existing resources before provisioning new ones. The Vercel Functions router orchestrates function execution to minimize cold starts, maximize concurrency, and optimize resource usage by dynamically routing invocations to pre-warmed or active instances. Instances communicate exclusively through the Vercel network. Fluid compute offers improved scaling with higher ceilings and better cost efficiency by prioritizing existing resources, reducing cold starts through a Rust-based runtime and bytecode caching, and supporting advanced tasks like background processing with `waitUntil`. It also provides dense global compute with multi-region failover and is open and portable across providers.

All Vercel trails
  1. Compute that takes any shapeThis post introduces and elaborates on Vercel's 'Fluid' compute platform, which unifies builds, sandboxes, and functions. It details the components: Hive (hardware provisioning), Fluid images (optimized environments using VHS format), and Vercel Drives (portable, durable storage). The core innovation is the ability to assemble machines dynamically around workloads, offering isolation stronger than containers without significant startup time penalties. It highlights the benefits for agent workloads, emphasizing immediate availability and state persistence. The post also mentions Active CPU pricing as a cost optimization strategy.
  2. Optimizing Vercel Sandbox snapshotsThis post details optimizations to Vercel Sandbox snapshot restore performance, reducing p75 latency from over 40 seconds to under one second. The improvements were achieved through parallelizing S3 downloads using the `Range` HTTP header and the AWS Go SDK's `transfermanager` API, fanning out decompression across multiple goroutines, and piping S3 download streams directly into decompression to eliminate intermediary file writes. Additionally, a local NVMe disk cache was implemented for decompressed snapshots, resulting in a 95% cache hit rate and further reducing boot times.
  3. Run untrusted code with Vercel Sandbox, now generally availableThis post announces the general availability of Vercel Sandbox as an execution layer for AI agents. It details how Sandbox leverages Vercel's existing compute platform (Hive, Firecracker) to provide isolated, ephemeral microVMs with sub-second start times, snapshots, and active CPU pricing. It highlights use cases with Roo Code and Blackbox AI, demonstrating how this infrastructure addresses the unique needs of AI agents for security, isolation, and rapid iteration.
  4. How AI Gateway runs on Fluid computeThis post details how Vercel's AI Gateway leverages Fluid compute for efficient, cost-effective operation. It highlights Fluid's in-function concurrency and Active CPU Pricing as key enablers for network-bound workloads like AI Gateway, which spend significant time waiting for external providers. The post explains how Fluid reuses instances, persists in-memory caches (e.g., provider routes, credentials, quota snapshots), and scales elastically, contrasting it with traditional serverless models. It also touches on the global delivery network's role in routing requests and the use of regional Redis clusters for state management and quota tracking, along with internal monitoring systems for self-correction.
  5. Server rendering benchmarks: Fluid Compute and Cloudflare WorkersThis post presents benchmarks comparing Vercel's Fluid Compute against Cloudflare Workers for server-side rendering. It highlights Fluid Compute's performance advantage (1.2x to 5x faster) and consistency, attributing it to in-region deployment (reducing network latency for database queries and API calls) and full Node.js/Python runtime compatibility, which avoids issues faced by Cloudflare Workers' approximate Node.js runtime. The benchmarks measured mean, min, max, and variability of response times across Next.js, React SSR, SvelteKit, math operations, and Vanilla JS.
  7. Scale to one: How Fluid solves cold startsThis post details Vercel's 'scale to one' strategy, which keeps at least one function instance warm to eliminate first-visitor cold starts for production and recent branch deployments (on Enterprise plans). It explains how Fluid compute reuses existing warm instances for multiple requests, reducing the total number of instances and the likelihood of cold starts. The post highlights that single instances can handle dozens of concurrent requests, with peaks over 250, and that Active CPU pricing optimizes costs by only charging for active execution. Predictive scaling and bytecode caching are also mentioned as contributing factors to reducing cold start impact.
  8. The real serverless compute to database connection problem, solvedThis post addresses the serverless compute to database connection problem, clarifying that the issue is not the number of connections but connection leaks due to function suspension. It explains how traditional serverless platforms struggle with this due to their VM lifecycle. The post introduces Vercel Fluid Compute's `waitUntil` feature as a solution, enabling functions to stay alive to close idle database connections before suspension. A simple code snippet using `attachDatabasePool` demonstrates this solution. It also discusses cost implications and best practices like configuring low connection idle timeouts and defining pools globally.
  9. Fluid compute: How we built serverless serversThis post details the engineering effort behind Vercel's Fluid compute, specifically focusing on the development of a custom TCP-based transport protocol to enable HTTP streaming from AWS Lambda functions. This protocol allows for multiplexing multiple concurrent requests to a single Lambda instance, breaking the traditional one-invocation-per-instance model. A new `compute-resolver` service was introduced to manage routing requests to Vercel Function Router pods, ensuring efficient reuse of established TCP connections and preventing hot-spotting. The Rust-based core acting as glue between infrastructure and user code is also highlighted.
  10. The AI Cloud: A unified platform for AI workloadsThis post introduces the Vercel AI Cloud, a unified platform for AI workloads that extends the existing Frontend Cloud. Key contributions include the introduction of AI SDK and AI Gateway for model integration and API management, Fluid compute with Active CPU pricing for cost-efficient AI execution, tool support via MCP servers and queues for autonomous actions, and secure sandboxes. It details how Fluid compute optimizes for AI workloads by reusing resources and charging only for active CPU usage, potentially reducing costs by up to 90% compared to traditional serverless. It also explains how AI SDK manages tool execution, which can run on Vercel Functions, MCP servers, or Vercel Queues, and introduces the `@vercel/mcp-adapter` package for simplified MCP server creation.
  11. Introducing Active CPU pricing for Fluid computeThis post introduces Active CPU pricing for Fluid compute. The new pricing model bills for CPU usage only when code is actively executing, measured in milliseconds as Active CPU (vCPU * active time). It also includes Provisioned Memory (GB-hours) and Invocations. This aims to reduce costs for I/O-bound workloads with high idle times, offering additional savings of up to 90% compared to previous models. The post contrasts traditional server-based and serverless models with Fluid compute's approach to concurrency and resource reuse.
  12. Designing and building the Vercel Ship conference platformThis post details the technical implementation of the Vercel Ship conference platform, highlighting the use of Fluid Compute for backend services. It describes how the platform was built as a Next.js app with a Postgres database and Payload CMS, simplifying the stack and enabling independent team movement. Rendering strategies like ISR and PPR were employed for speed, with `use cache` and `cacheLife` directives for fine-grained freshness control. The use of `after()` for post-checkout logic and dogfooding Vercel's platform (Sign In with Vercel, shared UI assets) are also discussed. The post also touches on modular component systems using shadcn, Geist, and cva, and transactional emails with React Email.
  13. Fluid compute: Evolving serverless for AI workloadsThis post details the architectural mismatch between traditional serverless computing and LLM interactions, highlighting how LLM workloads involve extended execution times and periods of inactivity. It introduces Fluid compute as a new model that reuses existing resources before scaling new ones, processing multiple AI inference requests simultaneously within a single instance to avoid cold starts and reduce costs. Fluid compute also strategically places resources in regions close to data for optimized performance and consistency. The post emphasizes the security aspects of Fluid compute, including Vercel Firewall for Layer 7 protection and secure instance architecture with TCP tunnels, as well as enhanced reliability through automatic failover.
  14. How Fluid compute works on VercelThis post details how Vercel's Fluid compute model optimizes function execution through its router. It explains the real-time routing process, including Vercel Firewall inspection, edge caching checks, and compute selection based on in-flight and pre-warmed instances. It highlights the secure infrastructure design where instances communicate via persistent TCP tunnels to the router, enabling precise control over workload distribution and scaling. The post also quantifies cost savings, stating up to 85% reduction in compute costs.
  15. Introducing Fluid compute: The power of servers, in serverless formThis post introduces Fluid compute, a new model for Vercel Functions that moves beyond traditional serverless by offering high-performance mini-servers. Key technical contributions include: a many-to-one invocation model for handling tens of thousands of concurrent invocations, built-in recursion protection to prevent runaway costs, a Rust-based runtime for faster initialization, bytecode caching for accelerated invocation, and support for `waitUntil` to continue background tasks post-response. It also details a dense global compute model with multi-region failover and emphasizes portability across providers.
  16. Improved infrastructure pricingThis post details Vercel's updated infrastructure pricing, which introduces more granular metrics for bandwidth and functions. It breaks down bandwidth into 'Fast Data Transfer' and 'Fast Origin Transfer', and functions into 'Function Invocations' and 'Function Duration'. New metrics like 'Edge Requests' and 'Data Cache Reads/Writes' are also introduced. The pricing changes aim to reduce costs for the majority of customers, align with industry standards, and provide new primitives for easier optimization. It also highlights existing features that help prevent runaway spend.