Deno Subhosting - Run Custom Code on Your Platform

TL;DR

TL;DR: Deno Subhosting is a multi-tenant infrastructure layer that lets you embed secure, scalable JavaScript/TypeScript code execution into any SaaS product — using one API call per deployment, running on Deno Deploy’s global network.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: deno.com/subhosting — verified Aug 2026
• Source repository: no public source repo (proprietary hosted product)
• License: proprietary (Deno commercial product)
• HN launch thread: news.ycombinator.com/item?id=41687628 — 37 points
• Pricing: free tier available, scales to 100,000 users on Builder Plan (verified at deno.com/pricing)
• Source last checked: 2026-08-24

What Is Deno Subhosting?

Deno Subhosting is an infrastructure product from Deno Land that lets platforms embed custom code execution for their end users. Instead of building your own sandboxed runtime, Subhosting provides a programmatic way to deploy JavaScript or TypeScript on behalf of any number of tenants — with the security, scaling, and monitoring handled by Deno’s edge network.

The product sits at the intersection of two use cases:

1. Platform extensibility — Allow your users to write custom logic (webhooks, transformations, automations) that runs on your infrastructure, not theirs.
2. White-label edge functions — Power a Netflix-style or Netlify-style edge functions product without managing the underlying runtime.

“Built with SaaS scale and security in mind, Subhosting is easily configurable for any use case, using an SDK and a simple API. It is the same infrastructure that powers Deno Deploy, now available for your product.” — Deno Subhosting homepage

Key Differentiators

According to the product comparison on the landing page, Subhosting differs from other platforms in several ways:

• Runs standard JS and TS — No proprietary runtime or DSL lock-in. Your users write plain JavaScript or TypeScript.
• One API call to deploy — Deployments are created with a single API call, not a complex CI/CD pipeline.
• Built-in OTEL with easy export — Observability is included, with OpenTelemetry-compatible tracing and metrics.
• True white-labeling — The runtime is invisible to end users; your branding fronts everything.
• Free tier available — A free plan exists; scaling to 100,000+ users is available on the Builder Plan.

Setup Workflow

Prerequisites

• A Deno Deploy account (sign up at console.deno.co)
• An API key from the Deno Deploy dashboard
• curl or an HTTP client to make API calls

Step 1: Create an App

An “app” in Subhosting is a isolated deployment target. You create one via the REST API:

curl -X POST https://api.deno.com/v2/apps \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "my-platform-app"}'

The response returns an app_id you use for all subsequent deployments.

Step 2: Deploy Code for a Tenant

Subhosting’s core value is deploying per-user or per-tenant code with a single call:

curl -X POST https://api.deno.com/v2/apps/{app_id}/deploy \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "deployment": {
      "entryPointUrl": "main.ts",
      "files": {
        "main.ts": "export default { fetch(req) { return new Response(\"Hello\"); } }"
      }
    },
    "tenantId": "user_123"
  }'

This deploys an isolated version of the code for tenant user_123. Each tenant gets their own runtime context, invisible to other tenants.

Step 3: Route Requests

Once deployed, Subhosting provides a unique endpoint for each tenant:

https://user_123.app_id.deno.dev/

Requests to this URL are routed to that tenant’s deployed code. No configuration, no nginx rewrites — Deno handles the routing.

Step 4: Monitor with OTEL

Subhosting emits OpenTelemetry traces automatically. You can export them to any OTEL-compatible backend:

curl https://api.deno.com/v2/apps/{app_id}/otel \
  -H "Authorization: Bearer YOUR_API_KEY"

Real-World Use Cases

Deno lists three public case studies on the Subhosting page:

1. Netlify — Used Subhosting to power Netlify Edge Functions. Mathias Biilmann, Netlify CEO, is quoted: “We chose Deno because it is optimized for performance and does not force proprietary APIs onto our users.”
2. Slack — Used Deno to build their new platform, saving months of engineering effort.
3. Deco.cx — Brazil’s top e-commerce platform used Subhosting to drive 5x faster page load speeds for client storefronts.

How It Compares to Alternatives

The Subhosting comparison table on its own page highlights three categories where it differs from “other platforms” (implying AWS Lambda@Edge, Cloudflare Workers, or Vercel Edge Functions):

| Feature | Subhosting | Other platforms | |---|---|---| | Runtime | Standard JS/TS | Proprietary runtime | | Deployments | One API call | Complex CI/CD | | Analytics | Built-in OTEL | Proprietary dashboard | | White-labeling | Yes | No |

The runtime claim is notable — Cloudflare Workers uses V8 isolates (not standard Node.js APIs), and some alternatives require learning a proprietary surface. Subhosting claims standard Deno runtime compatibility, which would mean Node.js compatibility mode (node-compat) and standard Web APIs are available.

Practical Evaluation Checklist

If you are evaluating Deno Subhosting for your product, here is a practical checklist:

• Runtime compatibility — Does your code need Node.js built-ins? Deno Subhosting runs standard Deno, which has different built-in APIs than Node.js. Check the Deno runtime docs for the full API surface.
• Cold start performance — Subhosting runs on Deno Deploy’s edge network. Deno Deploy claims 10B+ requests/month at the time of writing. Cold start latency depends on your deployment size and whether the instance is warm.
• Pricing model — The free tier is available but limits apply. The Builder Plan supports up to 100,000 users. Enterprise pricing is by inquiry.
• Multi-tenancy model — Subhosting isolates tenants at the runtime level. If you need stronger sandboxing (separate processes, separate network namespaces), verify with Deno’s enterprise team.
• GitOps integration — Subhosting is API-first. If you want Git-backed deployments, you need to build the Git hook layer yourself or use Deno Deploy’s built-in GitHub integration separately.

Security Notes

• Tenants run in isolated contexts within Deno Deploy’s multi-tenant infrastructure.
• Deno Subhosting is built on Deno Deploy, which has ISO 27001:2022 and SOC 2 Type II certifications (attested by Prescient Assurance).
• Because Subhosting uses Deno’s permission system, code runs with explicit permission grants — network access, file system access, and environment variables must all be explicitly allowed.
• White-labeling means your users never see Deno branding — the endpoint is tenant.yourdomain.com, not tenant.deno.dev.

FAQ

Q: Can I use Node.js packages in Subhosting? A: Deno supports many Node.js compatibility packages via the npm: specifier. Whether a specific package works depends on whether it relies on Node.js native addons (.node files) which Deno does not support.

Q: How does Subhosting differ from just using Deno Deploy directly? A: Deno Deploy is for deploying your own code to the edge. Subhosting is for deploying code on behalf of many separate tenants — with isolated runtime contexts, per-tenant analytics, and a management API designed for platform builders.

Q: Is there a source repository I can audit? A: Subhosting itself is a proprietary commercial product without a public source repo. The underlying Deno runtime is open source (github.com/denoland/deno) under a MIT license.

Q: What language versions does Subhosting support? A: Subhosting runs Deno — JavaScript (ES2023+) and TypeScript (5.x) are natively supported without a build step.

Q: Does Subhosting support WebSockets or streaming responses? A: Deno Deploy supports streaming responses and WebSockets. Whether Subhosting exposes these capabilities fully depends on your use case — verify with Deno’s enterprise team for streaming-intensive workloads.

Conclusion

Deno Subhosting targets a specific niche: platform builders who want to add programmable extensibility without building their own runtime infrastructure. The pitch is compelling — one API call, standard JS/TS, true white-labeling, built-in OTEL, backed by Deno’s global edge network used by Netlify and Slack.

The enterprise B2B nature of the product means it is not a tool every developer will use directly — but if you are building a SaaS platform and need per-tenant code execution, Subhosting is purpose-built for exactly that problem. The free tier lets you prototype before committing to a paid plan.