Connecting to Neon from Vercel

• What connection pooling is and why it mattered for serverless
• The difference between "Classic Serverless" and Vercel's "Fluid compute"
• How TCP, HTTP, and WebSocket connections compare on latency
• Our recommendation for connecting from Vercel

• Vercel-Managed Integration
• Neon-Managed Integration
• Benchmarking latency

Vercel's Fluid compute model fundamentally changes the performance trade-offs for connecting to your Neon database.

The short answer: With Vercel Fluid, we recommend you use a standard Postgres TCP connection (for example, with the node-postgres package) and a connection pool. This is the new fastest and most robust method.

This guide explains why this is a change, the difference between connection methods, and what you should use.

The most important concept to understand is connection pooling.

• Database connection: Establishing a connection to a Postgres database is an expensive, multi-step process (called a "handshake") that takes time.
• Connection pooling: A connection pool is a "cache" of active database connections. When your function needs to talk to the database, it quickly grabs a connection from the pool, uses it, and then returns it (also quickly).

The key problem with "classic" serverless was that you could not safely maintain a connection pool. Functions would be suspended while holding idle connections, leading to "leaks" that could exhaust your database's connection limit.

How you connect depends entirely on your compute environment.

In a traditional serverless environment, each request spins up a new, isolated function instance. That instance runs its code and then shuts down.

• The problem: Because connection pools were not safe (as noted above), you had to establish a new database connection on every single request.
• The latency hit: A standard TCP connection (the default for Postgres) takes the most "roundtrips" (~8) to establish. This adds significant latency to every API call.
• The solution (HTTP/WebSocket): To solve this, Neon provides the @neondatabase/serverless driver, which connects over HTTP or WebSockets. These protocols have fewer setup roundtrips (~3-4), making them much faster for the first query.

Vercel's Fluid model allows function runs to reuse warm compute instances and share resources.

• The opportunity: This reuse is the key. It makes connection pooling possible and safe in a serverless environment.
• How Fluid makes pooling safe: Vercel Fluid solves the "leaked connection" problem. It keeps a function alive just long enough to safely close idle connections before the function is suspended, making pooling reliable.
• The new "fastest" method: You can now establish a TCP connection once and place it in a pool. Subsequent function calls reuse that "warm" connection, skipping the ~8 roundtrip setup cost entirely.
• The result: Once the connection is established, a direct Postgres TCP connection is the lowest-latency and most performant way to query your database.

This table breaks down the trade-offs, which are all about setup cost versus query speed.

Note: Roundtrip counts are estimates and vary based on authentication and configuration.

We recommend using a standard Postgres TCP driver (like node-postgres) and implementing a connection pool. This will give you the best performance by paying the connection cost once and reusing the connection for subsequent queries. See Vercel's Connection pooling with Vercel Functions guide for implementation details.

Here is a complete example using Drizzle ORM with attachDatabasePool from @vercel/functions:

// src/lib/db/client.ts
import { attachDatabasePool } from '@vercel/functions';
import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';

import * as schema from './schema';

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});
attachDatabasePool(pool);

export const db = drizzle({ client: pool, schema });

attachDatabasePool handles the connection lifecycle for you: the first request establishes a TCP connection, subsequent requests reuse it instantly, and idle connections close gracefully before Vercel suspends the function.

Continue using the @neondatabase/serverless driver. Its HTTP-based connection is optimized for low-latency "first queries," which is the most important metric in that environment.

You can see a live latency comparison of these three methods here: Function latency comparison