Drizzle ORM - The TypeScript ORM That Doesn't Suck

Been using Drizzle in production for about 18 months now, and it's the first ORM that hasn't made me want to throw my laptop out the window. Just upgraded to v0.44.5 (released September 2025) - still solid as a rock. Here's why it actually works.

Started with Prisma like everyone else, moved to TypeORM, tried Sequelize (big mistake), and finally landed on Drizzle. Each ORM taught me what I actually needed vs what sounded good in documentation.

The TypeScript Integration That Actually Works

Most ORMs treat TypeScript like an afterthought. Prisma generates types, TypeORM uses decorators everywhere, and Sequelize... well, let's not talk about Sequelize. Drizzle schemas are just TypeScript. No code generation bullshit, no prisma generate step that breaks your CI when the moon is in the wrong phase.

// This is your schema. It's TypeScript. That's it.
export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').unique()
});

IntelliSense works immediately. No waiting for generators. No mysterious type errors that disappear after restarting your language server for the third time.

Bundle Size That Won't Kill Your Serverless Functions

At 7.4kb minified+gzipped, Drizzle is smaller than most icon libraries. Compare that to Prisma's chunky client that adds 50kb+ to your Lambda cold starts. When you're paying per millisecond on AWS Lambda or Vercel Functions, that shit adds up fast.

I migrated a Next.js app from Prisma to Drizzle and cold start times dropped by 200ms. AWS bills were noticeably cheaper. The serverless performance guide covers the technical details if you're into that.

The Migration Story That Doesn't Suck

Drizzle Kit generates SQL migrations from your schema changes. No custom DSL to learn, no migration files written in some made-up language. Just SQL that you can actually read and modify when it inevitably generates something weird.

## This actually works and doesn't break mysteriously
npx drizzle-kit generate
npx drizzle-kit migrate

Best part? If the generated migration is wrong, you can just edit the SQL file. Try doing that with Prisma without breaking everything.

Database Support Without the Drama

Works with PostgreSQL, MySQL, SQLite, and all the serverless variants like Neon, Turso, PlanetScale, Cloudflare D1, plus newer drivers like Xata and PGlite. The latest version added Neon HTTP batch support which is fucking fast. No special adapters, no weird connection pool configurations that work in development but shit the bed in production.

I've deployed this on Vercel, Cloudflare Workers, Fly.io, and regular Node.js servers. Same code, different environments, zero config changes. The deployment guides cover all the major platforms.

When Things Break (And They Will)

The error messages are actually helpful. Latest version added DrizzleQueryError that wraps all database driver errors with proper stack traces - no more hunting through cryptic database driver logs. When a query fails, you get real SQL with line numbers. No mysterious "Prisma error P2001" or "TypeORM EntityColumnNotFound: No metadata for User.undefined" bullshit that requires googling every time.

TypeScript catches most issues at compile time. Unlike other ORMs where you find out your query is broken when your user clicks the wrong button in production. Had a foreign key constraint blow up last week - Drizzle showed me exactly which column and the actual SQL that failed.

The Gotchas (Because There Are Always Gotchas)

Connection pooling in serverless can be tricky. Edge functions have limited SQL driver support. The relational query builder is newer and has fewer examples floating around Stack Overflow.

But honestly? These are minor compared to the daily pain of fighting other ORMs. Sometimes simple and working beats feature-complete and broken.

For production debugging, Drizzle Studio beats writing admin panels. The Discord community actually helps instead of telling you to read the docs. And the GitHub repo with its 30k+ stars shows real development activity, not just bot-generated releases.

But enough about why it doesn't suck - let's see how it stacks up against the competition. Because choosing an ORM is like choosing your poison, might as well pick the one that hurts least.

Schemas Are Just TypeScript Files

Stop learning new query languages. Your schema is TypeScript:

import { pgTable, serial, text, varchar, boolean } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: varchar('email', { length: 255 }).notNull().unique(),
  name: text('name'),
  isActive: boolean('is_active').default(true),
});

No separate .prisma files. No YAML configurations. No code generation steps that randomly break your build pipeline. Just TypeScript with proper IntelliSense that works immediately.

The schema declaration docs cover all the column types and constraints. TypeScript strict mode catches schema issues at compile time, not runtime.

Two Ways to Query, Both Work

Drizzle gives you options without forcing you into one pattern:

Relational API for simple stuff:

// Clean and simple for basic queries
const userWithPosts = await db.query.users.findFirst({
  where: eq(users.id, 1),
  with: { posts: true }
});

SQL-like API when you need control:

// When the relational API isn't enough
const complexQuery = await db
  .select()
  .from(users)
  .leftJoin(posts, eq(users.id, posts.userId))
  .where(and(
    eq(users.isActive, true),
    gt(posts.createdAt, lastWeek)
  ))
  .orderBy(desc(posts.createdAt));

Use what makes sense. Mix and match. The types work either way.

Performance That Doesn't Suck

No runtime magic, no reflection, no hidden query builders doing weird shit behind the scenes. Drizzle compiles to straightforward SQL queries.

Cold start times matter in serverless. At 7.4kb with zero dependencies, your Lambda functions actually start up this decade. Tree shaking works properly - unused features don't bloat your bundle.

In benchmarks against other TypeScript ORMs, Drizzle consistently ranks at the top for query performance. The performance docs explain the architectural decisions that make it fast.

Raw SQL When You Need It

The sql template tag lets you drop into raw SQL without losing type safety:

// Complex queries that query builders can't handle
const result = await db.execute(sql`
  SELECT u.name, COUNT(p.id) as post_count
  FROM users u
  LEFT JOIN posts p ON u.id = p.user_id
  WHERE u.created_at > ${lastMonth}
  GROUP BY u.id
  HAVING COUNT(p.id) > 5
`);

PostgreSQL arrays, JSON operations, window functions, CTEs - if your database supports it, Drizzle won't get in your way.

Row-level security works out of the box. Custom types, extensions, fancy indexes - all supported without jumping through hoops. The PostgreSQL guide covers advanced features.

Migrations That Make Sense

Change your schema, run drizzle-kit generate, get SQL files you can actually read:

-- Generated migration - edit if needed
ALTER TABLE "users" ADD COLUMN "last_login" timestamp;
CREATE INDEX "users_last_login_idx" ON "users" ("last_login");

Migration looks wrong? Edit the SQL file. Drizzle won't throw a tantrum like other ORMs do when you modify generated files.

Need to introspect an existing database? drizzle-kit introspect generates schemas from your current tables. Works great for migrations from other ORMs.

Drizzle Studio - The Database GUI That Doesn't Suck

Unlike phpMyAdmin or the generic database browsers, Drizzle Studio understands your schema and relations. Browse data with proper type safety, edit records with validation, export data without SQL gymnastics.

Runs locally for development, can deploy to production for team access. Beats writing admin panels for basic data operations.

These are the features that matter in production. But if you're still on the fence, let me answer the questions I get asked most often. Because implementation details are great, but real-world experience tells the whole story.