Skip to content

Top 32 Deno Interview Questions and Answers [2026]

November 16, 2026 27 min read
Deno interview guide by Second Talent
TL;DR: Deno interviews in 2026 test whether a candidate can scope permissions for a real service, run an existing npm project without surprises, and judge where Deno still fits. Candidates should know Deno 2.9.8 (October 21, 2026), the 2.8 and 2.9 default changes (npm-first installs, Node timers, test sanitizers off, a 24-hour dependency age floor, compression off in Deno.serve), JSR publishing, Deno KV, deno compile, and what the October 9, 2026 Cloudflare announcement means for Deno Deploy.

Deno 2.9 turned off automatic response compression in Deno.serve and started skipping npm and JSR versions published less than 24 hours ago, so two upgrades that look like patch bumps change production behavior.

The current release is Deno 2.9.8. On October 9, 2026 the Deno team announced it is joining Cloudflare, which puts a time limit on Deno Deploy and on runtime development.

The questions below are for senior backend and full-stack developers who run Deno in production or are being hired to maintain or migrate a Deno codebase, with four find-the-bug rounds.

Key takeaways
  1. 1Since Deno 2.9, installs skip dependency versions published less than 24 hours ago unless minimumDependencyAge says otherwise.
  2. 2Deno Deploy runs for six months after the October 9, 2026 Cloudflare announcement, and the runtime gets one more year of monthly fix releases.
  3. 3Since Deno 2.8, sanitizeOps and sanitizeResources in Deno.test default to false, so leaked timers and handles no longer fail a test.
  4. 4A Deno KV value is capped at 64 KiB and a key at 2,048 bytes after serialization, which rules out storing documents or blobs directly.

Runtime Fundamentals

1. What does Deno give you out of the box that a Node.js project assembles from packages?

A TypeScript-aware runtime plus a formatter, linter, test runner, type checker, bundler, task runner, package manager, coverage tool and single-binary compiler, all in one executable. deno fmt, deno lint, deno test, deno check, deno bundle, deno task, deno install, deno coverage and deno compile share one config file and one module graph.

The other defining choices are a permission sandbox that denies file, network, environment and subprocess access until granted, web-standard APIs (fetch, Request, Response, Web Streams, Web Crypto) as the primary interface, and ES modules first.

A strong candidate adds the cost: the tools are good defaults, but a team that already standardized on ESLint plugins or a specific test framework will either keep running those through Deno or accept the built-in feature set.

2. How does Deno run TypeScript, and when does it type-check?

Deno strips types and runs the code without type checking by default on deno run. Type errors surface through deno check, the LSP in the editor, or deno test and deno compile, which check the graph they load.

The bundled compiler is TypeScript 6.0.3 since Deno 2.8, a release the TypeScript team uses to land deprecations before 7.0.

Interviewers listen for a candidate who puts deno check in CI because deno run alone lets a type error reach production, and knows that compilerOptions in deno.json replaces most of a tsconfig.json.

A weak answer says "Deno compiles TypeScript to JavaScript first" and stops there, which misses that checking and execution are separate steps.

3. How do you write an HTTP server, and what is the difference between deno run and deno serve?

Deno.serve takes a handler that receives a web-standard Request and returns a Response. It listens on port 8000 by default, supports HTTP/2, and returns an HttpServer whose shutdown() drains connections.

Per the deno serve reference, the alternative is a module whose default export satisfies Deno.ServeDefaultExport, which lets Deno own the listen options and scale across cores with --parallel.

// server.ts, run with: deno serve --parallel -N server.ts
export default {
  async fetch(req: Request): Promise<Response> {
    const url = new URL(req.url);
    if (url.pathname === "/health") return new Response("ok");
    if (req.method === "POST" && url.pathname === "/echo") {
      return Response.json(await req.json());
    }
    return new Response("not found", { status: 404 });
  },
} satisfies Deno.ServeDefaultExport;

Use deno serve when the program is an HTTP server and nothing else; use deno run with Deno.serve() when the server is one part of a larger process.

A senior candidate mentions that --parallel runs separate isolates, so in-memory caches and counters are per worker, not shared.

4. Why did responses get larger after a team upgraded to Deno 2.9?

Deno 2.9 disabled automatic body compression in Deno.serve. Before 2.9, the server compressed compressible responses with gzip or brotli when the client sent a matching Accept-Encoding.

Now it does that only with automaticCompression: true on the server or DENO_SERVE_AUTOMATIC_COMPRESSION=1 in the environment, per the 2.9 release post.

Deno.serve({ automaticCompression: true }, handler);

The strong answer goes past the flag: in most production setups a CDN or reverse proxy should compress, so the default change is a reason to check where compression happens, not to switch it back on blindly.

Compressing in both places wastes CPU, and compressing responses that mix secrets with attacker-controlled input over TLS reopens BREACH-style questions.

5. How does module resolution work: URLs, jsr:, npm: and bare specifiers?

Deno resolves four kinds of specifiers. Relative and absolute paths and https: URLs load directly. jsr:@scope/name@range pulls from JSR, and npm:name@range pulls from npm into a global cache.

Bare specifiers such as "@std/assert" or "chalk" resolve through the imports map in deno.json or through package.json dependencies.

{
  "imports": {
    "@std/assert": "jsr:@std/assert@^1.0.0",
    "hono": "npm:hono@^4"
  },
  "scopes": {
    "./legacy/": { "@std/assert": "jsr:@std/assert@^0.224.0" }
  }
}

Inline npm: and jsr: specifiers work for scripts, but a team codebase should centralize versions in the import map or a workspace catalog: so upgrades happen in one place.

Since Deno 2.8, deno add express with no prefix writes npm:express; JSR packages need the jsr: prefix.

6. What is the difference between Deno's global cache and a node_modules directory?

By default Deno stores npm packages in a global cache and creates no node_modules. The Node compatibility docs list three nodeModulesDir modes:

  • none: the default without a package.json; packages resolve from the global cache.
  • auto: Deno creates and updates a local node_modules on demand, for bundlers and packages that expect files on disk.
  • manual: the default when a package.json exists; you run deno install (or npm, pnpm) yourself.

The default local layout is isolated, similar to pnpm, with real files under node_modules/.deno/ and symlinks on top. Deno 2.8 added "nodeModulesLinker": "hoisted", which requires manual mode, for tools that walk a flat tree.

A candidate who has run Next.js or Vite on Deno will know why those projects sit in manual mode.

Permissions and Security

7. Walk through the permission flags you would grant a typical API service.

Grant the narrowest scope each flag accepts. The permissions reference covers read (-R), write (-W), net (-N), env (-E), sys (-S), run, ffi and import, each with a matching --deny-* flag that takes precedence over the allow flag.

deno run \
  --allow-net=0.0.0.0:8000,db.internal:5432,api.stripe.com \
  --allow-env=DATABASE_URL,STRIPE_KEY,PORT \
  --allow-read=./static,./config \
  main.ts

Points a strong candidate makes unprompted:

  • A bare --allow-net grants the whole category; hostnames do not include subdomains unless written as *.example.com.
  • --allow-env with a list prevents a dependency from reading every secret in the environment.
  • -A turns the sandbox off and has the same security properties as Node.js, per the docs.
  • Prompts only appear on a TTY, so a service in a container fails fast with Deno.errors.NotCapable instead of hanging.

8. Why does the docs page treat --allow-run and --allow-ffi as equivalent to --allow-all?

A subprocess runs as a separate program with its own permissions, and an FFI library runs native code in the same process that can make system calls directly.

Neither is constrained by Deno's sandbox. --allow-run=deno is the extreme case: the script can start another deno with -A.

Combinations matter too. --allow-write plus a scoped --allow-run=git lets code overwrite the allowed binary if it sits in a writable path.

The reference also notes that spawning a child with an LD_* or DYLD_* variable, such as LD_PRELOAD, requires unscoped --allow-run, because those variables can inject a shared library into any allowed program.

A senior candidate reviews --allow-run lists in the same review as the Dockerfile.

9. Which module loads need no permission, and which do?

The static module graph loads without --allow-read or --allow-net.

Local files in the graph, npm: packages and a list of trusted hosts are allowed by default: deno.land, jsr.io, esm.sh, raw.esm.sh, cdn.jsdelivr.net, raw.githubusercontent.com and gist.githubusercontent.com.

Any other host needs --allow-import=host.

Runtime behavior is different. A dynamic import(someVariable) that cannot be analyzed statically is checked against --allow-read or --allow-import when it runs, and a Web Worker loaded from a local file needs --allow-read.

Once code runs, every file read and request goes through the permission system. A weak answer assumes that because import of a URL worked, fetch to the same host will too.

10. How do you store permissions in config instead of repeating flags?

Since Deno 2.5, deno.json accepts named permission sets, selected with -P (or --permission-set). A set named default applies when -P has no name, and test, bench and compile can carry their own permissions.

{
  "permissions": {
    "default": {
      "net": ["0.0.0.0:8000", "db.internal:5432"],
      "env": ["DATABASE_URL", "PORT"],
      "read": ["./static"]
    },
    "migrate": {
      "net": ["db.internal:5432"],
      "env": ["DATABASE_URL"],
      "read": ["./migrations"]
    }
  },
  "test": {
    "permissions": { "read": ["./fixtures"], "env": true }
  }
}

Run them as deno run -P main.ts and deno run -P=migrate migrate.ts. Per the deno.json reference, if test permissions exist and you run deno test without a permission flag, Deno stops with "Test permissions were found in the config file.

Did you mean to run with -P?" The point for reviewers: the permission surface becomes a diffable file in the repository.

11. How do you find out which permissions a program uses before you tighten them?

Run it under the permission audit log. Setting DENO_AUDIT_PERMISSIONS to a file path writes one JSON line per access, allowed or denied, with the permission name and value.

Setting it to otel emits each access as an OpenTelemetry log record through the exporter configured by OTEL_DENO, and DENO_TRACE_PERMISSIONS=1 adds a stack trace to each entry.

DENO_AUDIT_PERMISSIONS=./perm-audit.jsonl DENO_TRACE_PERMISSIONS=1 \
  deno run -A main.ts
# then derive --allow-* lists from the distinct permission/value pairs

The workflow candidates should describe: run the test suite and a staging soak with -A and auditing on, build the allow lists from the log, then switch production to those lists and watch for NotCapable errors.

The stack traces tell you which dependency asked, which is how teams catch a logging library reading the whole environment.

12. Find the bug: a permission setup that works locally and fails in CI.

// report.ts
const token = Deno.env.get("GITHUB_TOKEN");
const res = await fetch("https://api.github.com/repos/acme/app/issues", {
  headers: { Authorization: `Bearer ${token}` },
});
await Deno.writeTextFile("./out/issues.json", await res.text());

// CI step
// deno run --allow-net=github.com --allow-write=./out report.ts

Bugs:

  • Wrong host: --allow-net=github.com does not cover api.github.com, because hostnames exclude subdomains.
  • Missing env permission: Deno.env.get needs --allow-env=GITHUB_TOKEN.
  • Why it passed locally: on a developer's terminal Deno prompted and the developer pressed y twice. CI has no TTY, so the same calls throw NotCapable.

Fix: --allow-net=api.github.com --allow-env=GITHUB_TOKEN --allow-write=./out, or a named permission set, plus --no-prompt in local scripts so developers see the same failure CI does.

A strong candidate also checks res.ok before writing the body.

npm and Node.js Compatibility

13. How do you run an existing Node.js project on Deno?

Run deno install, then deno task <script> or deno run with the permissions the code needs.

Deno reads package.json: dependencies install into node_modules, scripts run through deno task in Deno's cross-platform shell, "type" is respected, and since 2.9 engines mismatches print a warning.

Without the install step Deno fails with "Deno expects the node_modules/ directory to be up to date. Did you forget to run deno install?"

Since Deno 2.9, the first deno install in a project with package-lock.json, pnpm-lock.yaml, yarn.lock or bun.lock and no deno.lock seeds deno.lock from it, keeping the resolved versions and integrity hashes.

A candidate who migrated a project should name the gaps: a script that calls node still runs Node, native addons may need lifecycle scripts approved, and code that relies on CommonJS detection in .js files needs a fix (question 16).

14. What happens to npm lifecycle scripts such as postinstall?

Deno does not run them by default. Packages that build or download a native binding in postinstall install without it and fail at import, and deno install prints a notice to run deno approve-scripts.

You can approve per package with deno install --allow-scripts=npm:duckdb, or record the approvals in config with deno approve-scripts (added in 2.6).

The interview value is the reasoning: install scripts are the main path for supply-chain malware on npm, so an allow list reviewed in a pull request beats npm's run-everything default.

A strong candidate pairs it with the 2.9 minimum dependency age and deno audit, and knows the age floor can be tuned in deno.json or with min-release-age in .npmrc.

15. Which Node globals exist in Deno, and which do not?

Per the Node compatibility docs: process is available everywhere, Buffer is not global in your own code and must come from node:buffer, __dirname and __filename are undefined in ES modules (use import.meta.dirname and import.meta.filename), and require() exists in CommonJS files.

Since 2.8, setTimeout and setInterval use Node semantics.

Deno 2.9 reports process.version as v26.3.0 and Node-API version 10, so packages that gate on the Node version see a modern runtime.

Since 2.6, @types/node declarations are included out of the box, and since 2.8 the no-process-global lint rule is off by default.

16. How does Deno decide a file is CommonJS, and what breaks?

A .cjs extension always means CommonJS. A .js file is CommonJS only when the nearest package.json has "type": "commonjs".

Deno does not inspect file contents to detect CommonJS unless you pass --unstable-detect-cjs, so a .js file that calls require in a project without that field fails with a hint listing the three fixes.

// From an ES module, create require explicitly:
import { createRequire } from "node:module";
const require = createRequire(import.meta.url);
const legacy = require("./legacy-config.cjs");

Deno's require() can load ES modules that have no top-level await in their graph, matching Node. CommonJS resolution needs a local node_modules and usually -R and -E.

A weak answer suggests rewriting everything to ESM before the migration; a senior one renames the few CommonJS entry points to .cjs and moves on.

17. Find the bugs: an Express server copied from a Node project.

// main.ts, run with: deno run -N main.ts
import express from "npm:express@5";

const app = express();

app.get("/", (_req, res) => {
  res.sendFile(__dirname + "/public/index.html");
});

app.get("/token", (_req, res) => {
  const encoded = Buffer.from(process.env.API_SECRET!).toString("base64");
  res.json({ encoded });
});

app.listen(3000);

Bugs:

  • __dirname is undefined in an ES module; use import.meta.dirname and build the path with node:path.
  • Buffer is not a global in your own code; import it from node:buffer.
  • Missing permissions: sendFile needs -R on ./public, and process.env.API_SECRET needs --allow-env=API_SECRET. Express may read more environment variables, so the audit log from question 11 is the quick way to find them.
  • Security, unrelated to Deno: the route hands out a reversible encoding of a secret to any caller.

The npm:express@5 default import itself is correct. A candidate who spots the two runtime bugs and the permission gap in a minute has run real Node code on Deno.

18. Find the bug: a debounce helper after upgrading to Deno 2.8.

const timers = new Map<string, number>();

export function debounce(key: string, fn: () => void, ms: number): void {
  clearTimeout(timers.get(key));
  timers.set(key, setTimeout(fn, ms));
}

Bug: since Deno 2.8, setTimeout returns Node's Timeout object instead of a number, and the Node type declarations are included by default, so deno check rejects timers.set(key, setTimeout(...)) against a Map<string, number>.

Code that did arithmetic on timer IDs, compared them with === to numbers or serialized them to JSON breaks at runtime too, as the 2.8 post warns.

Fix: type the map as Map<string, ReturnType<typeof setTimeout>>. Strong candidates mention that the same code now behaves like Node, which removes a long-standing difference for libraries shared between the two runtimes.

Config, Tooling and JSR

19. What goes in deno.json for a production service?

Imports, tasks, permissions, lockfile settings, compiler options, lint and fmt settings, and the dependency age policy. A compact example a candidate might write on a whiteboard:

{
  "imports": {
    "@std/assert": "jsr:@std/assert@^1.0.0",
    "hono": "npm:hono@^4"
  },
  "tasks": {
    "dev": "deno run -P --watch main.ts",
    "check": "deno check main.ts && deno lint && deno fmt --check",
    "build": {
      "command": "deno run -A build.ts",
      "files": ["src/**/*.ts"],
      "output": ["dist/**"]
    }
  },
  "lock": { "frozen": true },
  "minimumDependencyAge": "P3D",
  "compilerOptions": { "strict": true }
}

The details worth probing: "lock": { "frozen": true } makes any change to resolved versions an error, which belongs in CI; the task object form with files and output enables 2.9's input-based task caching; and minimumDependencyAge takes an ISO-8601 duration such as P3D, a number of minutes, a date, or 0 to disable the 24-hour default.

A candidate who adds "exclude" entries for the company's own packages under minimumDependencyAge has hit the problem in practice.

20. How do workspaces, links and catalogs work in a Deno monorepo?

A root deno.json lists members under "workspace", each member has its own deno.json with a name and exports, and members import each other by package name.

Deno 2.8 added the pnpm-style catalog: protocol so versions live once in the root and members reference them by name.

Deno 2.9 stabilized the "links" field and added deno link and deno unlink, which point a dependency at a local checkout outside the workspace, the Deno answer to npm link.

It also added deno list and the preferPackageJson setting, which makes deno add write to package.json in hybrid repos. A senior candidate explains how they keep a Deno workspace and a package.json workspace from drifting when both exist.

21. What is JSR, and what are slow types?

JSR is a TypeScript-first registry that accepts source TypeScript, generates documentation and an npm-compatible build, and serves packages to Deno, Node, Bun and browsers.

Packages are scoped (@scope/name), and npm users install them through the compatibility layer, for example as npm:@jsr/std__encoding@1.

Per the JSR slow types docs, a slow type is an exported type that is not written explicitly, such as a public function with no return type or a class property typed only by its initializer.

Slow types make consumers type-check more slowly, and JSR cannot generate declarations for the npm layer or full docs.

// Slow: return type must be inferred
export function slug(s: string) {
  return s.toLowerCase().replaceAll(" ", "-");
}

// Fast: explicit return type on the public API
export function slug(s: string): string {
  return s.toLowerCase().replaceAll(" ", "-");
}

--allow-slow-types skips the check for the whole package, not per symbol. A strong candidate treats that flag as a code smell in a library meant for other teams.

22. How do you publish to JSR from CI with provenance?

Give the package a name, version and exports in deno.json or jsr.json, run deno publish --dry-run in pull requests, and publish from GitHub Actions with OIDC.

The workflow needs id-token: write; per the publishing docs, provenance is available only when publishing from GitHub Actions with OIDC.

permissions:
  contents: read
  id-token: write
steps:
  - uses: actions/checkout@v4
  - uses: denoland/setup-deno@v2
  - run: deno publish

The publish field controls which files ship: include lists them explicitly, and a negated exclude such as "!dist/" publishes a gitignored build folder. jsr publish refuses a version that already exists, so bumping is part of the release step; Deno 2.8 added deno bump-version for that, and deno pack for building an npm tarball from the same source.

23. What changed in deno test in 2.8 and 2.9, and why does it matter for existing suites?

Deno 2.8 turned sanitizeOps and sanitizeResources off by default, so a test that leaves a timer, a file handle or an open connection behind now passes.

Teams that relied on those sanitizers to catch leaks need to turn them back on per test, per file or in deno.json. 2.8 also added a per-test timeout option.

Deno 2.9 added most of what teams used to pull in from other runners:

import { assertEquals } from "jsr:@std/assert";

Deno.test.each([
  [1, 1, 2],
  [2, 1, 3],
])("add(%i, %i) = %i", (a, b, expected) => {
  assertEquals(a + b, expected);
});

Deno.test("renders the header", async (t) => {
  await t.assertSnapshot(renderHeader({ title: "Docs" }));
});

Plus retry and repeats, --shard=<index>/<count> for CI matrices, --changed and --related for affected-test runs, and coverage thresholds that fail the build.

A strong candidate is wary of retry: it hides flaky tests unless the team tracks which ones needed it.

24. How do you keep dependencies safe in a Deno project?

Layer the controls Deno now ships:

  • Frozen lockfile in CI, or deno ci (2.8), which fails without deno.lock, removes an existing node_modules and installs with --frozen.
  • Minimum dependency age, on at 24 hours since 2.9, so a freshly hijacked release is not picked up within the first day.
  • Lifecycle script approval (question 14).
  • deno audit against advisory databases, with deno audit fix (2.8) upgrading to the nearest patched version within your ranges and listing major bumps separately.
  • deno why (2.8) to trace which direct dependency pulled in a vulnerable package.
  • Scoped runtime permissions, so a compromised package that does run cannot read every secret or call any host.

The last item is the one Node cannot offer without extra tooling, and candidates who sell Deno to a security team lead with it.

KV, Deploy and deno compile

25. How does Deno KV work, and what are its limits?

Deno KV is a key-value store built into the runtime, opened with Deno.openKv(). Locally it uses SQLite, and on Deno Deploy it is backed by FoundationDB.

Keys are arrays of strings, numbers, bigints, booleans and byte arrays, ordered lexicographically, so ["user", id, "orders", orderId] lets kv.list({ prefix: ["user", id, "orders"] }) read one user's orders in order.

It still requires --unstable-kv (or "unstable": ["kv"] in config), per the KV docs.

Limits from the Deno.Kv API reference: keys up to 2,048 bytes and values up to 64 KiB after serialization, and list batches clamped at 500. Reads can be strong or eventual; writes are always strong.

There are no secondary indexes, so the application writes the same record under each key it needs to look it up by, inside one atomic operation.

26. Find the bug: a KV balance update.

const kv = await Deno.openKv();

export async function addCredit(userId: string, amount: number): Promise<void> {
  const key = ["balance", userId];
  const entry = await kv.get<number>(key);
  await kv.set(key, (entry.value ?? 0) + amount);
}

Bug: a lost update. Two concurrent calls read the same balance, each adds its amount, and the second write overwrites the first. Nothing ties the write to the version that was read.

Fix: an atomic operation that checks the versionstamp and retries when the check fails.

export async function addCredit(userId: string, amount: number): Promise<void> {
  const key = ["balance", userId];
  while (true) {
    const entry = await kv.get<number>(key);
    const res = await kv.atomic()
      .check(entry) // fails if the versionstamp changed since the read
      .set(key, (entry.value ?? 0) + amount)
      .commit();
    if (res.ok) return;
  }
}

A senior candidate offers the alternative for counters: store a Deno.KvU64 and use .sum(key, 1n), which needs no read.

They also bound the retry loop and note that a check against a null versionstamp asserts that the key does not exist, which is how you implement "create if absent".

27. How do KV queues work, and what delivery guarantee do they give?

kv.enqueue(value, options) schedules a message, and kv.listenQueue(handler) processes them; a handler that throws is retried.

Options include delay in milliseconds, a backoffSchedule, and keysIfUndelivered, the keys where the message is written if every retry fails.

Enqueue can also be part of an atomic operation, so a state change and its follow-up job commit together.

kv.listenQueue(async (msg: unknown) => {
  const job = msg as { type: "welcome"; userId: string };
  if (job.type === "welcome") await sendWelcomeEmail(job.userId);
});

await kv.atomic()
  .set(["user", userId], user)
  .enqueue({ type: "welcome", userId }, {
    delay: 60_000,
    keysIfUndelivered: [["failed_jobs", "welcome", userId]],
  })
  .commit();

Because failed handlers are retried, a message can run more than once; the handler must be idempotent, for example by recording a sent marker in KV and checking it first. A weak answer treats the queue as exactly-once.

28. What does deno compile produce, and what are the traps?

A single executable that bundles the denort runtime, your module graph and, by default, the whole resolved node_modules tree.

Per the compile reference, it cross-compiles to x86_64 and aarch64 targets for Linux, macOS and Windows from any host (Windows on ARM since 2.9.3), and permission flags are fixed at compile time.

deno compile \
  --allow-net=api.example.com --allow-read=./data \
  --include ./plugins \
  --exclude-unused-npm \
  --target x86_64-unknown-linux-gnu \
  -o reportctl main.ts

The traps candidates should name:

  • Dynamic imports that cannot be analyzed statically are left out; add them with --include.
  • Embedded files are read from a virtual file system at import.meta.dirname; --self-extracting (2.7) writes them to disk on first run for libraries that need real paths, at the cost of a slower first start and modifiable files.
  • Since 2.9, localStorage and a Deno.openKv() call without a path persist in a per-app data directory; --app-name keeps that location stable across renames.
  • macOS binaries get an ad-hoc signature; distribution outside your own machines still needs proper signing.

29. Find the bug: a compiled CLI with plugins.

// main.ts, built with: deno compile --allow-read=. -o tool main.ts
const name = Deno.args[0] ?? "default";
const plugin = await import(`./plugins/${name}.ts`);
await plugin.run();

Bug: the import specifier is built from a runtime value, so deno compile cannot see which plugin files to embed.

The binary works on the developer's machine, where ./plugins sits next to it under --allow-read=., and fails when shipped alone.

Fix: --include ./plugins at compile time, or a static map of plugin names to import() calls with literal specifiers, which also stops a user from passing ../../somewhere as a plugin name.

Version 2.9.8 also fixed compiled binaries to check read permission for dynamically imported local files, so a broad --allow-read=. is doing real work here and should be narrowed.

30. What is the state of Deno Deploy, and what would you do with an app running on it?

Two deadlines apply. Deno Deploy Classic (dash.deno.com) and the subhosting v1 API were scheduled to shut down on July 20, 2026, with apps moved by hand to the new Deno Deploy at console.deno.com, per the migration guide.

Then the October 9, 2026 Cloudflare announcement said Deno Deploy "will continue operating for six months before shutting down", with migration support for paying customers moving to Cloudflare Workers.

JSR keeps operating, with its infrastructure moving to Cloudflare.

A strong answer is a plan, not a lament:

  • Inventory platform-specific APIs: Deno.openKv() without a path, Deno.cron, KV queues, and any reliance on Deploy's environment contexts.
  • Export KV data and pick a replacement store before the shutdown, because data does not move with the code.
  • Keep handlers on web-standard Request and Response, which port to Workers and other runtimes with the least change.
  • Decide whether the app should also leave the Deno runtime, given the support window in question 31.

What Changed Recently

Sep 10, 2025
Deno 2.5: permission sets in deno.json, permission audit log, Deno.test setup and teardown APIs
Dec 10, 2025
Deno 2.6: deno x, deno approve-scripts, @types/node included, --ignore-env
Feb 25, 2026
Deno 2.7: Temporal API stable, npm overrides, deno create, --self-extracting for compile
May 22, 2026
Deno 2.8: npm-first deno add, TypeScript 6.0.3, Node timers, test sanitizers off, deno ci, deno why, deno pack
Jun 25, 2026
Deno 2.9: 24-hour dependency age floor, Deno.serve compression off, lockfile seeding, snapshot tests, deno desktop
Jul 20, 2026
Deno Deploy Classic scheduled shutdown, with the subhosting v1 API
Oct 9, 2026
Deno team joins Cloudflare: Deploy has six months left, the runtime gets one year of fix releases
Oct 21, 2026
Deno 2.9.8: current release, with compile, npm and TLS fixes

31. Should a team start a new project on Deno after the Cloudflare announcement?

Per the announcement, the team will support the runtime "for another year with monthly releases containing bug fixes and security updates", then end its own development; Deno stays open source and open to other maintainers.

Cloudflare's post says it will bring ideas and code from Deno into its open-source workerd runtime.

This is the design-tradeoff question that separates seniors in 2026. A strong answer weighs:

  • Time horizon: a script, internal tool or compiled CLI with a short life can use Deno's tooling today at low risk. A service meant to run for five years needs an exit plan from day one.
  • Portability of the code: web-standard handlers, node: imports and npm or JSR dependencies move to Node.js, Bun or Workers with modest change. Deno.* APIs, KV and Deploy-specific features do not.
  • Security patches: after the support year, CVEs in V8 or the runtime depend on whoever picks up maintenance.
  • What stays: JSR keeps operating, and JSR packages already install into Node and Bun.

A weak answer either dismisses Deno outright or ignores the announcement. Both miss that most of a well-written Deno codebase is already portable.

32. Which 2.8 and 2.9 default changes would you check first when upgrading from 2.7?

The ones that change behavior without a code change:

  • Unprefixed packages go to npm in deno add and deno install (2.8). Scripts that relied on JSR resolution for bare names install a different package.
  • Timers return Timeout objects (2.8), which breaks code that treats IDs as numbers (question 18).
  • Test sanitizers are off (2.8), so leak checks the team relied on stop running.
  • TypeScript 6.0 (2.8) brings deprecations that surface in deno check.
  • Dependency age floor of 24 hours (2.9): an urgent same-day fix to an internal package will not install until you exclude it or lower the age.
  • Compression off in Deno.serve (2.9), visible as larger responses when no proxy compresses (question 4).
  • A stand-in node on PATH (2.9) when Node is not installed, which helps tools that spawn node but can confuse build scripts that detect Node; DENO_DISABLE_NODE_SHIM=1 turns it off.

A candidate who has done this upgrade reads the release notes for "BREAKING" and "default" before bumping the version in CI, and pins the Deno version in setup-deno so a minor release does not land unreviewed.

Signs of a Strong Answer

  • They write scoped --allow-* lists or a named permission set, and know api.github.com is not covered by github.com.
  • They treat --allow-run and --allow-ffi as a full trust grant and say why.
  • They protect every KV read-modify-write with a versionstamp check and make queue handlers idempotent.
  • They know which defaults changed in 2.8 and 2.9 and can name the one that bit their last upgrade.
  • They keep request handling on web-standard APIs and isolate Deno.* calls, so the code can move runtimes.
  • They have a dated plan for any app on Deno Deploy and for the end of the runtime's support year.

Hiring Deno Developers

Developers who have run Deno in production, scoped its permissions for a real service and moved npm projects across runtimes are rare on general job boards, and in 2026 the job often includes planning a migration off Deno Deploy.

Look for engineers who also know Node.js well: our Node.js, Node.js developer and TypeScript interview guides cover that side of the loop.

Second Talent helps US startups hire vetted AI-Native Engineers from Asia, including Node.js developers, TypeScript developers and backend developers screened with questions like these.

Rates run $23 to $39 USD an hour, billed monthly, with matches in 24 hours and a 90-day one-time replacement guarantee. Compare rates on the cost to hire a Node.js developer page, or tell us what you need.

Get developers who ship with AI agents.

Starts at $25/Hour.

Start Hiring

$0 cost until you hire