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

apps/blog/content/blog/launching-prisma-compute-public-beta/index.mdx

@@ -0,0 +1,59 @@
+---
+title: "Launching Prisma Compute in Public Beta"
+slug: "launching-prisma-compute-public-beta"
+date: "2026-06-08"
+authors:
+  - "Shane Neubauer"
+metaTitle: "Launching Prisma Compute in Public Beta"
+metaDescription: "Prisma Compute is now in public beta: TypeScript app hosting that runs on the same infrastructure as your database. Point your agent at your project and tell it to deploy."
+heroImagePath: "/launching-prisma-compute-public-beta/imgs/hero.png"
+heroImageAlt: "Prisma Compute, now in public beta"
+metaImagePath: "/launching-prisma-compute-public-beta/imgs/meta.png"
+tags:
+  - "announcement"
+  - "platform"
+  - "ai"
+---
+
+import { deployTerminalLines } from "./snippets";
+
+The hard part of building apps has moved up the stack. You describe what you want, and your agent codes it at 50x the speed.
+
+What didn't change is everything after: finding somewhere to host it, configuring your database, copying connection strings between dashboards, setting environment variables, inspecting build output, chasing logs, and feeding all of that context back into the agent when something breaks.
+
+The friction didn't disappear. It moved.
+
+## Introducing Prisma Compute
+
+Today we're launching Prisma Compute in [public beta](https://pris.ly/public-beta-docs): TypeScript app hosting that runs on the same infrastructure as your database, without sending traffic through a separate hosting vendor.
+
+It runs on Bun, scales to zero when nothing is happening, and treats every deploy as an immutable version with its own preview URL. You can look at a change running in production-like conditions before you promote it, and roll back just as easily by promoting the previous one.
+
+Every branch comes with a full database and an app deployment. Your agent can spin up a branch, test a new idea against a real database, and merge it into production when it's ready. App and database, together in one box.
+
+The most important part is that your agent can drive the whole loop: build, deploy, read logs, fix, and redeploy. It can make a change, inspect what happened, fix what failed, and try again without jumping between tools.
+
+That is the direction Prisma is moving in: one place where product builders, and their agents, can define the stack, deploy it, inspect it, and keep iterating.
+
+## Where Prisma is headed
+
+Prisma started as a type-safe ORM for the TypeScript community, where you could express your database schema as code. Then we launched Prisma Postgres, so you could host your database with Prisma too. Now Prisma Compute brings the app and database together into one platform, where you, or your agent, can define the entire stack as code and deploy it.
+
+With Prisma Compute, Prisma becomes a platform for product builders who want to build software with their agent, in the way software is built in 2026.
+
+## Try it
+
+Compute is in public beta starting today. Point your coding agent at your project and tell it:
+
+<AgentPrompt
+  prompt="Deploy this with @prisma/cli@latest."
+  skill="prisma-cli"
+  terminalCommand="bunx @prisma/cli@latest app deploy --db"
+  terminalLines={deployTerminalLines}
+/>
+
+One prompt, and the agent reads the project, provisions a branch database, applies your schema, builds the app, and ships an immutable preview URL. When something breaks, it reads the same logs you just watched scroll by, fixes the cause, and redeploys. The loop stays inside the agent.
+
+We're early and shipping fast, so we'd love to hear what breaks, what feels rough, and what's missing. Tag [@prisma on X](https://pris.ly/x), or drop your feedback in [the `prisma-compute` channel in our community Discord](https://pris.ly/discord-compute). We'll be reading closely, and we're excited to build this next chapter with you.
+
+Go build something.

apps/blog/content/blog/launching-prisma-compute-public-beta/snippets.ts

@@ -0,0 +1,17 @@
+// Captured from a real `@prisma/cli@latest app deploy --db` run.
+// The agent reads the project, wires a branch database, applies the
+// schema, builds, and ships an immutable preview, all in one command.
+export const deployTerminalLines = [
+  "✔ Linked ./guestbook to project compute-guestbook-demo",
+  "Deploying compute-guestbook-demo / add-guestbook / guestbook",
+  "◇ Creating branch database…",
+  "✔ Created branch database",
+  "◇ Applying schema with prisma db push…",
+  "✔ Database in sync with prisma/schema.prisma",
+  "✔ Added branch env: DATABASE_URL, DIRECT_URL",
+  "Building locally…  Built",
+  "Uploading…  Uploaded",
+  "Deploying…  Deployed",
+  "✔ Live in 4.5s",
+  "  https://add-guestbook.guestbook.prisma.build",
+];

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

@@ -6,7 +6,7 @@ metaTitle: Prisma getting started
 metaDescription: Choose a Prisma quickstart for new or existing projects and get from schema to first query quickly.
 ---
 
-Prisma gives you a few good starting points depending on whether you need a database, already have one, or want the smallest possible local setup.
+Prisma gives you a few good starting points depending on whether you need a database, already have one, want the smallest possible local setup, or are ready to deploy your app.
 
 ## Choose your path
 
@@ -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
+- [Set environment variables](/compute/environment-variables) to connect your deployed app to a database
+
 ### Add Prisma to an existing project
 
 - [Add Prisma ORM to an existing PostgreSQL project](/prisma-orm/add-to-existing-project/postgresql)
@@ -35,6 +40,13 @@ No matter which guide you choose, the flow is usually the same:
 3. Run `prisma generate` to create a type-safe client for your schema.
 4. Create or introspect your database, then start sending queries from your application.
 
+If you're deploying to [Prisma Compute](/compute), the equivalent flow is:
+
+1. Sign in with `npx @prisma/cli@latest auth login`.
+2. Run `npx @prisma/cli@latest app deploy` from your app directory to get a live URL.
+3. Set your database connection string and other config as [environment variables](/compute/environment-variables).
+4. Redeploy to apply them, then keep shipping from the CLI or [connect GitHub](/compute/github) to deploy on push.
+
 ## Next steps
 
 After setup, these pages are usually the next ones people need:

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

@@ -19,12 +19,19 @@ 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-compute/deploy" title="Use Prisma Compute" icon={<Rocket className="text-primary" />}>
+    **Ready to deploy?** Run your app next to your database, with a live preview for every branch.
+  </Card>
   <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>
 }>
     **Need a database?** Get started with your favorite framework and Prisma Postgres.
   </Card>
-  <Card href="/prisma-postgres/quickstart/prisma-orm" title="Bring your own database" icon={<Database className="text-primary" />}>
-    **Already have a database?** Use Prisma ORM for a type-safe developer experience and automated migrations.
-  </Card>
 </Cards>

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/deploy.mdx

@@ -0,0 +1,139 @@
+---
+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) deploys and runs your app next to your Prisma Postgres database.
+
+In this guide, you will deploy an existing app to Compute, open it at a live URL, and connect it to GitHub so every push deploys on its own. Each step explains what the CLI does on your behalf, so nothing happens behind your back.
+
+If you are new to how Compute fits together, the [resource model](/compute#the-model) is worth a quick look first: a workspace holds projects, a project holds branches, and each branch owns its own app and database.
+
+## Prerequisites
+
+- A JavaScript runtime: Node.js 22.12 or newer for `npx`/`pnpm`, or Bun for `bunx`.
+- A [Prisma Data Platform account](https://pris.ly/pdp).
+- 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. Sign in
+
+A deploy needs an authenticated session, so sign in before anything else:
+
+```npm
+npx @prisma/cli@latest auth login
+```
+
+This opens your browser, signs you in to your Prisma Data Platform account, and stores a session on your machine. Every later command reads that session automatically, so you sign in only once. Anything else running in the same environment inherits it too, including a coding agent working in your project directory.
+
+Confirm who you are signed in as:
+
+```npm
+npx @prisma/cli@latest auth whoami
+```
+
+The browser step needs a human, so it does not work in CI or other headless environments. If you are in a headless environment, authenticate with a [service token](/compute/getting-started#automation-and-ci) instead.
+
+## 2. Deploy your app
+
+From your app directory, run:
+
+```npm
+npx @prisma/cli@latest app deploy
+```
+
+There is no black box here. In one pass, the CLI:
+
+1. **Detects your framework** from your project files, whether that is Next.js, Hono, TanStack Start, or a plain Bun server. To choose it yourself, pass `--framework`.
+2. **Sets up a project** the first time you deploy from this directory, then writes `.prisma/local.json` to pin the directory to that project. That file is a local, gitignored cache rather than committed config. If your team already has a project, [link it first](/compute/getting-started#link-an-existing-project).
+3. **Resolves the target branch.** Inside a Git repository, the CLI uses your current Git branch name; otherwise it falls back to `main`. Pass `--branch <name>` to choose explicitly. Because each branch is its own isolated environment, this is what decides where the deploy lands.
+4. **Builds and uploads your app**, provisions the app, and prints a live URL.
+
+Your first deploy is promoted to production automatically, so the URL you get back is your production URL. To see how projects, branches, and apps relate, see [The model](/compute#the-model).
+
+## 3. Verify the deployment
+
+Open the deployed app in your browser:
+
+```npm
+npx @prisma/cli@latest app open
+```
+
+If the app does not respond the way you expect, stream its logs to see what happened:
+
+```npm
+npx @prisma/cli@latest app logs
+```
+
+Logs cover both the build and the running app, so a failed build and a runtime error both surface in the same place.
+
+## 4. Deploy again
+
+Run `app deploy` whenever you want to ship a change. After your first deploy, production is protected: deploying to your production branch again needs an explicit `--prod` flag, so you never ship to production by accident.
+
+```npm
+npx @prisma/cli@latest app deploy --prod
+```
+
+Deploying from a Git feature branch behaves differently. The CLI resolves that branch name, creates a matching platform branch if one does not exist yet, and gives you an isolated [preview deployment](/compute/branching) with its own app, database, and URL. Preview deploys never ask for confirmation and never affect production, so you can run them as often as you like.
+
+In scripts and CI, add `--yes` to accept the production confirmation up front:
+
+```npm
+npx @prisma/cli@latest app deploy --prod --yes
+```
+
+You can also inspect everything you have deployed in the [Console](https://pris.ly/pdp): projects, branches, apps, deployments, integrations, and domains.
+
+## 5. Connect GitHub
+
+Connecting your repository to GitHub is the recommended way to deploy on Compute, and the workflow most teams settle on. Once it is connected, Prisma deploys on every push, so you rarely run `app deploy` by hand again. From your linked project directory, connect your Git origin:
+
+```npm
+npx @prisma/cli@latest git connect
+```
+
+If the Prisma GitHub App is not installed yet, the CLI starts the install flow in your browser. Once the connection is live, Prisma watches the repository and keeps your platform branches in sync with your Git branches:
+
+- Pushing to a branch builds that commit and updates the matching platform branch's preview.
+- Creating a Git branch creates the matching platform branch.
+- Deleting a Git branch tears its preview down, while leaving production and your default branch alone.
+
+Connecting does not deploy anything on its own; it wires up automation for future pushes, so to ship right now you still run `app deploy`. For the full setup, including monorepos and CI, see the [GitHub integration docs](/compute/github).
+
+## Hand it to your agent
+
+You can also let your coding agent do the deploying. Sign in once yourself ([step 1](#1-sign-in)), because the browser step needs a human. 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 for 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. The first deploy is promoted to production automatically.
+- If the app needs config or secrets, scope them to the environment you're deploying. Use `--role production` for production deploys and `--role preview` for preview branches, then redeploy: `npx @prisma/cli@latest project env add KEY=value --role production` (or `--role preview`). Don't write production config to the preview scope. For the full scoping rules, see [Environment variables](/compute/environment-variables).
+
+## What's next
+
+- [Branching](/compute/branching): how preview branches isolate work and map to your Git branches.
+- [Add environment variables](/compute/environment-variables) for configuration, secrets, and your database connection string.
+- [Deployments](/compute/deployments): promote, roll back, and inspect what you ship.
+- [GitHub integration](/compute/github): the full picture on deploy-on-push, monorepos, and cleanup.
+- [Read the full CLI getting-started guide](/compute/getting-started) for frameworks, project linking, and CI.

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

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

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) and the [Prisma Compute CLI reference](/compute/cli-reference).
+
+:::
+
 ## Usage
 
 ```bash