Prisma Stack

The connected TypeScript stack

An application runtime, a Postgres database, and a type-safe data layer that arrive already connected. Fewer dependencies, less configuration, one command to start.

$ npm create prisma@next

Start building Explore the stack

The stack, simplified

Prisma plus your framework is the whole stack

Hosting, runtime, data access, and database ship as one connected platform, so the only decision left open is your framework. The alternative is stitching those layers together from four vendors, where every seam adds configuration and something new to break.

One connected platform. The framework on top is your call.

Any framework

Your application

The one layer Prisma has no opinion about, on purpose. Every major frontend and backend framework runs on the stack unchanged, with the same runtime, database, and deploy underneath.

Next.js, TanStack Start, Hono, NestJS, and more
Change framework without touching the data layer
Plain TypeScript projects, no proprietary app model

Runs unchanged on the stack

See the framework guides

Runtime

Bun

The runtime your application executes on, in development and in production. Batteries included: the tooling most projects assemble from a dozen packages is built in.

HTTP server, test runner, and bundler built in
Runs TypeScript directly, no build step
Package manager with a fast lockfile

Built into the runtime

Bun.serve()
bun test
Bun bundler
Bun.password
Bun.s3
Bun.redis
Bun.file
TS + JSX

Learn about Bun

Database

Prisma Postgres

A managed Postgres database provisioned together with your app. Common capabilities stay inside the database instead of becoming extra services to run and pay for.

Standard Postgres, works with any Postgres client
Extensions enabled with one command
Preview branches get their own database copy

Extensions one command away

pgvector
pg_search
pg_cron
pg_trgm
pg_stat_statements
uuid-ossp

Explore Prisma Postgres

How it works

From empty folder to production

One command scaffolds the app, the database, the typed client, and the deploy target. Step through what happens next.

From empty folder to productionStep 1 of 6

Your application
Prisma ORM
Prisma Postgres
Prisma Compute + Bun

$ npm create prisma@next

✔ Framework · Hono
✔ ORM       · Prisma Next
✔ Database  · Prisma Postgres

Generating the typed client   ✓
Provisioning Prisma Postgres  ✓
Configuring Compute deploys   ✓

cd my-app && npm run dev

$ npm create prisma@next

✔ Framework · Hono
✔ ORM       · Prisma Next
✔ Database  · Prisma Postgres

Generating the typed client   ✓
Provisioning Prisma Postgres  ✓
Configuring Compute deploys   ✓

cd my-app && npm run dev

my-app/
  prisma/
    schema.prisma       # your data model
    db.ts               # typed client, generated
  src/
    index.ts            # your application
  prisma.config.ts      # database + deploy config
  package.json

model User {
  id    String  @id @default(cuid(2))
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        String  @id @default(cuid(2))
  title     String
  published Boolean @default(false)
  author    User    @relation(fields: [authorId], references: [id])
  authorId  String
}

import { db } from "./prisma/db";

const posts = await db.orm.public.Post
  .where({ published: true })
  .include("author")
  .all();

// typeof posts
// Array<Post & { author: User }>
//
// [{ id: "k9dq…", title: "Hello Prisma",
//    author: { name: "Ada", … } }]

$ npx @prisma/cli app deploy

Building with Bun     ✓
Uploading             ✓
Promoting to production

https://my-app.prisma.build
→ same database, same client, no config changes

-- Semantic search without a separate vector database
CREATE EXTENSION vector;

ALTER TABLE "Post" ADD COLUMN embedding vector(1536);

SELECT id, title FROM "Post"
ORDER BY embedding <-> $1
LIMIT 5;

One command creates the application, provisions a Prisma Postgres database, sets up Prisma Next, and configures the project for Prisma Compute. Nothing to wire together by hand.

Your stack, your call

Opinionated by default, replaceable by design

The happy path is one command and no glue code. But every layer is a default, not a requirement: the stack works as a whole, and each piece works alone.

Data access

Prisma Next

Or swap it: Drop to raw SQL with the built-in query builder, or use any Postgres client.

Any Postgres client

SQL query builder docs

Database

Prisma Postgres

Or swap it: It speaks standard Postgres. Point the ORM at any Postgres database, anywhere.

Any PostgreSQL database

Connect any client

Hosting

Prisma Compute

Or swap it: Deploy the same app to Vercel, AWS, or your own servers.

Vercel
AWS

Deployment guides

Runtime

Bun

Or swap it: Your code is standard TypeScript. Run it on Node.js if you prefer.

Node.js

Add to an existing project

Prisma Next + Prisma Postgres

One schema, typed all the way down

The data layer is one piece: the database, the migrations, and the client all derive from the same schema.

Queries that match your schema

Types come from the schema, so typos fail in your editor, not in production.

post.title
post.titel

How queries work

Migrations you can review

Schema changes become versioned files that apply the same way everywhere.

0042_add_posts
review in a PR

How migrations work

Capabilities without extra services

Features you would otherwise host separately live inside Postgres:

pgvector
pg_search
pg_cron
pg_stat_statements

Browse the extensions

Prisma Compute + Bun

Deploy the way you develop

Prisma Compute runs your app on Bun in production, so the runtime you develop against is the runtime that serves traffic.

One command to production

The first deploy creates the project, the branch, and the database it runs on.

prisma app deploy
my-app.prisma.build

How deploys work

A preview per branch

Reviews run against real infrastructure, not a shared staging server.

feature/search
own database copy

How branching works

Less tooling to maintain

The usual pile of dev dependencies is built into the runtime.

Bun.serve()
bun test
bundler

Prisma Next on Bun

Built for developers and agents

A stack agents can read

Agent-driven development works when a project is explicit. The Prisma Stack keeps its structure, contracts, and workflows in plain files that an agent can read, change, and verify.

One project shape

An agent that knows one Prisma Stack project knows them all.

prisma/schema.prisma
src/index.ts

Scaffold a project

The schema is the contract

The data model is one readable file: inspect it, diff it, regenerate the types.

Model your data

A typed feedback loop

Agents iterate against the compiler, not runtime failures.

Explore Prisma Next

Workflows in plain text

Migrations are files and deploys are commands, reviewable before and after they run.

Deploy from Git

See how to build with Prisma and AI tools

Stop configuring. Start shipping.

One command gives you a running application, a Prisma Postgres database, a typed Prisma Next client, and a deploy target on Prisma Compute. Connected from the first minute.

$ npm create prisma@next

Read the docs Open the Console