[Deno Deploy](https://deno.com/deploy) includes a feature that allows you to provision a Prisma Postgres database directly within the platform. This guide demonstrates how to integrate Prisma Postgres in a Deno Deploy project using a minimal Deno application that logs HTTP requests to the database.

By the end of this guide, you will have a deployed Deno app that writes to and reads from a Prisma Postgres database provisioned in Deno Deploy, using Prisma Client with `runtime = "deno"`.

## Prerequisites

- A [Deno Deploy](https://deno.com/deploy) account
- Deno v2.0 or later installed ([installation guide](https://docs.deno.com/runtime/#install-deno))
- [Deno extension for VS Code](https://docs.deno.com/runtime/reference/vscode/)

## 1. Create and set up a new Deno project

Create a new Deno project using the `deno init` command, which generates a basic project structure with a main entry file and configuration.

```terminal
deno init prisma-postgres-deno-deploy
cd prisma-postgres-deno-deploy
```

### 1.1 Configure VS Code for Deno

To ensure VS Code recognizes this as a Deno project and provides proper TypeScript validation, you need to initialize the workspace. Without this, VS Code will show errors when using Deno-specific APIs like `Deno.serve`.

Install the [Deno extension for VS Code](https://docs.deno.com/runtime/reference/vscode/), then:
1. Select **View** > **Command Palette** _(or press `Cmd+Shift+P` on macOS or `Ctrl+Shift+P` on Windows)_
2. Run the command **Deno: Initialize Workspace Configuration**

### 1.2 Create a basic HTTP server

Update the `main.ts` file to create a simple HTTP server that responds with "Hello, World!", establishing the foundation for your application before adding database functionality.

```ts file=main.ts
function handler(_req: Request): Response {
  return new Response("Hello, World!");
}

Deno.serve(handler);
```

You can test the server locally by running:

```terminal
deno task dev
```

Visit `localhost:8000` in your browser to see the application running.

### 1.3 Push initial project to GitHub

To connect your project to Deno Deploy and get a database connection string, you need to have a successful deployment. Set up a GitHub repository and push your project to it.

## 2. Deploy the project to Deno Deploy

Deploy your repository to Deno Deploy. Any subsequent commits will trigger automatic redeployments. You need to deploy now, as the database string requires a successful deployment to generate.

1. Navigate to the [Deno Deploy dashboard](https://dash.deno.com/) and select **New App**
2. Configure GitHub app permissions by following GitHub's prompts
3. Choose your GitHub repository in the Deno Deploy interface
4. Click **Create App** to complete the deployment

The application will deploy automatically.

## 3. Provision a Prisma Postgres database

Provision a Prisma Postgres database in Deno Deploy, and link it to your application:

1. Go to the **Databases** section in the Deno Deploy dashboard
2. Select **Provision Database** and choose **Prisma Postgres**
3. Complete the database configuration and confirm provisioning
4. Click **Assign** and select your application
5. Copy the **Production connection string**
6. Add the connection string to your `.env` file:

```env
DATABASE_URL="postgresql://<username>:<password>@db.prisma.io:5432/<database_name>-production"
```

## 4. Configure Prisma ORM

### 4.1 Configure Deno for Prisma

Create or update your `deno.json` with the following configuration:

```json file=deno.json
{
  "nodeModulesDir": "auto",
  "compilerOptions": {
    "lib": ["deno.window"],
    "types": ["node"]
  },
  "imports": {
    "@prisma/adapter-pg": "npm:@prisma/adapter-pg@^7.0.0",
    "@prisma/client": "npm:@prisma/client@^7.0.0",
    "prisma": "npm:prisma@^7.0.0"
  },
  "tasks": {
    "dev": "deno run -A --env=.env --watch main.ts",
    "db:generate": "deno run -A --env=.env npm:prisma generate",
    "db:push": "deno run -A --env=.env npm:prisma db push",
    "db:migrate": "deno run -A --env=.env npm:prisma migrate dev"
  }
}
```

:::note
The `nodeModulesDir: "auto"` setting is required for Prisma to work correctly with Deno. The `compilerOptions` ensure TypeScript understands Deno globals and npm packages.
:::

Install the dependencies:

```terminal
deno install
deno install --allow-scripts
```

### 4.2 Initialize Prisma and create schema

Initialize Prisma in your project:

```terminal
deno run -A npm:prisma init
```

Update the Prisma schema with these changes:
1. Add the Deno runtime configuration _(required for Deno to work properly)_
2. Add the `Log` model for storing request information

```prisma file=prisma/schema.prisma highlight=4;add
generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
  runtime  = "deno"
}

datasource db {
  provider = "postgresql"
}

model Log {
  id      Int    @id @default(autoincrement())
  level   Level
  message String
  meta    Json
}

enum Level {
  Info
  Warn
  Error
}
```

### 4.3 Generate and apply migrations

Migrations create the actual database tables based on your Prisma schema. This command generates SQL migration files and executes them against your database, creating the `Log` table with the specified fields.

```terminal
deno task db:migrate --name init
```

Or use `db:push` for rapid prototyping:

```terminal
deno task db:push
```

## 5. Update the application to use Prisma

Now that the database is configured, update your application to interact with it. This implementation creates a logging system that captures every HTTP request, stores it in the database, and returns the logged entry as JSON.

```ts file=main.ts
import { PrismaPg } from "@prisma/adapter-pg";
import { PrismaClient } from "./generated/prisma/client.ts";

const connectionString = Deno.env.get("DATABASE_URL")!;
const adapter = new PrismaPg({ connectionString });
const prisma = new PrismaClient({ adapter });

async function handler(request: Request): Promise<Response> {
  const url = new URL(request.url);
  if (url.pathname === "/favicon.ico") {
    return new Response(null, { status: 204 });
  }

  const log = await prisma.log.create({
    data: {
      level: "Info",
      message: `${request.method} ${request.url}`,
      meta: {
        headers: JSON.stringify(request.headers),
      },
    },
  });
  
  return new Response(JSON.stringify(log, null, 2), {
    headers: { "Content-Type": "application/json" },
  });
}

Deno.serve(handler);
```

Test the application locally by running:

```terminal
deno task dev
```

Visit `localhost:8000` in your browser to see the application running. You should see a JSON response containing the log entry:

```json
{
  "id": 1,
  "level": "Info",
  "message": "GET http://localhost:8000/",
  "meta": {
    "headers": "..."
  }
}
```

## 6. Deploy the application

The build command must generate the Prisma Client code to ensure it is available in production.

### 6.1 Update build configuration in Deno Deploy

1. Go to the application in Deno Deploy and click **Settings**
2. Under **Build configuration**, click **Edit** and configure:
   - **Install command**: `deno install`
   - **Pre-deploy command**: `deno run -A npm:prisma generate`
3. Click **Save**

### 6.2 Push changes to GitHub

Commit and push your changes to trigger an automatic deployment:

```terminal
git add .
git commit -m "added prisma"
git push
```

Navigate back to Deno Deploy and you should see a successful build. Once deployed, click the deployment URL at the top right of the dashboard.

### 6.3 Verify the deployment

When you visit your deployed application, you should see a response that looks like this:

```json
{
  "id": 1,
  "level": "Info",
  "message": "GET https://prisma-postgres-deno-deploy.<org-name>.deno.net/",
  "meta": {
    "headers": "{}"
  }
}
```

You're done! Each time you refresh the page, a new log entry is created in your database.

## Next Steps

Now that you have a working Deno app connected to a Prisma Postgres database, you can:

- **Enhance your data model** - Add relationships, validations, and indexes to your Prisma schema
- **Secure your API** - Implement authentication, rate limiting, and proper error handling
- **Improve deployment** - Set up CI/CD, monitoring, and database backups for production
- **Deploy to Deno Deploy** - Check out the full [Deploy to Deno Deploy guide](/orm/prisma-client/deployment/edge/deploy-to-deno-deploy) for a more comprehensive example

## More info

- [Prisma ORM Documentation](/orm/overview/introduction)
- [Deno Deploy Documentation](https://docs.deno.com/deploy)
---

# How to use Prisma ORM and Prisma Postgres with Cloudflare Workers