Why I Started Using Drizzle ORM

Most ORMs promise two things:

  • Write less SQL.

  • Move faster with type safety and abstractions. But in practice, they:

  • Abstract too much and hide SQL behaviour (hello, Sequelize),

  • Introduce separate schema languages (like Prisma’s DSL),

  • Or are simply too bloated for microservices. Drizzle ORM hits the sweet spot. It’s just TypeScript. You define your schema in code, and the database reflects it. No context switching, no magic strings, no mismatched types.

Entity Definition with Drizzle

Defining entities (called schema in Drizzle), is very simple. With the typescript file, and attributes you can simply define the schema like this:

typescript

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

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: varchar('email', { length: 255 }),
});

Very good part about this is, everytime when you change something, you’ll see the errors in IDE, and refactor easily, instead of string searching.

Queries

Unlike Prisma or Sequelize, Drizzle doesn’t try to be an ORM with a model layer. It’s a query builder with strong typing, which I prefer.

import { eq } from 'drizzle-orm';
import { db } from './db';
import { users } from './schema';
const user = await db.select().from(users).where(
    eq(users.email, 'test@example.com')
);

Simple, expressive, and type safe. You get proper types for inputs and outputs, and you know exactly what SQL it’s generating.

Real World Use in Node.js Backends

In actual production use API servers built with Express, Fastify, I found Drizzle to be:

  • Stable under load
  • Easy to debug
  • Great with Postgres and SQLite
  • Minimal runtime overhead
  • It integrates cleanly with connection pools like pg, and you can layer it on top of any architecture monolith or microservice.

Cons

  • This is a relatively new technology compared to Prisma or Sequelize, and it is still evolving.
  • Database support is limited—it works great with PostgreSQL and SQLite, but MySQL support is still in progress.

Final Thoughts

Drizzle ORM is for backend engineers who understand SQL and want static guarantees without runtime complexity. It’s not a drop in model- ayer ORM like Prisma or Sequelize. it’s a different mindset: write your database logic as TypeScript, explicitly.

In 2025, I’ve made Drizzle my go to tool for most Node.js backend work, especially where I need clean, transparent, maintainable data layers.

If you’re serious about type safety, schema management, and long-term maintainability in TypeScript backends, Drizzle deserves a spot in your toolkit.