feat(docs): add Prisma Compute docs section and integrate into the docs experience

apps/docs/content/docs/(index)/getting-started.mdx

@@ -18,6 +18,11 @@ Prisma gives you a few good starting points depending on whether you need a data
 - [Quickstart with MySQL](/prisma-orm/quickstart/mysql) if your application uses MySQL
 - [Quickstart with MongoDB](/prisma-orm/quickstart/mongodb) if your application uses MongoDB
 
+### Deploy your app
+
+- [Deploy your first app](/prisma-compute/deploy) on [Prisma Compute](/compute), currently in Public Beta, to run it next to your Prisma Postgres database
+- [Connect Prisma Compute to Prisma Postgres](/prisma-compute/connect-to-prisma-postgres) once your app is deployed
+
 ### Add Prisma to an existing project
 
 - [Add Prisma ORM to an existing PostgreSQL project](/prisma-orm/add-to-existing-project/postgresql)

apps/docs/content/docs/(index)/index.mdx

@@ -19,6 +19,13 @@ npx create-db
 ```
 
 
+[**Prisma Compute**](/compute) runs your app next to your Prisma Postgres database, currently in [Public Beta](/console/more/feature-maturity#public-beta). Deploy Next.js, Hono, TanStack Start, and Bun apps, with an isolated preview for every branch.
+
+```npm
+npx @prisma/cli@latest app deploy
+```
+
+
 <Cards>
   <Card href="/prisma-orm/quickstart/prisma-postgres" title="Use Prisma Postgres" icon={<div className="text-primary"><svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="159" height="195" viewBox="0 0 640 640" fill="none"><path d="M355.2 85C348.2 72.1 334.7 64 320 64C305.3 64 291.8 72.1 284.8 85L209.7 224L430.2 224L355.1 85zM123.3 384L516.6 384L456.1 272L183.7 272L123.2 384zM97.4 432L68.8 485C62.1 497.4 62.4 512.4 69.6 524.5C76.8 536.6 89.9 544 104 544L536 544C550.1 544 563.1 536.6 570.4 524.5C577.7 512.4 577.9 497.4 571.2 485L542.6 432L97.4 432z" fill="currentColor"/></svg></div>
 }>

apps/docs/content/docs/(index)/meta.json

@@ -8,6 +8,8 @@
     "---Prisma ORM---",
     "...prisma-orm",
     "---Prisma Postgres---",
-    "...prisma-postgres"
+    "...prisma-postgres",
+    "---Prisma Compute---",
+    "...prisma-compute"
   ]
 }

apps/docs/content/docs/(index)/prisma-compute/connect-to-prisma-postgres.mdx

@@ -0,0 +1,58 @@
+---
+title: Connect to Prisma Postgres
+description: Connect your Compute app to a Prisma Postgres database with a single environment variable.
+url: /prisma-compute/connect-to-prisma-postgres
+metaTitle: 'Quickstart: Connect Prisma Compute to Prisma Postgres'
+metaDescription: Create a Prisma Postgres database, set its connection string on your Compute app, and verify the connection.
+---
+
+An app on Compute reads its database connection from an environment variable, typically `DATABASE_URL`. In this guide, you will create a [Prisma Postgres](/postgres) database, set its connection string on your app, and verify the connection.
+
+## Prerequisites
+
+- A deployed app on Compute. If you don't have one, follow [Deploy your first app](/prisma-compute/deploy).
+
+## 1. Create a database
+
+Create a Prisma Postgres database from the terminal:
+
+```npm
+npx create-db
+```
+
+Copy the `postgres://...` connection string from the output. Alternatively, create the database in [Prisma Console](https://console.prisma.io), open it, and click **Connect to your database** to copy a connection URL.
+
+## 2. Set the connection string
+
+Add the connection string to the scope your app runs in:
+
+```npm
+npx @prisma/cli@latest project env add DATABASE_URL=postgres://... --role preview
+```
+
+Use `--role production` instead when configuring your production branch.
+
+## 3. Deploy
+
+Variables are resolved at deploy time, so they apply on the next deploy:
+
+```npm
+npx @prisma/cli@latest app deploy
+```
+
+## 4. Verify
+
+Open the app and exercise a code path that queries the database, then check the logs for connection errors:
+
+```npm
+npx @prisma/cli@latest app open
+npx @prisma/cli@latest app logs
+```
+
+If queries succeed, your app is connected.
+
+## What's next
+
+- [Connect to a Prisma Postgres database](/compute/database/connect-to-prisma-postgres) for per-branch databases and troubleshooting
+- [Environment variables](/compute/environment-variables) for scopes, write-only behavior, and limits
+- [Prisma Postgres documentation](/postgres)

apps/docs/content/docs/(index)/prisma-compute/deploy.mdx

@@ -0,0 +1,89 @@
+---
+title: Deploy your first app
+description: Take an existing TypeScript app from your terminal to a live URL on Prisma Compute.
+url: /prisma-compute/deploy
+metaTitle: 'Quickstart: Deploy your first app on Prisma Compute'
+metaDescription: Deploy a TypeScript app to Prisma Compute with the @prisma/cli beta package and verify it at a live URL.
+---
+
+[Prisma Compute](/compute) runs your app next to your Prisma Postgres database. In this guide, you will deploy an existing app to Compute and open it at a live URL.
+
+## Prerequisites
+
+- A JavaScript runtime: Node.js 22.12 or newer for `npx`/`pnpm`, or Bun for `bunx`.
+- A Prisma developer platform account ([console.prisma.io](https://console.prisma.io)).
+- An app built with **Next.js**, **Hono**, **TanStack Start**, or a plain **Bun** HTTP server.
+
+:::info
+
+Next.js apps must set `output: "standalone"` in their Next.js config before deploying.
+
+:::
+
+## 1. Deploy
+
+From your app directory:
+
+```npm
+npx @prisma/cli@latest app deploy
+```
+
+If you're not signed in yet, the CLI walks you through it, then sets up the project, builds your app, and deploys it. When it finishes, you get a live URL. Your first deployment is promoted to production automatically.
+
+## 2. Verify
+
+Open the deployed app in your browser:
+
+```npm
+npx @prisma/cli@latest app open
+```
+
+If something looks off, stream the logs:
+
+```npm
+npx @prisma/cli@latest app logs
+```
+
+## 3. Keep shipping
+
+After your app is live, you can keep deploying with the Prisma CLI or inspect your resources in the [Prisma Console](https://console.prisma.io): projects, branches, apps, deployments, integrations, and domains.
+
+Deploys from a Git feature branch create isolated [preview deployments](/compute/branching); deploying to production again is explicit:
+
+```npm
+npx @prisma/cli@latest app deploy --prod
+```
+
+## Hand it to your agent
+
+You can also let your coding agent do the deploying. Sign in once yourself, because the browser step needs a human:
+
+```npm
+npx @prisma/cli@latest auth login
+```
+
+After that, anything running in your environment inherits the session, including your agent. Paste this into your agent and fill in the blanks:
+
+```text
+Build [what you want] in [framework] and deploy it to Prisma Compute using `npx @prisma/cli@latest`.
+```
+
+For example:
+
+```text
+Build a Hono API with a /todos endpoint backed by an in-memory list. Deploy it to Prisma Compute using `npx @prisma/cli@latest`.
+```
+
+Notes worth giving your agent:
+
+- Run every CLI command as `npx @prisma/cli@latest <command>`, and add `--json` for structured output.
+- Check login state with `npx @prisma/cli@latest auth whoami`.
+- On the first deploy, the CLI creates the project and prints a live URL. Open it and confirm the app responds.
+- If the app needs config or secrets, add them with `npx @prisma/cli@latest project env add KEY=value --role preview`, then redeploy. Variables apply on the next deploy.
+
+## What's next
+
+- [Connect your app to Prisma Postgres](/prisma-compute/connect-to-prisma-postgres)
+- [Add environment variables](/compute/environment-variables) for configuration and secrets
+- [Connect a GitHub repository](/compute/github) to deploy on push
+- [Read the full CLI getting-started guide](/compute/getting-started)

apps/docs/content/docs/(index)/prisma-compute/meta.json

@@ -0,0 +1,5 @@
+{
+  "title": "Prisma Compute",
+  "defaultOpen": true,
+  "pages": ["deploy", "connect-to-prisma-postgres"]
+}

apps/docs/content/docs/(index)/prisma-orm/quickstart/prisma-postgres.mdx

@@ -269,7 +269,11 @@ You've successfully set up Prisma ORM. Here's what you can explore next:
 - **Build a full application**: Check out our [framework guides](/guides) to integrate Prisma ORM with Next.js, Express, and more
 - **Join the community**: Connect with other developers on [Discord](https://pris.ly/discord)
 
+:::info[Deploy to Compute]
 
+Want to run this app in the cloud? Deploy it to [Prisma Compute](/compute), which runs your app next to your Prisma Postgres database. Follow [Deploy your first app](/prisma-compute/deploy).
+
+:::
 
 ## More info
 

apps/docs/content/docs/(index)/prisma-postgres/quickstart/drizzle-orm.mdx

@@ -192,3 +192,9 @@ Connection closed
 ## Next steps
 
 You've successfully connected Drizzle ORM to Prisma Postgres! For more advanced features like schemas, migrations, and queries, see the [Drizzle ORM documentation](https://orm.drizzle.team/docs/get-started).
+
+:::info[Deploy to Compute]
+
+Want to run this app in the cloud? Deploy it to [Prisma Compute](/compute), which runs your app next to your Prisma Postgres database. Follow [Deploy your first app](/prisma-compute/deploy).
+
+:::

apps/docs/content/docs/(index)/prisma-postgres/quickstart/kysely.mdx

@@ -268,3 +268,9 @@ All users: [ { id: 1, email: 'alice@prisma.io', name: 'Alice' } ]
 ## Next steps
 
 You've successfully connected Kysely to Prisma Postgres! For more advanced features like schemas, migrations, and complex queries, see the [Kysely documentation](https://kysely.dev/docs/intro).
+
+:::info[Deploy to Compute]
+
+Want to run this app in the cloud? Deploy it to [Prisma Compute](/compute), which runs your app next to your Prisma Postgres database. Follow [Deploy your first app](/prisma-compute/deploy).
+
+:::

apps/docs/content/docs/(index)/prisma-postgres/quickstart/prisma-orm.mdx

@@ -251,6 +251,12 @@ You've successfully set up Prisma ORM. Here's what you can explore next:
 - **Build a full application**: Check out our [framework guides](/guides) to integrate Prisma ORM with Next.js, Express, and more
 - **Join the community**: Connect with other developers on [Discord](https://pris.ly/discord)
 
+:::info[Deploy to Compute]
+
+Want to run this app in the cloud? Deploy it to [Prisma Compute](/compute), which runs your app next to your Prisma Postgres database. Follow [Deploy your first app](/prisma-compute/deploy).
+
+:::
+
 ## More info
 
 - [Prisma Postgres documentation](/postgres)

apps/docs/content/docs/(index)/prisma-postgres/quickstart/typeorm.mdx

@@ -174,3 +174,9 @@ Loaded users:  [ User { id: 1, firstName: 'Timber', lastName: 'Saw', age: 25 } ]
 ## Next steps
 
 You've successfully connected TypeORM to Prisma Postgres! For more advanced features like entities, migrations, and queries, see the [TypeORM documentation](https://typeorm.io/docs/getting-started).
+
+:::info[Deploy to Compute]
+
+Want to run this app in the cloud? Deploy it to [Prisma Compute](/compute), which runs your app next to your Prisma Postgres database. Follow [Deploy your first app](/prisma-compute/deploy).
+
+:::

apps/docs/content/docs/cli/index.mdx

@@ -22,6 +22,12 @@ The Prisma CLI is available as an npm package. Install it as a development depen
 npm install prisma --save-dev
 ```
 
+:::info
+
+Looking for [Prisma Compute](/compute) commands? Deployments to Compute use the separate [`@prisma/cli`](/compute/getting-started) beta package, which exposes the `prisma-cli` binary so it can coexist with `prisma`. See [Get started with `@prisma/cli`](/compute/getting-started).
+
+:::
+
 ## Usage
 
 ```bash

apps/docs/content/docs/compute/branching.mdx

@@ -0,0 +1,71 @@
+---
+title: Branching
+description: Branches are isolated infrastructure boundaries that map to your Git branches, so preview work never touches production.
+url: /compute/branching
+metaTitle: Branching | Prisma Compute
+metaDescription: How production and preview branches work in Prisma Compute, how the CLI picks a branch, and how branches are created and cleaned up.
+---
+
+A branch is an isolated infrastructure boundary. Every branch in a project gets its own apps, databases, and deployments, so work on a preview never touches production.
+
+A platform branch maps to a Git branch, but it's more than a name: it's a real resource that owns the infrastructure for one line of work.
+
+```text
+workspace → project → branch → { apps, databases }
+```
+
+## Production and preview
+
+Every branch has a role.
+
+- The **first branch** in a project is your production branch, usually `main`. It's protected and durable.
+- **Every other branch** is a preview by default: disposable infrastructure for testing changes before they merge.
+
+Production deploys get a guardrail; previews don't. See [Deployments](/compute/deployments).
+
+## How the CLI picks a branch
+
+When you deploy, the CLI resolves the branch in this order:
+
+1. `--branch <name>`, if you pass it.
+2. Your active Git branch.
+3. `main`.
+
+So inside a Git repo, deploying from `feature/search` targets the `feature/search` branch automatically. To be explicit:
+
+```npm
+npx @prisma/cli@latest app deploy --branch feature/search
+```
+
+Inspect platform branches:
+
+```npm
+npx @prisma/cli@latest branch list
+npx @prisma/cli@latest branch show
+```
+
+`branch use` switches your local branch context without creating anything remote:
+
+```npm
+npx @prisma/cli@latest branch use feature/search
+```
+
+Listing a branch doesn't expand the apps and databases inside it. Use the `app` commands to inspect those.
+
+## Creating branches
+
+You rarely create branches by hand. They appear when work needs them:
+
+- **On deploy** — `app deploy --branch feature/search` creates the branch if it doesn't exist.
+- **From GitHub** — when a repo is connected, branch and push events create or update the matching platform branch automatically. See [GitHub integration](/compute/github).
+
+Connecting GitHub doesn't create branches retroactively; it wires up automation for future events.
+
+## Cleaning up
+
+When GitHub is connected, deleting a Git branch tears down the matching platform branch, as long as it isn't your production or default branch. Those are always left alone.
+
+## Next steps
+
+- [Environment variables](/compute/environment-variables) — preview values and per-branch overrides.
+- [GitHub integration](/compute/github) — keep platform branches in sync with your repo.