Does Vercel run next.js server components in a serverless fashion (i.e. do they spin up a long-lived or short-lived node.js server)?

[magnusriga]

I have been using Next.js for a while and realized I am missing a core piece of understanding relating to how the framework actually operates under the hood, as it relates to server-side code.

Background

Next.js has three categories of code that runs server side (as far as I know):

1. Code in Server Components (e.g. a normal async page component). It is possible to fetch external data in these server components. The code will never be executed by the browser.

2. Code in Route Handlers (previously called API Routes). This code is executed when a machine (typically client side code in the browser) sends a request to the handler's URL. Route Handlers are executed by app host (e.g. Vercel) on demand, in a node.js server environment. That server is started on-demand, whenever the function runs, thus there is a small lag to run these functions. This way of running functions is called "serverless", because we do not need to run and manage our own server to execute them. Vercel, for instance, can execute these from a central server (e.g. in the US), or from one of many servers around the world (called the edge) that runs smaller and faster versions of the node.js runtime (called the edge runtime).

3. Finally, Server Actions also execute server-side, in a node.js environment. They are similar to Route Handlers, in that they are "serverless" (called by client-side code in the browser, resulting in a server booting up to run the code and then shutting down).

As I was looking into Prisma, I read that the Prisma Client either establishes long-lived connections to a database, or short-lived connections. See: https://www.prisma.io/docs/orm/prisma-client/setup-and-configuration/databases-connections

Question

It is clear to me that Route Handlers and Server Actions will spawn short-lived node.js servers and thus create a new Prisma Client object per function call. As such, these Prisma database connections are short-lived, meaning the Prisma Client object only lives for the duration of the function call.

Firstly, is my above understanding correct?

Secondly, if we contact our database in a normal server component in a dynamic route (i.e. SSR, not SSG), will that be a short-lived node.js execution, or does that node.js environment persist / live over time (so Prisma Client objects are actually long-lived in that scenario)?

---

Edit:

• Vercel caches data fetches (in Data Cache), so the database requests might not actually run if the same data is requested again. The question above disregards the cache, and is related to code execution and creation of the Prisma Client object and whether its database connection is long-lived or short-lived.

• In static routes, bundle (react server component payload, and html/css/js bundle) resulting from execution of react server component, is cached in Full Route Cache on e.g. Vercel. This does not happen with dynamic routes.

[magnusriga]

Relevant:

It is vaguely documented, but here is some initial evidence that when any server component is rendered on the server by Vercel, it is done so in a serverless fashion (i.e. that it does not keep a long-lasting node.js server running): https://vercel.com/docs/frameworks/nextjs#incremental-static-regeneration

As seen, the docs page groups server-rendering with Route Handlers (referred to by its old name "API Routes"), calling it all Vercel Functions, which is serverless (meaning the node.js server it spins up only runs for the duration of the function it executes).

In other words, I am not 100% certain that server components are run in one-off node.js servers by Vercel (i.e. serverless), but it is my current best guess.

[eddie-thomas]

I'm currently reading through the Next.js 14 docs and agree it is vaguely documented. I, personally, want to know whether the server components would cause a serverless Node instance to persists for billing reasons. @magnusriga I'm assuming the server components don't persist so we can save money on serverless function costs, but did you find anything to back my assumption up?

[magnusriga]

Unfortunately, I have yet to find complete and in-depth information on RSCs and how Vercel runs them (particularly in Next.js).

If we do not know how the server components run under the hood, both for static and dynamic routes, it is impossible to optimize the code and feel safe when using Next.js. Frustrating, to say the least.

These resources helped my understanding to some degree, but I am still missing the majority of the puzzle:

• https://demystifying-rsc.vercel.app/ <-- Great resource
• https://react.dev/reference/rsc/server-components <-- Official docs

[pppdns]

On Vercel they are serverless functions based on the Vercel docs:

On Vercel, you can server-render Next.js applications in either the Node.js runtime (default) with
[Serverless Functions](https://vercel.com/docs/functions/serverless-functions) or the Edge runtime
with [Edge Functions](https://vercel.com/docs/functions/edge-functions). This allows you to pick the best rendering
strategy on a per-page basis.

https://vercel.com/docs/frameworks/nextjs#server-side-rendering-ssr

Although the self-hosted version seems to be a long-running Node server:
https://nextjs.org/docs/pages/building-your-application/deploying#self-hosting