Dev Note

Neon Serverless Postgres + Drizzle ORM: The Modern Full-Stack Database Stack
If you’re building a modern web application in 2026 and still managing your own Postgres instance, you’re probably wasting ops time you don’t need to spend. Neon has matured into the de facto serverless Postgres platform, and paired with Drizzle ORM, you get a type-safe, zero-ops database experience that feels like it should have existed years ago.
This guide covers the full stack: Neon setup, Drizzle schema, queries, migrations, and production patterns.
Photo by Tobias Fischer on Unsplash
Why Neon?
Neon solves the core problems of serverless databases:
The cold-start problem is dead. Neon’s “scale-to-zero” computes restart in under 500ms in 2026. With their persistent connection pooler (built on PgBouncer), most requests don’t even see a cold start.
Branching is a game-changer. Create a copy-on-write branch of your production database in seconds. Every PR gets its own database branch. No more “dev DB is out of sync with prod.”
main ──────────────────────────── production
      └── feature/auth ─────── dev/staging
      └── pr/fix-user-query ── CI/CD testing
True Postgres. Not Postgres-compatible. Not a subset. Full Postgres 17 with extensions (pgvector, PostGIS, etc.).
Getting Started with Neon
Setup
# Install Neon CLI
npm install -g neonctl
# Authenticate
neonctl auth
# Create a project
neonctl projects create --name my-app-db --region-id aws-us-east-1
# Get connection string
neonctl connection-string
# postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/neondb?sslmode=require
Environment Setup
# .env
DATABASE_URL="postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/neondb?sslmode=require"
# For edge environments (Cloudflare Workers, Vercel Edge)
DATABASE_URL_POOLED="postgresql://user:pass@ep-xxx-pooler.us-east-1.aws.neon.tech/neondb?sslmode=require"
Neon provides two endpoints:
Direct (ep-xxx.region.aws.neon.tech) — for serverless functions with long-lived connections
Pooled (ep-xxx-pooler.region...) — for edge functions with many short connections
Drizzle ORM: Why Not Prisma?
The Prisma vs Drizzle debate was settled in 2026. Drizzle won for most new projects:
Feature
      Drizzle
      Prisma
    
Bundle size
      ~20KB
      ~500KB+
    
Edge compatible
      ✅
      ⚠️ (Prisma Accelerate needed)
    
SQL proximity
      High (write SQL-like)
      Low (abstracted)
    
Type safety
      ✅ Excellent
      ✅ Excellent
    
Schema in code
      ✅ TypeScript
      Prisma schema lang
    
Migrations
      ✅ SQL files
      ✅ Prisma migrate
    
Raw SQL
      ✅ First-class
      ⚠️ $queryRaw
    
Performance
      ✅ Zero overhead
      Moderate overhead
    
Drizzle’s philosophy: write SQL, get types. If you know SQL, Drizzle feels instantly familiar.
Installation
# Install Drizzle + Neon driver
npm install drizzle-orm @neondatabase/serverless
npm install -D drizzle-kit
# Or with Bun (faster)
bun add drizzle-orm @neondatabase/serverless
bun add -d drizzle-kit
Schema Definition
Everything is TypeScript — no separate schema files, no code generation needed:
// src/db/schema.ts
import { 
  pgTable, 
  text, 
  integer, 
  timestamp, 
  boolean,
  uuid,
  jsonb,
  index,
  uniqueIndex,
  pgEnum
} from "drizzle-orm/pg-core";
import { relations } from "drizzle-orm";
// Enums
export const userRoleEnum = pgEnum("user_role", ["admin", "user", "viewer"]);
export const postStatusEnum = pgEnum("post_status", ["draft", "published", "archived"]);
// Users table
export const users = pgTable("users", {
  id: uuid("id").primaryKey().defaultRandom(),
  email: text("email").notNull(),
  name: text("name").notNull(),
  role: userRoleEnum("role").default("user").notNull(),
  avatarUrl: text("avatar_url"),
  isActive: boolean("is_active").default(true).notNull(),
  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
}, (table) => ({
  emailIdx: uniqueIndex("users_email_idx").on(table.email),
  roleIdx: index("users_role_idx").on(table.role),
}));
// Posts table
export const posts = pgTable("posts", {
  id: uuid("id").primaryKey().defaultRandom(),
  title: text("title").notNull(),
  slug: text("slug").notNull(),
  content: text("content"),
  status: postStatusEnum("status").default("draft").notNull(),
  metadata: jsonb("metadata").$type<{
    views: number;
    readTime: number;
    tags: string[];
  }>(),
  authorId: uuid("author_id").notNull().references(() => users.id, {
    onDelete: "cascade"
  }),
  publishedAt: timestamp("published_at", { withTimezone: true }),
  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
}, (table) => ({
  slugIdx: uniqueIndex("posts_slug_idx").on(table.slug),
  authorIdx: index("posts_author_idx").on(table.authorId),
  statusIdx: index("posts_status_idx").on(table.status),
}));
// Comments table
export const comments = pgTable("comments", {
  id: uuid("id").primaryKey().defaultRandom(),
  content: text("content").notNull(),
  postId: uuid("post_id").notNull().references(() => posts.id, { onDelete: "cascade" }),
  authorId: uuid("author_id").notNull().references(() => users.id, { onDelete: "cascade" }),
  parentId: uuid("parent_id"),  // For nested comments
  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
});
// Relations (for type inference in joins)
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
  comments: many(comments),
}));
export const postsRelations = relations(posts, ({ one, many }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
  comments: many(comments),
}));
export const commentsRelations = relations(comments, ({ one }) => ({
  post: one(posts, {
    fields: [comments.postId],
    references: [posts.id],
  }),
  author: one(users, {
    fields: [comments.authorId],
    references: [users.id],
  }),
}));
Database Client Setup
// src/db/index.ts
import { neon } from "@neondatabase/serverless";
import { drizzle } from "drizzle-orm/neon-http";
import * as schema from "./schema";
// HTTP-based driver (best for serverless/edge)
const sql = neon(process.env.DATABASE_URL!);
export const db = drizzle(sql, { schema });
// Export types
export type DB = typeof db;
// For type inference
export type User = typeof schema.users.$inferSelect;
export type NewUser = typeof schema.users.$inferInsert;
export type Post = typeof schema.posts.$inferSelect;
export type NewPost = typeof schema.posts.$inferInsert;
For WebSocket-based connections (better for long-lived Node.js processes):
// src/db/node.ts — for Node.js servers (not edge)
import { Pool } from "@neondatabase/serverless";
import { drizzle } from "drizzle-orm/neon-serverless";
import * as schema from "./schema";
import ws from "ws";
// Enable WebSocket for serverless driver
import { neonConfig } from "@neondatabase/serverless";
neonConfig.webSocketConstructor = ws;
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
export const db = drizzle(pool, { schema });
Queries: The Drizzle Way
Basic CRUD
import { db } from "./db";
import { users, posts } from "./db/schema";
import { eq, and, or, like, desc, count, sum, avg, sql } from "drizzle-orm";
// INSERT
const [newUser] = await db.insert(users).values({
  email: "alice@example.com",
  name: "Alice Johnson",
  role: "user",
}).returning();
console.log(newUser.id); // fully typed!
// SELECT with filtering
const activeAdmins = await db
  .select()
  .from(users)
  .where(
    and(
      eq(users.role, "admin"),
      eq(users.isActive, true)
    )
  )
  .orderBy(desc(users.createdAt))
  .limit(10);
// UPDATE
const [updatedUser] = await db
  .update(users)
  .set({ 
    name: "Alice Smith",
    updatedAt: new Date()
  })
  .where(eq(users.id, newUser.id))
  .returning();
// DELETE
await db.delete(users).where(eq(users.id, "some-uuid"));
// UPSERT (INSERT ... ON CONFLICT)
const [upserted] = await db
  .insert(users)
  .values({ email: "alice@example.com", name: "Alice" })
  .onConflictDoUpdate({
    target: users.email,
    set: { name: "Alice", updatedAt: new Date() }
  })
  .returning();
Joins with Relations
// Using query builder (relational mode)
const postsWithAuthors = await db.query.posts.findMany({
  where: eq(posts.status, "published"),
  with: {
    author: {
      columns: {
        id: true,
        name: true,
        avatarUrl: true,
      }
    },
    comments: {
      limit: 5,
      orderBy: [desc(comments.createdAt)],
      with: {
        author: {
          columns: { id: true, name: true }
        }
      }
    }
  },
  orderBy: [desc(posts.publishedAt)],
  limit: 20,
});
// Type is fully inferred — no type assertions needed!
for (const post of postsWithAuthors) {
  console.log(`${post.title} by ${post.author.name}`);
  console.log(`${post.comments.length} recent comments`);
}
Aggregations
// Count posts by status
const postStats = await db
  .select({
    status: posts.status,
    count: count(),
  })
  .from(posts)
  .groupBy(posts.status);
// Average read time for published posts
const [stats] = await db
  .select({
    avgReadTime: avg(sql<number>`(metadata->>'readTime')::int`),
    totalViews: sum(sql<number>`(metadata->>'views')::int`),
  })
  .from(posts)
  .where(eq(posts.status, "published"));
Full-Text Search
// Using Postgres's built-in FTS
const searchResults = await db
  .select()
  .from(posts)
  .where(
    sql`to_tsvector('english', ${posts.title} || ' ' || coalesce(${posts.content}, '')) 
        @@ plainto_tsquery('english', ${searchQuery})`
  )
  .limit(20);
Migrations with Drizzle Kit
// drizzle.config.ts
import type { Config } from "drizzle-kit";
export default {
  schema: "./src/db/schema.ts",
  out: "./drizzle/migrations",
  driver: "pg",
  dbCredentials: {
    connectionString: process.env.DATABASE_URL!,
  },
  verbose: true,
  strict: true,
} satisfies Config;
# Generate migration from schema changes
npx drizzle-kit generate:pg
# View pending migrations (dry run)
npx drizzle-kit push:pg --verbose --dry-run
# Apply migrations
npx drizzle-kit push:pg
# Introspect existing DB (great for migration)
npx drizzle-kit introspect:pg
Generated migration looks like clean SQL:
-- drizzle/migrations/0001_add_posts_table.sql
CREATE TYPE "post_status" AS ENUM('draft', 'published', 'archived');
CREATE TABLE IF NOT EXISTS "posts" (
  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
  "title" text NOT NULL,
  "slug" text NOT NULL,
  "content" text,
  "status" "post_status" DEFAULT 'draft' NOT NULL,
  "metadata" jsonb,
  "author_id" uuid NOT NULL,
  "published_at" timestamp with time zone,
  "created_at" timestamp with time zone DEFAULT now() NOT NULL,
  "updated_at" timestamp with time zone DEFAULT now() NOT NULL
);
CREATE UNIQUE INDEX "posts_slug_idx" ON "posts" ("slug");
CREATE INDEX "posts_author_idx" ON "posts" ("author_id");
CREATE INDEX "posts_status_idx" ON "posts" ("status");
ALTER TABLE "posts" ADD CONSTRAINT "posts_author_id_users_id_fk" 
  FOREIGN KEY ("author_id") REFERENCES "users"("id") ON DELETE cascade;
Neon Branching in CI/CD
This is Neon’s killer feature. Every PR branch gets a database branch:
# .github/workflows/pr.yml
name: PR Preview
on:
  pull_request:
    types: [opened, synchronize]
jobs:
  setup-db:
    runs-on: ubuntu-latest
    outputs:
      db_url: $
    steps:
      - name: Create Neon branch
        id: create-branch
        uses: neondatabase/create-branch-action@v5
        with:
          project_id: $
          branch_name: pr-$
          api_key: $
      
      - name: Run migrations on branch
        run: npx drizzle-kit push:pg
        env:
          DATABASE_URL: $
  
  test:
    needs: setup-db
    runs-on: ubuntu-latest
    env:
      DATABASE_URL: $
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test  # Tests run against isolated DB branch!
  cleanup:
    if: github.event.action == 'closed'
    runs-on: ubuntu-latest
    steps:
      - name: Delete Neon branch
        uses: neondatabase/delete-branch-action@v3
        with:
          project_id: $
          branch_name: pr-$
          api_key: $
Performance Patterns
Connection Pooling (Critical for Serverless)
// For Next.js App Router / Vercel
// src/db/index.ts
import { neon } from "@neondatabase/serverless";
import { drizzle } from "drizzle-orm/neon-http";
// Neon HTTP driver is already connection-pool-friendly
// Each request gets a fresh HTTP connection, pooled by Neon's infrastructure
const sql = neon(process.env.DATABASE_URL!);
export const db = drizzle(sql);
Batch Queries
// Execute multiple queries in one round-trip
const [usersList, postsCount] = await Promise.all([
  db.select().from(users).limit(10),
  db.select({ count: count() }).from(posts),
]);
Prepared Statements
import { placeholder } from "drizzle-orm";
// Prepare once, execute many times
const getUserByEmail = db
  .select()
  .from(users)
  .where(eq(users.email, placeholder("email")))
  .prepare("get_user_by_email");
// Execute with different values (skips query planning)
const user = await getUserByEmail.execute({ email: "alice@example.com" });
Cost Optimization
Neon’s pricing (2026):
Free tier: 0.5 GB storage, 1 compute unit, 190 active hours/month
Launch ($19/mo): 10 GB storage, autoscaling, branching
Scale ($69/mo): 50 GB, read replicas, IP allow-listing
Tips to minimize cost:
Use scale-to-zero (enabled by default) — no idle compute charges
Avoid SELECT * — only select columns you need
Use the connection pooler endpoint for high-concurrency apps
Set reasonable connection pool sizes in your app
Full Example: Next.js 15 + Neon + Drizzle API Route
// app/api/posts/route.ts (Next.js App Router)
import { NextResponse } from "next/server";
import { db } from "@/db";
import { posts, users } from "@/db/schema";
import { eq, desc } from "drizzle-orm";
export const runtime = "edge"; // Edge-compatible!
export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const page = parseInt(searchParams.get("page") ?? "1");
  const limit = 20;
  const offset = (page - 1) * limit;
  const publishedPosts = await db.query.posts.findMany({
    where: eq(posts.status, "published"),
    with: {
      author: {
        columns: { id: true, name: true, avatarUrl: true }
      }
    },
    orderBy: [desc(posts.publishedAt)],
    limit,
    offset,
  });
  return NextResponse.json({
    posts: publishedPosts,
    page,
    hasMore: publishedPosts.length === limit,
  });
}
export async function POST(request: Request) {
  const body = await request.json();
  
  const [newPost] = await db
    .insert(posts)
    .values({
      title: body.title,
      slug: body.title.toLowerCase().replace(/\s+/g, "-"),
      content: body.content,
      authorId: body.authorId,
      status: "draft",
    })
    .returning();
  return NextResponse.json(newPost, { status: 201 });
}
Conclusion
The Neon + Drizzle stack in 2026 represents the best of modern web development:
No ops — Neon handles backups, scaling, HA automatically
Type safety — Drizzle infers types from your schema, no codegen required
Edge-compatible — HTTP driver works everywhere Postgres didn’t before
Git-like branching — true database branches for every PR
Full Postgres — no compromises on features or compatibility
If you’re starting a new project or migrating an existing one, this stack is genuinely worth the learning curve. The type safety alone will save you from countless runtime errors, and Neon’s branching will change how your team thinks about database development workflow.
The future of databases is serverless, branched, and fully typed.
References:
Neon Documentation
Drizzle ORM Documentation
Neon + Drizzle Integration Guide

Neon Serverless Postgres + Drizzle ORM: The Modern Full-Stack Database Stack

댓글