Deno Deploy is shutting down after the Deno team joined Cloudflare. The main alternatives, how they compare on runtime, data, background work and pricing, and how to move a TypeScript backend into your own AWS or GCP account.

Deno Deploy made it easy to put a TypeScript handler on a global network with Deno.serve, a built-in key-value store and Deno.cron, all without a build step. On October 9, 2026 the Deno team announced it is joining Cloudflare, with Deno Deploy shutting down six months later and the Deno runtime itself getting one more year of bug-fix and security releases.
That turns choosing a new home from a nice-to-have into a deadline: Deno Deploy will keep operating for six months from that announcement, and apps that use Deno KV, KV queues or Deno.cron need replacements for those as well as for the hosting. This guide compares the main Deno Deploy alternatives on runtime, data, background work and pricing, and shows how Encore moves a TypeScript backend with all three into your own AWS or GCP account.
Deno Deploy prices are from its pricing page, checked November 17, 2026: the Free plan includes 1 million requests and 10 hours of active CPU a month, Pro is $20 a month with 5 million requests, then $2 per million, and Builder is $200 a month.
Encore is a backend framework with built-in infrastructure for TypeScript and Go, and the three Deno Deploy features most apps lean on map onto its primitives: Deno KV data goes into a Postgres database, KV queues become a Pub/Sub topic with a subscription, and Deno.cron becomes a cron job, all declared in the same TypeScript file. encore run starts Postgres and the queue locally, and on deploy Encore provisions them in your own AWS or GCP account as the infrastructure docs list. Encore runs TypeScript on Node.js rather than on Deno's Rust-based runtime, so Deno.* calls are replaced along the way while most application logic and npm packages carry over.
Run in your terminal to get started locally.
A link shortener is a typical Deno Deploy app, with links in KV, clicks counted through a queue and a nightly cleanup. The migration creates a links table keyed by slug and a link_clicks table with a click_id UUID PRIMARY KEY, a slug that references links and a clicked_at timestamp. The links folder also gets an encore.service.ts that exports new Service("links"), and the service looks like this:
// links/links.ts
import { api, APIError } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";
import { Topic, Subscription } from "encore.dev/pubsub";
import { CronJob } from "encore.dev/cron";
import { randomBytes, randomUUID } from "node:crypto";
// Replaces Deno KV: Postgres on RDS or Cloud SQL, started locally by `encore run`.
const db = new SQLDatabase("links", { migrations: "./migrations" });
interface Click {
clickId: string;
slug: string;
at: string;
}
// Replaces kv.enqueue and kv.listenQueue: SNS/SQS on AWS, Pub/Sub on GCP.
export const clicks = new Topic<Click>("link-clicks", {
deliveryGuarantee: "at-least-once",
});
export const shorten = api(
{ expose: true, method: "POST", path: "/links" },
async ({ url }: { url: string }): Promise<{ slug: string }> => {
let parsed: URL;
try {
parsed = new URL(url);
} catch {
throw APIError.invalidArgument("invalid url");
}
if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
throw APIError.invalidArgument("http or https url required");
}
const slug = randomBytes(6).toString("base64url");
await db.exec`INSERT INTO links (slug, url) VALUES (${slug}, ${parsed.toString()})`;
return { slug };
},
);
export const lookup = api(
{ expose: true, method: "GET", path: "/links/:slug" },
async ({ slug }: { slug: string }): Promise<{ url: string; clicks: number }> => {
const row = await db.queryRow<{ url: string; clicks: number }>`
SELECT l.url, (SELECT count(*)::int FROM link_clicks c WHERE c.slug = l.slug) AS clicks
FROM links l WHERE l.slug = ${slug}`;
if (!row) throw APIError.notFound("link not found");
await clicks.publish({ clickId: randomUUID(), slug, at: new Date().toISOString() });
return row;
},
);
// The click ID is the primary key, so a redelivered message is stored once.
const _ = new Subscription(clicks, "record-click", {
handler: async (c) => {
await db.exec`
INSERT INTO link_clicks (click_id, slug, clicked_at)
VALUES (${c.clickId}::uuid, ${c.slug}, ${c.at}::timestamptz)
ON CONFLICT (click_id) DO NOTHING`;
},
});
// Replaces Deno.cron: called by the Encore platform every day at 03:00 UTC.
export const pruneClicks = api({ expose: false }, async (): Promise<{ deleted: number }> => {
const row = await db.queryRow<{ deleted: number }>`
WITH gone AS (
DELETE FROM link_clicks WHERE clicked_at < now() - interval '90 days' RETURNING 1
)
SELECT count(*)::int AS deleted FROM gone`;
return { deleted: row?.deleted ?? 0 };
});
const __ = new CronJob("prune-clicks", {
title: "Delete click events older than 90 days",
schedule: "0 3 * * *",
endpoint: pruneClicks,
});
The click is recorded by the subscriber after the response, so the next lookup shows it, and a redelivered message hits the click_id primary key and is ignored. The SQL was checked against Postgres 17, including the duplicate insert and the 90-day cleanup. Cron jobs do not run locally, so you test pruneClicks by calling it from the local development dashboard, and in the cloud the job is managed by the Encore platform with no scheduler to set up, as the cron docs describe.
Deno KV gave you a key-value API with atomic operations, and Postgres gives you tables, joins and transactions in its place, which suits most apps once their data outgrows a single key prefix. For data that only needs caching, Encore also has Redis caching backed by ElastiCache or Memorystore. With the queue and schedule living in the code, an AI coding agent porting the app from Deno can replace kv.enqueue and Deno.cron in the same change as the handlers and test the result locally before anything deploys.
Best fit: TypeScript backends leaving Deno Deploy that need a relational database, queues and scheduled jobs in their own AWS or GCP account.
Workers is where the Deno team went, with Ryan Dahl now working on celld, a project built on the Workers and Durable Objects programming model, and paying Deno Deploy customers get migration help to it. Workers run on Cloudflare's workerd runtime, which supports web-standard APIs like fetch, Request and Response that Deno code already uses, with Workers KV, D1, R2, Queues, Cron Triggers and Durable Objects for state. The Workers Paid plan is a $5 monthly minimum that includes 10 million requests and 30 million CPU milliseconds, then $0.30 per million requests and $0.02 per million CPU milliseconds, from Cloudflare's pricing docs checked November 17, 2026.
Code that calls Deno.* APIs, opens raw TCP connections to a database without Hyperdrive, or relies on long-running processes needs rework, and Workers KV is eventually consistent, so code that relied on Deno KV's atomic operations moves to Durable Objects or D1 instead.
Best fit: edge functions and APIs that want the official migration path and Cloudflare's global network.
Supabase Edge Functions run TypeScript on Supabase's open source Edge Runtime, which is built on Deno, so Deno-style imports and Deno.serve handlers often move with small changes. Functions sit next to a Supabase Postgres database, with pg_cron and Supabase Queues for scheduling and background work. The Free plan includes 500,000 invocations a month and paid plans 2 million, then $2 per million, from Supabase's Edge Functions pricing page checked November 17, 2026.
Functions have execution time and memory limits, so long-running work belongs elsewhere, and the runtime's future depends on Supabase's work rather than on the Deno team.
Best fit: small Deno functions that already use, or can move to, a Supabase database.
Netlify Edge Functions run in a secure runtime based on Deno on Netlify's network, close to the user, and are usually paired with a frontend site on Netlify. Netlify Blobs stores files and key-value data, and Netlify's scheduled and background functions handle recurring and long-running work, though those run as regular serverless functions rather than at the edge.
It is the shortest path for a Deno Deploy app that is mostly a website with some request-time logic, and a weak fit for a backend with its own database and queues.
Best fit: frontend sites on Netlify that need middleware-style logic at the edge.
Cloud Run runs any container, so a Deno server can keep running as it is in a denoland/deno image while you plan a longer-term runtime. It scales to zero, bills per vCPU-second and GB-second with a monthly free tier, and connects to Cloud SQL, Firestore, Pub/Sub and Cloud Scheduler for the data and background work Deno Deploy covered.
You take on the Dockerfile, the service configuration, IAM, and the database and queue setup, usually in Terraform, and the Deno runtime itself stops getting releases after the one-year support window.
Best fit: teams on GCP that want to keep the Deno server running in a container while they decide what comes next.
Fly.io runs containers as Machines in regions you choose, which suits a long-running Deno server that needs to stay close to users. Its pricing page, checked November 17, 2026, lists a shared-cpu-1x Machine with 256 MB at $2.19 a month and 1 GB at $6.70, billed by the second while running, and Fly Managed Postgres starts at $38 a month for the Basic plan.
There is no built-in queue or cron, so background work runs in its own Machines, and the Deno runtime support window applies here too.
Best fit: long-running servers in a few regions, where the app keeps its Deno code for now.
Pick Cloudflare Workers if the app is mainly edge functions and you want the migration path the Deno team is supporting. Pick Supabase or Netlify Edge Functions for small functions that already use a Deno-based runtime and sit next to a Supabase database or a Netlify site. Pick Cloud Run or Fly.io to keep a Deno server running in a container while you plan a longer-term runtime. Pick Encore when the app is a backend that needs a relational database, queues and scheduled jobs, and you want them declared in TypeScript, running locally with encore run and provisioned in your own AWS or GCP account, where a hosting provider's next change of plans does not set your deadline.
Deno Deploy is shutting down: on October 9, 2026 Ryan Dahl announced that the Deno team is joining Cloudflare and that Deno Deploy will keep operating for six months before shutting down. Deno Deploy Classic had already shut down on July 20, 2026, and paying customers get migration help to Cloudflare Workers.
Cloudflare Workers is the official migration path and the closest match for edge functions. For a backend that needs a relational database, queues and scheduled jobs, a container platform such as Google Cloud Run or Fly.io is a better fit, and Supabase or Netlify Edge Functions suit small functions that already run on a Deno-based runtime.
On Cloudflare, Workers KV or Durable Objects replace Deno KV, Cloudflare Queues replace KV queues and Cron Triggers replace Deno.cron. On a container platform the usual replacements are a database, a queue and a scheduled job in the same cloud as the service.
With Encore, rewrite the Deno.serve routes as api endpoints, store what lived in Deno KV in a Postgres database declared with new SQLDatabase, publish queue messages to a Topic handled by a Subscription, and schedule the Deno.cron job with a CronJob. encore run starts Postgres and the queue locally, and a git push deploys to Fargate, RDS and SNS/SQS in your AWS account, with cron jobs managed by the Encore platform.
Deploy to your cloud on AWS and Google Cloud
without managing infrastructure
Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.