Drizzle ORM Adoption Guide: A Complete Getting Started Tutorial

Master TypeScript-first database ORM with schema definitions, CRUD operations, migrations, and best practices for modern Node.js applications

In the evolving landscape of Node.js database tooling, Drizzle ORM has emerged as a compelling alternative to traditional ORMs like Prisma and TypeORM. Born from the community's desire for a lightweight, type-safe, and performant database layer, Drizzle offers a unique approach that combines the developer experience of schema-first design with the flexibility of SQL-driven patterns.

This comprehensive guide walks you through adopting Drizzle ORM in your project, covering everything from initial setup and schema definition to advanced querying patterns and migration strategies. Whether you're building a new application or considering migrating from another ORM, this guide provides the practical knowledge you need to succeed with Drizzle.

What is Drizzle ORM?

Drizzle ORM is a lightweight, TypeScript-first object-relational mapper designed for modern Node.js applications. Unlike heavier ORMs that generate significant runtime overhead, Drizzle takes a minimalist approach--providing type safety and developer experience without sacrificing performance.

At its core, Drizzle embraces two key philosophies:

  • Schema-First Design: Your database schema is defined in TypeScript, serving as the single source of truth for your application.
  • SQL-Like Queries: The query builder mirrors SQL structure, giving developers explicit control over their database interactions while maintaining full type inference.

The project has evolved significantly since its initial release, with the introduction of RQB v2 (Relational Query Builder v2) bringing a more intuitive, object-based approach to complex queries. This evolution reflects Drizzle's commitment to balancing type safety with developer ergonomics.

With over 30,000 GitHub stars and support for PostgreSQL, MySQL, SQLite, MSSQL, CockroachDB, and SingleStore, Drizzle provides developers with a compelling option for building type-safe database applications. The Alternation Engine rewrite, representing 363 commits and over 9,000 tests, demonstrates the team's commitment to production-grade reliability, as noted in Prisma's industry analysis of ORM evolution.

Why Choose Drizzle ORM for Your Project?

Selecting the right ORM is a foundational decision that impacts your application's maintainability, performance, and developer experience. Drizzle offers several compelling advantages that make it worth considering for your next project. Our web development services team regularly implements Drizzle for clients requiring high-performance database layers.

Performance-First Architecture

Drizzle generates minimal runtime code, avoiding the overhead common in heavier ORMs. Queries compile down to efficient SQL statements without unnecessary abstraction layers, resulting in faster execution times and smaller bundle sizes. The lightweight architecture means better cold start times for serverless applications, making Drizzle an excellent choice for platforms like Vercel, Netlify, or AWS Lambda. This performance characteristic is particularly valuable when building AI-powered applications that require efficient database interactions.

Full TypeScript Integration

Type safety isn't an afterthought--it's baked into every layer of Drizzle. From schema definitions to query results, TypeScript inference ensures that type errors catch bugs at compile time rather than runtime. When you define your schema, TypeScript automatically infers types for all your database operations through the $inferSelect and $inferInsert helpers.

Flexible Query Building

With Drizzle, you can choose between a SQL-like query builder syntax and the newer RQB v2 approach. This flexibility allows you to match your query style to the complexity of your operations. The combination of SQL transparency and TypeScript type safety creates an excellent developer experience--you can see exactly what SQL is being generated while enjoying the benefits of type-safe code.

Robust Migration System

Drizzle Kit provides a comprehensive migration system that generates migration files automatically from schema changes. The Alternation Engine rewrite (363 commits, 9,000+ tests) ensures reliable, production-ready migrations that can be reviewed before execution.

Getting Started with Drizzle ORM

Installing Drizzle ORM is straightforward, with the core package and driver-specific modules available via npm. The installation process involves adding Drizzle and your chosen database driver to your project dependencies.

1# Install Drizzle ORM core and PostgreSQL driver2npm install drizzle-orm drizzle-kit3npm install drizzle-kit --save-dev4 5# Install PostgreSQL driver (or mysql2, better-sqlite3)6npm install @neondatabase/serverless

After installation, you'll configure your database connection and initialize Drizzle in your project. This involves setting up a connection to your database and configuring Drizzle Kit for migrations.

1import { neon } from '@neondatabase/serverless';2import { drizzle } from 'drizzle-orm/neon-http';3 4const sql = neon(process.env.DATABASE_URL!);5export const db = drizzle(sql);
1import type { Config } from 'drizzle-kit';2 3export default {4 schema: './src/db/schema.ts',5 out: './drizzle',6 dialect: 'postgresql',7 dbCredentials: {8 url: process.env.DATABASE_URL!,9 },10} satisfies Config;

Defining Your Database Schema

Drizzle's schema definition system uses TypeScript to define your database tables. Tables are created using the table helper functions (pgTable for PostgreSQL, mysqlTable for MySQL, or sqliteTable for SQLite), with columns defined using column helper functions that provide type safety and validation. This schema-first approach means your TypeScript definitions serve as the single source of truth for your application.

1import { pgTable, serial, text, integer, timestamp, boolean, decimal, uuid } from 'drizzle-orm/pg-core';2import { relations } from 'drizzle-orm';3 4// Users table5export const users = pgTable('users', {6 id: serial('id').primaryKey(),7 username: text('username').notNull().unique(),8 email: text('email').notNull().unique(),9 passwordHash: text('password_hash').notNull(),10 bio: text('bio'),11 avatarUrl: text('avatar_url'),12 createdAt: timestamp('created_at').defaultNow().notNull(),13 updatedAt: timestamp('updated_at').defaultNow().notNull(),14});15 16// Posts table17export const posts = pgTable('posts', {18 id: serial('id').primaryKey(),19 title: text('title').notNull(),20 slug: text('slug').notNull().unique(),21 excerpt: text('excerpt'),22 content: text('content').notNull(),23 published: boolean('published').default(false).notNull(),24 authorId: integer('author_id').references(() => users.id).notNull(),25 viewCount: integer('view_count').default(0).notNull(),26 createdAt: timestamp('created_at').defaultNow().notNull(),27 updatedAt: timestamp('updated_at').defaultNow().notNull(),28});29 30// Comments table31export const comments = pgTable('comments', {32 id: serial('id').primaryKey(),33 content: text('content').notNull(),34 authorId: integer('author_id').references(() => users.id).notNull(),35 postId: integer('post_id').references(() => posts.id).notNull(),36 parentId: integer('parent_id'),37 createdAt: timestamp('created_at').defaultNow().notNull(),38});

The schema definition supports various column types, constraints, and defaults. Key columns like primary keys, foreign keys, timestamps, and unique constraints are all defined declaratively, with Drizzle generating the appropriate DDL statements during migration. You can also define indexes, check constraints, and custom SQL expressions using the index and check helpers.

Working with Database Relationships

Drizzle's relations system enables powerful data retrieval patterns through explicitly defined table relationships. Using the relations helper, you define how tables relate to each other, then use these definitions to query related data efficiently. The release of Drizzle's Relational API v2 (RQB v2) marked a major milestone, introducing object-based queries that mirror what developers have come to expect from mature ORMs.

1import { relations } from 'drizzle-orm';2import { users, posts, comments } from './schema';3 4// Define users relations5export const usersRelations = relations(users, ({ many }) => ({6 posts: many(posts),7 comments: many(comments),8}));9 10// Define posts relations11export const postsRelations = relations(posts, ({ one, many }) => ({12 author: one(users, {13 fields: [posts.authorId],14 references: [users.id],15 }),16 comments: many(comments),17}));18 19// Define comments relations20export const commentsRelations = relations(comments, ({ one }) => ({21 author: one(users, {22 fields: [comments.authorId],23 references: [users.id],24 }),25 post: one(posts, {26 fields: [comments.postId],27 references: [posts.id],28 }),29 parent: one(comments, {30 fields: [comments.parentId],31 references: [comments.id],32 }),33}));

With relationships defined, you can leverage RQB v2 to retrieve related data with full type safety. The query builder automatically infers the structure of related data, ensuring that your application code accurately reflects your database schema. This approach eliminates N+1 query problems and provides a clean, type-safe way to work with related data.

1import { db } from './config';2import { users, posts, comments } from './schema';3import { usersRelations, postsRelations } from './relations';4import { eq, desc } from 'drizzle-orm';5 6// Find user with all their posts7const userWithPosts = await db.query.users.findFirst({8 where: eq(users.id, 1),9 with: {10 posts: {11 where: eq(posts.published, true),12 orderBy: [desc(posts.createdAt)],13 limit: 10,14 },15 },16});17 18// Find post with author and comments19const postWithDetails = await db.query.posts.findFirst({20 where: eq(posts.slug, 'drizzle-orm-guide'),21 with: {22 author: true,23 comments: {24 with: {25 author: true,26 },27 },28 },29});

CRUD Operations with Drizzle

Drizzle provides two approaches for CRUD operations: the SQL-like query builder for those who prefer explicit SQL-like syntax, and RQB v2 for object-based queries. Both approaches offer full type inference and can be mixed freely within your application. The type inference extends to query results, allowing autocomplete for column names, proper null handling, and type-safe filtering and sorting operations.

1import { db } from './config';2import { users, posts } from './schema';3import { eq } from 'drizzle-orm';4 5// Single insert6const [newUser] = await db.insert(users).values({7 username: 'john_doe',8 email: '[email protected]',9 passwordHash: 'hashed_password',10}).returning();11 12// Multiple inserts13const newPosts = await db.insert(posts).values([14 {15 title: 'Getting Started with Drizzle',16 slug: 'getting-started-drizzle',17 content: 'Drizzle is a lightweight ORM...',18 authorId: newUser.id,19 published: true,20 },21 {22 title: 'Advanced Drizzle Patterns',23 slug: 'advanced-drizzle-patterns',24 content: 'Advanced patterns in Drizzle...',25 authorId: newUser.id,26 published: false,27 },28]).returning();
1import { db } from './config';2import { users, posts } from './schema';3import { eq, desc, like, and, gte } from 'drizzle-orm';4 5// Find by ID6const user = await db.query.users.findFirst({7 where: eq(users.id, 1),8});9 10// Query builder approach11const publishedPosts = await db.select()12 .from(posts)13 .where(and(14 eq(posts.published, true),15 like(posts.title, '%Drizzle%')16 ))17 .orderBy(desc(posts.createdAt))18 .limit(10);19 20// Get all users with post count (aggregation)21const usersWithCounts = await db.select({22 id: users.id,23 username: users.username,24 postCount: sql<number>`count(${posts.id})`,25})26 .from(users)27 .leftJoin(posts, eq(users.id, posts.authorId))28 .groupBy(users.id);
1import { db } from './config';2import { posts } from './schema';3import { eq, desc } from 'drizzle-orm';4 5// Update operation6const [updatedPost] = await db.update(posts)7 .set({8 title: 'Updated Title',9 updatedAt: new Date(),10 })11 .where(eq(posts.id, 1))12 .returning();13 14// Delete operation15const [deletedPost] = await db.delete(posts)16 .where(eq(posts.slug, 'old-post'))17 .returning();18 19// Upsert (insert or update on conflict)20const [upsertedPost] = await db.insert(posts)21 .values({22 title: 'Existing or New Post',23 slug: 'existing-or-new',24 content: 'Content here',25 authorId: 1,26 })27 .onConflictDoUpdate({28 target: posts.slug,29 set: {30 title: 'Updated via upsert',31 content: 'New content',32 },33 })34 .returning();

Transactions and Advanced Query Features

Drizzle's transaction support enables atomic operations across multiple queries, ensuring data consistency for complex operations. Transactions can be created using the transaction method, with explicit or implicit transaction modes. If any operation within the transaction fails, all changes are automatically rolled back.

1import { db } from './config';2import { users, posts, comments } from './schema';3import { eq } from 'drizzle-orm';4 5// Create a new post with a comment in a transaction6await db.transaction(async (tx) => {7 // Create the post8 const [newPost] = await tx.insert(posts).values({9 title: 'New Blog Post',10 slug: 'new-blog-post',11 content: 'Post content...',12 authorId: 1,13 published: true,14 }).returning();15 16 // Create initial comment17 await tx.insert(comments).values({18 content: 'First comment!',19 authorId: 1,20 postId: newPost.id,21 });22 23 // Update author's post count (if you have such a field)24 await tx.update(users)25 .set({ postCount: sql`post_count + 1` })26 .where(eq(users.id, 1));27});28 29// Transaction with explicit settings30await db.transaction(async (tx) => {31 // Transaction operations here32}, {33 isolationLevel: 'read committed',34 accessMode: 'read write',35});

Raw SQL and Subqueries

For complex queries that exceed the query builder's capabilities, Drizzle allows raw SQL expressions and subqueries while maintaining type safety through the sql helper. This approach is useful for database-specific features, complex aggregations, or when you need fine-grained control over the generated SQL.

1import { db, sql } from './config';2import { users, posts } from './schema';3import { gte, desc } from 'drizzle-orm';4 5// Raw SQL with type-safe parameters6const recentUsers = await db.execute(sql`7 SELECT id, username, email8 FROM users9 WHERE created_at > NOW() - INTERVAL '30 days'10 ORDER BY created_at DESC11`);12 13// Using sql helper for complex expressions14const usersWithStats = await db.select({15 id: users.id,16 username: users.username,17 postCount: sql<number>`count(${posts.id})`,18 avgPostLength: sql<number>`avg(length(${posts.content}))`,19})20 .from(users)21 .leftJoin(posts, eq(users.id, posts.authorId))22 .where(sql`${users.createdAt} > NOW() - INTERVAL '90 days'`)23 .groupBy(users.id)24 .having(sql`count(${posts.id}) > 0`);25 26// JSON column access (PostgreSQL)27const usersWithMeta = await db.select({28 id: users.id,29 username: users.username,30 lastLogin: sql<string>`${users.metadata}->>'last_login'`,31})32 .from(users);

Migrations with Drizzle Kit

Drizzle Kit is the official CLI tool for managing database migrations. It generates migration files from schema changes, applies migrations to your database, and provides a push command for rapid prototyping. The migration system has been rewritten as the Alternation Engine, featuring 363 commits and over 9,000 tests for reliability.

1# Generate migration files from schema changes2npx drizzle-kit generate3 4# Push schema changes directly (for development)5npx drizzle-kit push6 7# Apply pending migrations to database8npx drizzle-kit migrate9 10# Pull schema from existing database11npx drizzle-kit pull12 13# Open Drizzle Studio (GUI database browser)14npx drizzle-kit studio

Migration File Structure

Each migration consists of two files: an SQL file containing the actual database changes, and a meta file tracking the migration state. Generated migrations are deterministic and can be reviewed before execution. For production deployments, always review generated SQL files and use the migrate command rather than push.

1-- CreateUsers table2CREATE TABLE IF NOT EXISTS "users" (3 "id" serial PRIMARY KEY NOT NULL,4 "username" text NOT NULL,5 "email" text NOT NULL,6 "password_hash" text NOT NULL,7 "bio" text,8 "avatar_url" text,9 "created_at" timestamp DEFAULT NOW() NOT NULL,10 "updated_at" timestamp DEFAULT NOW() NOT NULL11);12 13-- CreateIndex for unique constraints14CREATE UNIQUE INDEX IF NOT EXISTS "users_username_idx" ON "users"("username");15CREATE UNIQUE INDEX IF NOT EXISTS "users_email_idx" ON "users"("email");16 17-- CreatePosts table18CREATE TABLE IF NOT EXISTS "posts" (19 "id" serial PRIMARY KEY NOT NULL,20 "title" text NOT NULL,21 "slug" text NOT NULL,22 "excerpt" text,23 "content" text NOT NULL,24 "published" boolean DEFAULT false NOT NULL,25 "author_id" integer NOT NULL,26 "view_count" integer DEFAULT 0 NOT NULL,27 "created_at" timestamp DEFAULT NOW() NOT NULL,28 "updated_at" timestamp DEFAULT NOW() NOT NULL29);30 31-- Create foreign key32DO $$ BEGIN33 ALTER TABLE "posts" ADD CONSTRAINT "posts_author_id_users_id_fk"34 FOREIGN KEY ("author_id") REFERENCES "users"("id") ON DELETE no action ON UPDATE no action;35EXCEPTION36 WHEN duplicate_object THEN null;37END $$;

Drizzle Studio: Built-in Database GUI

Drizzle Studio is a web-based interface for browsing and editing your database. Launched with a simple command, it provides a visual way to inspect tables, run queries, and make data modifications without leaving your development environment.

1# Launch Drizzle Studio2npx drizzle-kit studio3 4# Studio runs on http://localhost:4983 by default

Studio is particularly useful during development for:

  • Inspecting schema changes after running migrations
  • Quick data exploration and debugging
  • Testing queries before implementing them in code
  • Making one-off data modifications during development

While convenient for development, Studio should not be used in production environments. For production database management, use the migration system and direct database connections.

Performance and Best Practices

Getting the most out of Drizzle requires understanding its performance characteristics and following established patterns. These best practices will help you build efficient, maintainable applications.

Optimize Query Patterns

Use selective column fetching when you don't need all fields. Drizzle allows specifying exact columns to return, reducing memory usage and network overhead. Avoid N+1 queries by leveraging the relation system and proper eager loading with RQB v2.

1// Select specific columns instead of all2const posts = await db.select({3 id: posts.id,4 title: posts.title,5 slug: posts.slug,6 createdAt: posts.createdAt,7})8 .from(posts)9 .where(eq(posts.published, true))10 .limit(10);11 12// Use indexed queries with proper WHERE clauses13const recentPosts = await db.select()14 .from(posts)15 .where(and(16 eq(posts.published, true),17 gte(posts.createdAt, thirtyDaysAgo)18 ))19 .orderBy(desc(posts.createdAt))20 .limit(20);21 22// Batch operations for bulk inserts23const BATCH_SIZE = 100;24for (let i = 0; i < data.length; i += BATCH_SIZE) {25 const batch = data.slice(i, i + BATCH_SIZE);26 await db.insert(posts).values(batch);27}

Connection Pooling

For production deployments, configure connection pooling to manage database connections efficiently. Serverless environments and high-traffic applications benefit significantly from pooled connections. Configure appropriate pool sizes, idle timeouts, and connection timeouts based on your application's load patterns.

Type Safety Patterns

Extract frequently used query patterns into reusable functions that preserve type inference. This reduces duplication and ensures consistent query behavior across your application. Consider using the repository pattern to encapsulate database operations while maintaining full type safety.

1import { db } from './config';2import { posts, users } from './schema';3import { eq, desc, type SQL } from 'drizzle-orm';4 5// Repository pattern with type safety6export const postRepository = {7 async findPublished(limit = 10) {8 return await db.select()9 .from(posts)10 .where(eq(posts.published, true))11 .orderBy(desc(posts.createdAt))12 .limit(limit);13 },14 15 async findBySlug(slug: string) {16 return await db.query.posts.findFirst({17 where: eq(posts.slug, slug),18 with: {19 author: true,20 },21 });22 },23 24 async incrementViewCount(id: number) {25 await db.update(posts)26 .set({ viewCount: sql`view_count + 1` })27 .where(eq(posts.id, id));28 },29 30 async deleteById(id: number) {31 const [deleted] = await db.delete(posts)32 .where(eq(posts.id, id))33 .returning();34 return deleted;35 },36};

Drizzle vs. Prisma: Understanding the Trade-offs

The Node.js ORM landscape has evolved significantly, with both Drizzle and Prisma converging on similar patterns while maintaining distinct philosophies. Understanding these differences helps you choose the right tool for your project.

Prisma initially popularized the schema-first approach, generating type-safe clients from declarative schema definitions. Drizzle builds on this foundation while addressing common pain points: faster cold starts, smaller bundle sizes, and more explicit control over SQL generation.

Recent developments show both projects influencing each other, with Prisma adding more explicit query options and Drizzle improving its developer experience. This convergence benefits developers by combining the best aspects of both approaches.

Drizzle vs Prisma: Key Differences

Bundle Size

Drizzle (~150KB) vs Prisma (1MB+) - significant for serverless and edge deployments

Cold Start

Drizzle starts faster, making it ideal for AWS Lambda, Vercel, and Netlify functions

Type Generation

Drizzle uses runtime inference; Prisma uses build-time code generation

Query Style

Drizzle offers SQL-like + RQB v2; Prisma uses chained builder syntax

Database Support

Drizzle: PostgreSQL, MySQL, SQLite; Prisma adds MongoDB and SQL Server

Conclusion: Is Drizzle ORM Right for Your Project?

Drizzle ORM represents a compelling choice for modern Node.js applications, particularly those built with TypeScript. Its lightweight nature, excellent type safety, and flexible query building make it well-suited for projects ranging from small APIs to large-scale applications.

Consider Drizzle if your project prioritizes:

  • Performance and minimal runtime overhead
  • Full TypeScript type inference without code generation steps
  • Explicit control over SQL queries
  • Rapid development with Drizzle Kit and Studio
  • PostgreSQL, MySQL, or SQLite as your primary database

While Drizzle may not be the right choice for every scenario--especially when you need MongoDB support or prefer a more abstracted query interface--it offers a well-balanced approach that combines the best aspects of schema-first design with SQL-like flexibility.

As the ecosystem continues to mature, Drizzle's commitment to performance and type safety positions it as a lasting player in the Node.js ORM landscape. Whether you're starting a new project or considering migration from another ORM, Drizzle provides the tools and patterns needed to build robust, type-safe database interactions. Our web development team can help you implement Drizzle ORM in your next project or optimize your existing database layer.

Sources

  1. Drizzle ORM Official Documentation - Primary source for official documentation, features, and getting started guide
  2. Drizzle ORM GitHub Repository - 30k+ stars, active open source project
  3. LogRocket: Drizzle ORM Adoption Guide - Comprehensive adoption guide with examples and alternatives
  4. Better Stack: Getting Started with Drizzle ORM - Step-by-step CRUD tutorial with SQLite
  5. Prisma: The ORM Convergence - Industry analysis of ORM evolution and Drizzle's Relational API v2

Ready to Modernize Your Database Layer?

Our team specializes in building high-performance Node.js applications with modern database patterns. Let us help you adopt Drizzle ORM or design the optimal data layer for your project.