Notes

# Deno Hosting: Deploy Your TypeScript Apps to the Cloud
**Primary keywords:** deno hosting, deno deploy, deno cloud hosting, deno app hosting, deno typescript hosting

---

Deno brought a fresh perspective to server-side JavaScript: TypeScript support out of the box, security by default, built-in tooling, and a standard library that doesn't depend on npm. Deploying Deno applications to production should match that same philosophy of simplicity. This guide covers how to host Deno apps in the cloud and get them running reliably.

## What Makes Deno Different to Host

Deno has a few characteristics that affect how you deploy it:

- TypeScript compiles on the fly — no separate build step needed
- Dependencies are imported from URLs or `deno.json`, not from `node_modules`
- Deno requires explicit permission flags (`--allow-net`, `--allow-env`, etc.)
- No `package.json` by convention — uses `deno.json` or `deno.jsonc`

These differences mean your Procfile needs to include the right permission flags, and your dependency management looks different from Node.js projects.

## A Simple Deno HTTP Server

```typescript
// main.ts
import Hono from "https://deno.land/x/[email protected]/mod.ts";

const app = new Hono();

app.get("/health", (c) =>
return c.json(
status: "ok",
runtime: "deno",
version: Deno.version.deno,
);
);

app.get("/", (c) =>
return c.text("Hello from Deno!");
);

const port = parseInt(Deno.env.get("PORT") || "8000");
console.log(`Server running on port $port`);
Deno.serve( port , app.fetch);
```

## Project Structure

```
my-deno-app/
├── main.ts
├── deno.json
└── Procfile
```

### deno.json

```json

"tasks":
"start": "deno run --allow-net --allow-env main.ts",
"dev": "deno run --watch --allow-net --allow-env main.ts"
,
"imports":
"hono/": "https://deno.land/x/[email protected]/"


```

### Procfile

```
web: deno run --allow-net --allow-env --allow-read main.ts
```

Be explicit with permissions. https://apexweave.com/blog/wpengine-alternative https://apexweave.com/developer Only grant what your app actually needs:
- `--allow-net`: HTTP server and outbound network calls
- `--allow-env`: Access to environment variables
- `--allow-read`: File system reads (only if needed)

## Deploying to ApexWeave

```bash
apexweave login
apexweave deploy
```

ApexWeave detects Deno from your `deno.json` file and ensures the correct Deno version is available in the runtime environment.

## Environment Variables

```bash
apexweave env:set DATABASE_URL=postgres://user:pass@host:5432/mydb
apexweave env:set API_KEY=your-api-key
apexweave env:set ENVIRONMENT=production
```

Access them in Deno:

```typescript
const dbUrl = Deno.env.get("DATABASE_URL");
const apiKey = Deno.env.get("API_KEY");

if (! ApexWeave dbUrl)
throw new Error("DATABASE_URL is required");

```

## Database Access with Deno

### PostgreSQL with postgres.js

```typescript
import Pool from "https://deno.land/x/[email protected]/mod.ts";

const pool = new Pool(Deno.env.get("DATABASE_URL"), 3, true);

app.get("/users", async (c) =>
const client = await pool.connect();
try
const result = await client.queryArray("SELECT id, email FROM users LIMIT 50");
return c.json(result.rows);
finally
client.release();

);
```

### Using Drizzle ORM with Deno

```typescript
import drizzle from "npm:drizzle-orm/postgres-js";
import postgres from "npm:postgres";

const sql = postgres(Deno.env.get("DATABASE_URL")!);
const db = drizzle(sql);
```

## Using npm Packages in Deno

Deno supports `npm:` specifiers, giving you access to the entire npm ecosystem:

```typescript
// Using express in Deno (if you need compatibility)
import express from "npm:express@4";

const app = express();
const port = Deno.env.get("PORT") || "3000";

app.get("/health", (req, res) =>
res.json( status: "ok" );
);

app.listen(port, () => console.log(`Running on port $port`));
```

## Streaming Logs

```bash
apexweave logs --follow
```

Deno writes to stdout/stderr, which ApexWeave captures and makes available here. Use `console.log` for application logs and `console.error` for errors.

## SSH Access

```bash
apexweave ssh
# Inside the container:
deno --version
deno eval "console.log(Deno.version)"
```

## Deno with Oak Framework

Oak is another popular Deno web framework:

```typescript
import Application, Router from "https://deno.land/x/[email protected]/mod.ts";

const router = new Router();

router
.get("/health", (ctx) =>
ctx.response.body = status: "ok" ;
)
.get("/users/:id", async (ctx) =>
const id = ctx.params.id;
ctx.response.body = id, name: "User " + id ;
);

const app = new Application();
app.use(router.routes());
app.use(router.allowedMethods());

const port = parseInt(Deno.env.get("PORT") || "8000");
await app.listen( port );
```

## TypeScript Configuration

Deno uses TypeScript natively, but you can customize compiler options:


```json

"compilerOptions":
"strict": true,
"lib": ["deno.window"],
"noImplicitAny": true


```

## Deno Version Pinning

Specify your Deno version in `.deno-version` or in your `Procfile`:

```
web: deno run --allow-net --allow-env main.ts
```

ApexWeave respects the Deno version you specify, ensuring production uses the same runtime as your development machine.

## Caching Dependencies

Deno caches dependencies in `$DENO_DIR`. To pre-cache during deployment:

```
# Procfile
web: deno cache main.ts && deno run --allow-net --allow-env main.ts
```

This separates dependency download from runtime startup, making cold starts faster.

## Plan Recommendations

- **AppForge Starter ($5/mo):** Personal Deno projects, APIs, TypeScript microservices
- **AppForge Pro ($10/mo):** Production APIs, multi-endpoint services, team projects
- **AppForge XL ($15/mo):** High-traffic Deno services, real-time apps

## Why Managed Hosting for Deno

Deno's security model and built-in TypeScript support make it a compelling runtime for backend development. But like any runtime, it needs proper cloud infrastructure around it: TLS, process supervision, log aggregation, and domain management. ApexWeave provides all of that without requiring you to configure it.

https://apexweave.com/about Start your **free 7-day ApexWeave trial** and deploy your Deno app to production. No credit card required — just `apexweave deploy` and you'll have a live HTTPS endpoint in minutes.

Homepage: https://apexweave.com/blog/wpengine-alternative