These three run JavaScript in V8 isolates across a global network, and that is where the similarity stops. Underneath, they are three genuinely different answers to a question the industry has not settled: what should a JavaScript runtime at the edge actually be?
Cloudflare’s answer is that it should be a new platform. The runtime is a deliberate break from Node, with its own storage, its own coordination primitive and its own idea of what a stateful application looks like when there are no servers to be stateful on. You write to Cloudflare’s model, and in exchange you get capabilities nothing else here has.
Vercel’s answer is that the runtime should be invisible. The edge is a tier inside a framework, not a place you deploy to. Middleware, caching, revalidation and rendering are one mechanism, the runtime split between edge and Node is an implementation detail the framework manages, and the product you are buying is the workflow rather than the sandbox.
Deno’s answer is that it should be the web platform, server-side. The APIs are the standard ones, TypeScript runs without a build step, and the design goal is that code you write here is not code you wrote for a vendor. It is the most principled of the three and the one that most often asks you to give something up for the principle.
Those three sentences predict nearly every difference below: which packages work, where the API gaps bite, how you keep state, what your bill is measured in, and how hard it is to leave.
Key takeaways
- Cloudflare is the only one of the three with a first-party coordination primitive. If your application needs a single writer, a lock or a sequence number, that is the deciding feature, not a tiebreaker.
- Vercel’s edge runtime is narrowing toward the pre-render request path while general application code moves back to its Node runtime. Treat it as middleware, not as a general compute target.
- Deno Deploy gives you the smallest gap between local and production because the runtime is the same binary, and the highest chance that a specific npm package will not work.
- All three break on the same four things: filesystem access, child processes, native addons and raw sockets. The porting effort differs far less than the marketing does.
The same sandbox, three different surfaces around it
Every one of these runs your code in a V8 isolate. No process, no filesystem, no native modules, no node:net. That shared floor means the first day of a port goes identically on all three: the image library fails, the Postgres driver fails, and the logging SDK that reads a config file fails.
What differs is everything built on top of that floor, and it differs in ways that matter more than the floor does.
The API surface. Cloudflare implements a growing set of real node: builtins in the runtime itself. Deno implements web standards natively and Node compatibility as a deliberate layer on top, reachable through npm: specifiers. Vercel’s edge runtime publishes an explicit allowlist of what exists, which is smaller than either and intentionally so.
The escape hatch. This one is underrated. When your code does not fit the sandbox, what happens next? On Vercel you move that route to the Node runtime, which is one configuration line and the reason the platform tolerates a narrow edge surface. On Cloudflare you reach for containers or a Wasm module, which is more work. On Deno Deploy your options are narrower still.
The state story. Isolates are ephemeral and there are many of them. A module-scope variable is a per-isolate, per-location cache with no guarantees. What the platform gives you to solve that properly is the largest architectural difference of the three, and it is where Cloudflare is genuinely alone.
The unit of deployment. Cloudflare deploys a Worker: a script and its bindings. Vercel deploys a project: a build output with routes, functions, assets and cache rules derived from your framework. Deno Deploy deploys a module graph rooted at an entrypoint. These sound like details and they set how your repository is organised, how previews work, and what a rollback means.
Cloudflare Workers

Cloudflare is building an application platform that happens to be everywhere, and the tell is the primitives. Workers on their own are an isolate runtime like the others. Workers plus Durable Objects are something no other vendor in this comparison offers: an addressable, single-threaded object with its own storage that the platform guarantees exists exactly once globally. That is a coordination primitive, and coordination is what distributed compute is normally missing.
The practical shape of that: you want a rate limiter that actually limits, a document with a single writer, a game room, a queue consumer that must not double-process, or a WebSocket hub. On the other two platforms, all of those mean bringing an external service with its own latency and its own bill. On Cloudflare they are a class with an id.
The runtime is open source, which matters more than it sounds. You can read what a given node: builtin does rather than filing a ticket, and you run the same engine locally instead of a simulation. When something behaves differently in production, the difference is usually configuration rather than an undocumented divergence.
Where the API gaps bite. Node compatibility is behind a flag and is genuinely partial. The modules people trip on are the ones with an obvious platform reason to be absent, so the failures are at least predictable. Raw TCP exists through a platform-specific socket API rather than node:net, so database drivers need either that API or an HTTP-speaking proxy in front. The CPU budget is the other wall: a handler that parses and reshapes a large JSON payload in pure JavaScript will hit it, and the fix is either a Wasm module or moving that work somewhere with a different meter.
The coupling is real and worth naming. An application whose state lives in Durable Objects and KV is not portable. You can move the request-handling code to another isolate runtime in a day. You cannot move the coordination model, because nothing else has one. That is the trade: the strongest capability in the category in exchange for the strongest lock-in in the category, and it is a defensible trade as long as you make it knowingly.
Vercel

Vercel is not really selling you a runtime. It is selling a deployment workflow with a runtime inside it, and evaluating it as a runtime misses what people actually buy.
The workflow is the best in the category and it is not especially close. Push a branch, get a preview URL with the right environment variables and a comment on the pull request. Merge, get an atomic production deploy. Something is wrong, roll back instantly to a previous immutable build. Caching, revalidation and image handling are configured in the same place as the code that uses them. For a product team shipping a web application, that is worth a great deal and it is the reason the platform’s runtime constraints are tolerable.
The runtime picture has been moving, and the honest summary is that the edge runtime has been narrowing toward what it is genuinely good at. Middleware that inspects a request, checks a token, assigns an experiment bucket, rewrites a path and sets a header runs before the cache and finishes without touching an origin, which is a real latency win. General application code has been steering back toward Vercel’s Node.js runtime, where the full ecosystem works and the constraints are the familiar serverless ones rather than the isolate ones.
Where the API gaps bite. The edge runtime’s allowlist is narrower than Cloudflare’s or Deno’s, and you find out at build time, which is the good version of finding out. The sharper issue is that the edge tier is not where you resolve the incompatibility, it is where you decide to leave. Because the Node escape hatch is one line, the platform has less pressure to close gaps in the edge runtime than Cloudflare does, and the practical consequence is that you will use the edge runtime for less of your application over time.
The other gap is portability of the framework contract, not the runtime. Incremental regeneration, streaming, middleware semantics and image optimisation are framework features whose reference implementation is this platform. Code that uses them runs elsewhere to varying and changing degrees, which is the subject of hosting Next.js in detail. If you are evaluating Vercel as a runtime, evaluate the framework coupling as the actual lock-in, because that is where it lives.
Deno Deploy

Deno Deploy is the standards bet, and the pitch is coherent: the web platform already specified fetch, Request, Response, URL, WebCrypto, streams and workers, so a server runtime should implement those rather than invent parallel APIs. Add TypeScript that runs without a build step and a permission model that is explicit rather than ambient, and you have a runtime where the things Node made complicated are simple.
In practice the best part is the small gap between local and deployed. deno run is the same runtime as production, not an emulation of it. Dependency management has no node_modules directory and no install step; you import from npm:, jsr: or a URL and the runtime resolves it. For a team that has spent years fighting toolchain configuration, removing the build step for TypeScript alone changes the day-to-day.
Built-in KV and queue primitives cover the common stateful cases, which puts Deno between Vercel, where state is entirely external, and Cloudflare, where state is a whole product family. KV gives you a durable key-value store with transactional semantics good enough for most application state. It is not a coordination primitive in the Durable Objects sense, and if your problem is a single writer rather than a shared store, you will feel the difference.
Where the API gaps bite. npm compatibility is real and incomplete in an inconvenient place. Packages that stay inside standard APIs and the supported builtins work. Packages that assume a physical node_modules layout, that resolve paths relative to their own file location on disk, or that reach into Node internals, fail, and these tend to be exactly the mature infrastructure packages you did not expect to have a problem with. The gap has been closing for years and the tail is long.
The second gap is ecosystem surface rather than runtime surface. Fewer first-party integrations, fewer examples for your specific framework, fewer people who have already hit your error message. That is a genuine cost when you are debugging at an awkward hour, and it does not show up in any feature comparison.
Porting one application: where each one stops you
Take a reasonably ordinary Node service. HTTP routes, a Postgres database, JWT verification, an S3-compatible upload path, some image thumbnailing, structured logging to a vendor, and a scheduled job. Here is where each platform stops you, in the order you will hit it.
Routing and JWT verification. Fine everywhere. Web-standard Request and Response plus WebCrypto cover this on all three, and most modern JWT libraries already target that surface.
Postgres. Stops you on all three, differently. Cloudflare has a socket API and a connection-pooling service designed for this. Deno has a socket API in the runtime, so a native driver can work. Vercel’s edge runtime pushes you toward HTTP-capable drivers or toward moving the route to the Node runtime. In every case, be aware that a globally distributed compute tier in front of a single-region database pays the round trip on every query, which is the argument made properly in edge databases and serverless databases.
Object storage uploads. Fine everywhere, because S3-compatible APIs are HTTP. The wrinkle is request signing, which needs HMAC and is available through WebCrypto on all three, and the aws SDK, whose size and Node assumptions cause more trouble than the signing does.
Image thumbnailing. Stops you hard, everywhere. The native library is not loadable in any isolate. Your options are identical across all three: a Wasm image codec with a bundle size cost, the platform’s own image transformation service, or moving that route off the edge entirely. This is the single most common reason an edge port stalls and it is not a differentiator between these three.
Structured logging to a vendor. Usually works, occasionally does not, and the failure is instructive. Many vendor SDKs buffer in the background and flush on a timer, which is exactly the pattern that does not survive an isolate being evicted between requests. You want an SDK that writes over fetch inside the request, or the platform’s own post-response hook. Getting telemetry out of a runtime with no agent and no filesystem is its own problem, covered in APM for serverless and edge.
The scheduled job. All three have a scheduling mechanism. The question is what happens when the job needs more than the per-invocation compute budget, and the answer on all three is that it does not belong here. Scheduled work that grinds through data wants a container, not an isolate.
The conclusion from that walkthrough is worth stating plainly: the porting difficulty is driven by your dependency tree far more than by the platform. If your tree is clean, all three are a weekend. If it contains a native image pipeline and an ORM with a compiled engine, all three are a rewrite, and choosing between them on compatibility grounds is choosing between three similar amounts of work.
Needs first-hand data: Port the same small service to all three and record the actual time spent, split into build errors, runtime errors and dependency replacements. The ratio between those three categories is the number worth having, because it predicts how the next service will go and no vendor comparison will tell you.
State, coordination and the thing that decides most architectures
Ephemeral isolates spread across many locations have no shared memory. Every application eventually needs something that behaves like shared memory, and how each platform answers that is the most consequential difference here.
Cloudflare gives you the full range. KV for eventually consistent global reads, which is right for configuration and feature flags and wrong for anything that must be immediately correct. A relational store for structured data. Object storage for blobs. And Durable Objects for the case nothing else covers: an object that exists once, handles its requests one at a time, and has its own storage. A rate limiter, a lock, a counter that counts, a WebSocket room and a workflow state machine are all straightforward with that primitive and all awkward without it.
Deno Deploy gives you a KV store with transactional operations and queues. That covers most application state honestly and well. What it does not give you is single-writer serialisation, so patterns that need a lock need either optimistic concurrency with retries or an external service.
Vercel expects state to be external, which is philosophically consistent with treating the runtime as an implementation detail. That means an integration with a database or cache vendor, which is well-trodden and adds a second bill and a second latency budget.
The decision procedure is short. Write down the pieces of state your application has, and mark each one as either “a stale read is acceptable” or “a stale read is a bug.” If the second list is empty, all three platforms work. If it is not empty, either you are choosing Cloudflare or you are choosing an external service with a strong consistency story, and you should price that service into the comparison rather than leaving it out.
Needs first-hand data: Implement the same rate limiter three ways, using Durable Objects, using Deno KV with optimistic concurrency, and using an external store from a Vercel function, then measure added latency at the median and tail plus the error rate under contention. The contention behaviour, not the happy path, is what separates them.
How to choose
Are you already using the framework? If your application is a Next.js application and your team is productive in it, the workflow argument for Vercel is strong enough that runtime purity is a secondary concern. Fighting the reference implementation to save on hosting is a trade people regret.
Do you need coordination? If anything in your system needs a single writer, this question decides the answer before any other consideration. Cloudflare, or an external service you are willing to pay for and monitor.
How much does the local-to-production gap cost you? Teams that lose days to “works locally, fails deployed” should weight Deno heavily, because the same binary running in both places removes that failure mode structurally rather than by emulation.
Where is your data? If it is in one region and will stay there, the edge is buying you less than you think on all three, and a well-placed regional deployment may beat all of them. Decide data locality before compute placement, which is the whole argument in multi-region deployment.
How bad is the exit? Ranked by how hard it is to leave: Cloudflare if you adopt its storage primitives, Vercel if you adopt the framework’s platform-specific features, Deno Deploy least of all because the APIs are mostly standard. Weight that by how likely you actually are to leave, which for most teams is lower than they assume during evaluation.
| Cloudflare Workers | Vercel | Deno Deploy | |
|---|---|---|---|
| Core bet | The edge is a new platform | The edge is a framework tier | The edge is the web platform |
| Runtime | V8 isolate, own runtime, open source | V8 isolate subset, plus a Node runtime | V8 isolate, Deno, same binary locally |
| Node compatibility | Real builtins behind a flag, growing | Explicit narrow allowlist at the edge | Web standards first, npm layer on top |
| Escape hatch | Wasm or containers | Move the route to the Node runtime | Narrow |
| Coordination primitive | Durable Objects | External | KV with transactions, no single writer |
| Meter | Requests plus CPU milliseconds | Plan tier plus several usage dimensions | Requests plus compute, KV metered separately |
| TypeScript | Build step | Build step | Native, no build step |
| Hardest part of leaving | Storage and coordination primitives | Framework-specific platform features | Deno-specific APIs only |
My default, stated plainly. For an application that is mostly a request path with real state, Cloudflare Workers, accepting the coupling deliberately. For a product team shipping a framework application where velocity matters more than runtime ownership, Vercel, and do not pretend the framework coupling is not there. For a TypeScript team who value standards and a small dev-to-prod gap, Deno Deploy, budgeting a day for the npm packages that will not cooperate. The wider category, including the container and PaaS options that are frequently the right answer instead, is in hosting platforms for developers.
Frequently asked questions
Which of the three has the best Node.js compatibility?
Cloudflare and Deno are ahead of Vercel’s edge runtime, and they get there differently. Cloudflare implements node: builtins in the runtime behind a compatibility flag. Deno implements web standards natively with a Node compatibility layer reached through npm: specifiers. Vercel’s edge runtime is a deliberately narrow allowlist, on the reasoning that you should move incompatible code to its Node runtime rather than wait for the edge surface to grow. None of them run native addons, so a package with a compiled binding fails on all three regardless.
Can I run a stateful application like a chat room or a collaborative editor?
On Cloudflare, yes, and it is the best answer available: a Durable Object gives you a single addressable instance that serialises its own requests and can hold WebSocket connections. On Deno Deploy you can build it on KV with optimistic concurrency, which works and requires you to handle contention yourself. On Vercel you bring an external service. The pattern needs single-writer semantics, and only one of these three has that built in.
Is Vercel just Cloudflare Workers underneath?
Do not reason about it that way. Vercel’s edge runtime is a V8 isolate environment with a documented API surface, and what you are buying is the framework integration, the deployment workflow and the caching model rather than the specific isolate host. Whatever the infrastructure underneath is at any given moment, the API surface you code against is Vercel’s, the escape hatch to its Node runtime is Vercel’s, and the caching and revalidation semantics are the framework’s.
How do I pick if all three would technically work?
Pick on the thing that is hardest to change later. Runtime compatibility is a week of work. A coordination model is an architecture. A framework’s platform-specific features are the same. So decide by asking what your application needs to be correct, not what it needs to run, and let the compatibility investigation be a tiebreak rather than the decision.
Related reading
- Best hosting platforms for developers — the full category, including the container and PaaS options these three are often compared against by mistake.
- Best edge compute platforms — the wider field, including the WebAssembly runtimes that take a different route entirely.
- Best hosting platforms for Next.js — the compatibility matrix behind the Vercel framework coupling question.
- Best edge databases — why compute placement without data placement usually changes nothing.
- Best serverless function platforms — when a wall-clock meter and a real runtime are the better trade.
- Best multi-region deployment platforms — the data-first ordering that should precede any edge decision.