← Blog · Guides

Netlify Shipped a Server. Which of Your Endpoints Were Never Functions?

November 11, 2026

On 10 November 2026 Netlify announced a new product. In the words of the post, by Distinguished Engineer Eduardo Bouças: "Today we're introducing Netlify Server, a long-running server for your application's backend." It is in Early Access, not generally available. "It gives your application everything a server can do, from WebSockets to in-memory state, with none of the work of running one."

Netlify spent a decade showing that a large share of the web does not need a server at all. That is why this announcement is worth reading closely. The company that made the case for functions is now saying where functions stop.

Why Netlify says functions were not enough

The post is direct about it, and the reasons are mostly about workloads that wait:

  • "Waiting is expensive. A function that spends ten seconds waiting for an AI model to finish its answer, or holding a session open while a user types their next message, occupies an entire instance for those ten seconds while doing almost nothing."
  • "A function responds and finishes, so it can't hold a WebSocket open."
  • "An Express or Hono app has to be reshaped into handlers or wrapped in an adapter before it can run as a function."

And the summary: "Serverless was designed around short, independent invocations, and these needs challenge that paradigm."

Netlify is just as direct about the old alternative. Describing what running a backend used to involve, it says: "It meant wrestling with Dockerfiles and Kubernetes, applying security patches, provisioning servers and scaling them up and down." That is the case for a managed long-running process, from a company that now offers one.

What it is, in Early Access

"Under the hood, an instance of your server is a long-lived Node.js process that handles many requests at the same time." Two Early Access details matter for how you design around it:

  • "During Early Access, a server scales up to 3 instances (1 on Free and Personal plans), and it always scales to zero after 5 minutes without requests."
  • For state that several instances must agree on, Netlify points to its own database: "With Netlify Database as the shared source of truth, several instances can serve the same room without drifting apart."

The question worth asking about your own app

The useful question here is not which platform is right. It is which of your endpoints spend their life waiting rather than computing. Those were never a good fit for a function:

  • Streaming an AI model's answer. Most of the time is spent waiting on someone else's tokens.
  • WebSockets. Chat, live dashboards, presence, collaborative editing: anything where the connection is the product.
  • Sessions that stay open while a person thinks between messages.
  • An existing Express, Hono or Fastify app that you would rather run as it is than cut into handlers.

A plain request that reads, computes and answers in a few hundred milliseconds is still a fine function. The split is about shape, not about how important the endpoint is.

Three things to check on any long-running backend

  1. When does in-memory state disappear? Memory belongs to one process. It is gone after a restart, a deploy, or a scale-to-zero, and a second instance never sees it. Netlify's own answer is a shared database. On any platform, keep anything you cannot afford to lose in a database or Redis, and treat memory as a cache.
  2. What happens when nobody is using it? A backend that scales to zero starts a fresh process on the next request, with empty memory and whatever start-up time your app has. One that stays running keeps both its memory and its warm caches. Neither is wrong, but you should design for the one you have.
  3. Do your clients reconnect? Every WebSocket eventually drops, because of a deploy, a restart or a network change. A client that reconnects and resubscribes on its own turns that into a blink instead of an outage.

How this looks on DeployBase

A Node.js app on DeployBase runs the start script from your package.json as one long-running process in its own container, and the process is restarted if it exits. It does not scale to zero, so in-memory state lasts until the next deploy or restart. It also does not scale out: there is one instance per app, so memory is never split across copies, and that one instance is your capacity. WebSockets pass through to the app. We checked one of the production apps on the platform today: a WebSocket handshake to its socket endpoint returned 101 Switching Protocols on both its custom domain and its .deploybase.io address.

Source: Netlify, "Netlify goes full stack: introducing Netlify Server", Eduardo Bouças, published 10 November 2026, read in full 12 November 2026. All quotations are from that post. DeployBase WebSocket check run on 12 November 2026.