Drizzle vs Prisma in Late 2026: Which ORM I'd Start With

If you start a TypeScript project this week, my pick is Drizzle, unless your team already knows Prisma well. In that case it's Prisma 7, pinned, and not Prisma 8. The reason is less about query syntax than about where both projects are right now: each one is in the middle of a major version, and Prisma's has a sharp edge you can cut yourself on just by running npm install.

Everything below was checked on October 25, 2026, against npm and the two projects' own docs.

What npm actually gives you today

This is the part most comparison posts are missing, because it only happened in the last few weeks. Prisma's October 2 changelog says it plainly: Prisma ORM 8 "is already what prisma@latest installs, while Prisma ORM 7 is prisma@prev." But only for the CLI package. The client package still points at 7.

So a fresh npm i -D prisma and npm i @prisma/client gets you a version 8 release candidate CLI next to a version 7 client. Prisma's release status page says the version 8 CLI "does not read schema.prisma" (it has its own schema format, which Prisma calls the contract), though since October 2 it can read an existing Prisma 7 Postgres schema as it is. It also needs Node 22.18+ or 24.11+ (24.0 to 24.10 don't work) and TypeScript 5.9+. If you followed a tutorial from last spring, none of that is in it.

The fix is one line in package.json, and Prisma recommends it themselves until 8 is final:

"prisma": "^7",
"@prisma/client": "^7"

General availability for 8 is "expected in October 2026," and version 7 gets bug fixes and security updates for 18 months after that. So 7 is a safe place to sit. I wouldn't build anything real on the 8 RC this month. rc.27 shipped on October 23, which tells you how fast it's still moving.

Drizzle is mid-upgrade too, but in the opposite way. latest is still 0.45.4 (October 8), and v1 lives on the rc tag (1.0.0-rc.5, October 21). You only get v1 if you ask for it with npm i drizzle-orm@rc drizzle-kit@rc. Nothing surprises you.

How they feel to write

Drizzle schemas are TypeScript. There is no generate step, no separate file format, and the query builder reads like the SQL it produces:

// schema.ts
import { pgTable, serial, text, integer, timestamp } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: text('email').notNull().unique(),
});

export const orders = pgTable('orders', {
  id: serial('id').primaryKey(),
  userId: integer('user_id').notNull().references(() => users.id),
  totalCents: integer('total_cents').notNull(),
  createdAt: timestamp('created_at').defaultNow(),
});

import { drizzle } from 'drizzle-orm/node-postgres';
import { eq, sum } from 'drizzle-orm';
import { users, orders } from './schema';

const db = drizzle(process.env.DATABASE_URL!);

const spend = await db
  .select({ email: users.email, spent: sum(orders.totalCents) })
  .from(users)
  .leftJoin(orders, eq(orders.userId, users.id))
  .groupBy(users.email);

If you know SQL, you already know Drizzle. That's my main reason for liking it. When a query is slow, I can read it and see the join, and the EXPLAIN output matches what I wrote.

Prisma 7 is schema-first. You write schema.prisma, run prisma generate, and get a client with the nicest autocomplete in the TypeScript world. Version 7 changed a lot about setup, though, so older answers on Stack Overflow will mislead you. Per the Prisma 7 upgrade guide: the generator is now prisma-client with a required output path, the client needs a driver adapter for every database, the database URL moved into prisma.config.ts, the package is ESM only, and .env is no longer loaded for you.

generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id     Int     @id @default(autoincrement())
  email  String  @unique
  orders Order[]
}

model Order {
  id         Int      @id @default(autoincrement())
  userId     Int
  user       User     @relation(fields: [userId], references: [id])
  totalCents Int
  createdAt  DateTime @default(now())
}

import { PrismaClient } from './generated/prisma/client';
import { PrismaPg } from '@prisma/adapter-pg';

const prisma = new PrismaClient({
  adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL }),
});

const spend = await prisma.order.groupBy({
  by: ['userId'],
  _sum: { totalCents: true },
});

Fine for that query. The trouble starts when you need something groupBy can't express, like the email in the same result. Then you drop to $queryRaw, and now part of your data layer is typed and part is strings. With Drizzle that query was just a join.

Relations and migrations

Prisma's relation model is still its best feature. You declare orders Order[] and include: { orders: true } just works, with nested writes on top. Drizzle's equivalent is its relational query API, and v1 replaces it: the old relations() helper is gone, and you declare everything once with defineRelations() (Drizzle's v2 relations guide). If you start on 0.45 and use relational queries, budget an afternoon to move them later.

Migrations differ in style. prisma migrate dev diffs your schema and writes SQL, and it's the most guided workflow either tool has. drizzle-kit generate does the same from your TypeScript schema. Upgrading Drizzle to v1 means running drizzle-kit up once, which removes journal.json and puts each migration's SQL and snapshot in its own folder (Drizzle's v1 upgrade page). Commit before you run it.

Size and where it runs

npm reports the unpacked size of @prisma/client 7.10.1 at about 74 MB and drizzle-orm 0.45.4 at about 10.5 MB. That isn't what ends up in your bundle, but it hints at how much more machinery Prisma carries. Prisma 7's Rust-free client closed a lot of the old gap on serverless and edge runtimes, which was the main complaint for years. Still, Drizzle has always been the thinner layer, and on Cloudflare Workers or a Lambda with tight cold starts I'd rather have less in the way.

So which one

• New project, you're comfortable with SQL: Drizzle 0.45 now, move to v1 when it's out of RC.
• Team that already ships Prisma: stay on 7 and pin it. Read the version 8 migration pages after GA, not before.
• Lots of nested relational reads, little custom SQL: Prisma 7 is still more pleasant there.
• Anything with reporting queries or odd joins: Drizzle, because you'll write them anyway.

What I wouldn't do is copy a "getting started" snippet from either project's docs without checking which major version it targets. Both sites have v1/v7 and RC pages side by side right now, and they don't always say which one you're reading.

If you're stuck between versions on a real codebase, or an ORM upgrade broke your deploy, book a free call and I'll take a look.