TechPrufer
Get started
Vercel
Vercel logoVercel · Feature trail

Runtime Options for Vercel Functions

12 posts · Jun 2019 – Oct 2025

What this trail covers

Vercel Functions now support streaming responses by default for all Node.js runtimes, allowing immediate return of results and near real-time log visibility. This change impacts how runtime errors are handled, with headers sent immediately and errors logged upon stream closure. The log experience is enhanced, with individual log statements appearing on separate lines with precise timestamps, rather than being aggregated into a single line after function completion. This also affects Vercel Log Drains. Additionally, Vercel Functions are now powered by Rust, leading to significant performance improvements in cold starts and execution times, with slightly lower costs. The Rust rewrite optimizes environment variable handling, Node.js process spawning, response streaming and encryption, and `waitUntil` API usage.

All Vercel trails
  1. Bun runtime on Vercel FunctionsIntroduces Bun as a new runtime option for Vercel Functions, available in Public Beta. Details performance improvements (28% latency reduction in CPU-bound Next.js workloads) attributed to Bun's architecture. Explains how to configure the Bun runtime via `vercel.json` and highlights its compatibility with Next.js, Express, Hono, and Nitro. Discusses performance characteristics and tradeoffs between Bun and Node.js, emphasizing testing dependencies before production migration. Includes benchmark results comparing full TTFB for server-side rendering workloads.
  2. Serverless servers: Efficient serverless Node.js with in-function concurrencyThis post introduces and details the implementation of in-function concurrency for Vercel Functions. It explains the historical limitations of the one-to-one invocation-to-instance model in serverless for interactive workloads, the architectural changes involving a streaming connection and a Rust-powered runtime, and the resulting efficiency gains (20%-50% reduction in compute usage and cost). It also discusses trade-offs such as potential latency increases for CPU-bound workloads and the backward-incompatible nature of the change.
  3. Understanding Vercel FunctionsThis post details the advantages of Vercel Functions, emphasizing their secure and up-to-date environments, predictable performance due to automatic scaling and a Rust-powered core, high availability with automatic failover, cost efficiency through automatic downscaling to zero, real-time usage and spend controls, and out-of-the-box observability. It highlights the reduction in operational complexity for developers by abstracting infrastructure management.
  4. Function streaming to be framework-agnostic on VercelThis post details the default enablement of streaming responses for all Node.js Vercel Functions, outlining the behavioral changes in response to runtime errors (headers sent immediately, errors logged upon stream closure) and the enhanced runtime logs experience (near real-time, per-log-statement visibility). It also notes the impact on Vercel Log Drains and provides instructions for enabling streaming today via the VERCEL_FORCE_NODEJS_STREAMING environment variable.
  5. Introducing bytecode caching for Vercel FunctionsIntroduces an experimental bytecode caching feature for Vercel Functions to reduce cold start latency. This feature caches the compiled JavaScript bytecode, eliminating the need for recompilation on subsequent cold starts. The implementation overcomes ephemeral filesystem limitations of serverless platforms by developing a custom caching mechanism. Performance improvements are demonstrated with three Next.js applications of varying sizes, showing reductions in TTFB and billed duration by up to 27% and 48% respectively. The feature requires Node.js 20 and frameworks compiling to CommonJS, with plans to support ES Modules in Node.js 22.
  7. Vercel Functions are now faster—and powered by RustThis post details the migration of Vercel Functions' core logic from Node.js to Rust, resulting in performance improvements. Key contributions include: 1. Rewriting function initialization and invocation phases in Rust to optimize startup times. 2. Specific Rust optimizations for reading/attaching environment variables, spawning Node.js processes, streaming/encrypting chunked responses, and using APIs like `waitUntil`. 3. Benchmarking results showing up to 30% faster cold starts for smaller workloads and 80ms (average) / 500ms (p99) faster execution for larger workloads. 4. Improvements in streaming response connection times (47% faster average, 77% faster p99). 5. The introduction of Rust-powered functions leading to slightly shorter billed durations and thus lower costs. 6. Regional routing improvements for faster startups, especially for new deployments.
  8. Vercel Functions: Faster, modern, and more scalableThis post details significant upgrades to Vercel Functions, including increased concurrency to 100,000 invocations, adoption of Web Standard APIs (Request/Response) for a unified signature, zero-configuration streaming responses, extended execution durations (5 mins Pro, 15 mins Enterprise), faster cold starts through runtime and framework optimizations, and automatic regional failover for Node.js. Logging limits have also been increased. These changes aim to provide lower latency, scalable, and cost-effective compute.
  9. Managing major traffic spikes during ticket drops with Vercel | Customers | VercelThis post details how Vercel's autoscaling and serverless architecture, particularly with Next.js, enabled Shotgun to handle 200x traffic spikes during ticket drops without manual intervention. It also mentions the use of Edge Config for quick configuration of waiting rooms and Vercel Functions for seamless migration from Firebase, contributing to a more robust and scalable infrastructure for handling high-demand events.
  10. Build a GPT-3 app with Next.js and Vercel Edge FunctionsThis post provides a historical walkthrough of building a GPT-3 app with Next.js and Vercel Edge Functions, highlighting the frontend and backend implementation. It details the prompt construction for GPT-3, the API route for interacting with OpenAI, and the user interface for displaying generated bios. Crucially, it updates the guidance for new projects, recommending Vercel Functions with the Node.js runtime and Fluid compute for streaming support, longer durations, and full Node.js API compatibility, moving away from the older Edge Functions approach.
  11. Refined Logging on VercelThis post introduces refined build logs and serverless function logs for improved observability. It also highlights the existing Log Drains feature for piping invocation logs to external tools like LogDNA or Datadog for more complex log inspection needs.
  12. Inspecting Serverless FunctionsThis post introduces a new 'Functions' tab in the Deployment Overview, providing developers with detailed insights into their Serverless Functions. This tab displays function details (size, computational resources, response time), a real-time stream of requests and their logs, and a list of failed requests for up to 30 days. This enhances the ability to inspect and debug serverless functions in production.
  13. Helpers for Serverless Node.js FunctionsThis post introduces default helper methods (`request.query`, `request.cookies`, `request.body`, `response.status()`, `response.json()`, `response.send()`) to serverless Node.js functions on Vercel. These helpers simplify common operations like accessing query parameters, cookies, and request bodies, as well as setting response status codes and sending JSON or plain text responses. Benchmarks indicate a performance gain compared to basic Express.js applications.