--- date: 2026-08-25 title: "Sutando vs Drizzle: Active Record vs SQL-First in Node.js" type: blog description: "Drizzle ORM has become the go-to choice for developers who want SQL-level control with TypeScript type safety. Sutando takes the opposite approach —…" authors: ["Dylan Yu"] mode: center --- --- Drizzle ORM has become the go-to choice for developers who want SQL-level control with TypeScript type safety. Sutando takes the opposite approach — bringing Active Record elegance to Node.js. Let's compare them head-to-head. ## The Core Difference - **Drizzle** is SQL-first: its query builder mirrors SQL syntax, and schemas are defined in TypeScript that looks like `CREATE TABLE` statements - **Sutando** is Active Record-first: models are classes with methods like `save()`, `delete()`, and relationship methods like `hasMany()` Drizzle says: "If you know SQL, you know Drizzle." Sutando says: "If you know Laravel Eloquent, you know Sutando." ## Schema Definition **Drizzle:** ```ts import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core'; export const users = pgTable('users', { id: serial('id').primaryKey(), name: text('name').notNull(), email: text('email').notNull().unique(), createdAt: timestamp('created_at').defaultNow(), }); export const posts = pgTable('posts', { id: serial('id').primaryKey(), title: text('title').notNull(), userId: integer('user_id').references(() => users.id), createdAt: timestamp('created_at').defaultNow(), }); ``` **Sutando:** ```ts import { Model } from 'sutando'; class User extends Model { table = 'users'; relationPosts() { return this.hasMany(Post, 'user_id'); } } class Post extends Model { table = 'posts'; relationUser() { return this.belongsTo(User, 'user_id'); } } ``` Drizzle's schema is closer to SQL. Sutando's models are closer to your business domain. ## Query Comparison ### Simple Query **Drizzle:** ```ts const users = await db.select().from(users) .where(eq(users.name, 'Alice')) .limit(10); ``` **Sutando:** ```ts const users = await User.query() .where('name', 'Alice') .limit(10) .get(); ``` ### Join / Relationship Query **Drizzle:** ```ts const result = await db.select({ id: users.id, name: users.name, postTitle: posts.title, }) .from(users) .leftJoin(posts, eq(users.id, posts.userId)) .where(eq(users.id, 1)); ``` **Sutando:** ```ts const user = await User.query().with('posts').find(1); // user.posts is an array of Post models ``` This is the key difference: Drizzle makes you write explicit joins, while Sutando handles relationship loading automatically through eager loading. ### Insert **Drizzle:** ```ts const [user] = await db.insert(users).values({ name: 'Alice', email: 'alice@example.com', }).returning(); ``` **Sutando:** ```ts const user = new User(); user.name = 'Alice'; user.email = 'alice@example.com'; await user.save(); ``` ### Update **Drizzle:** ```ts await db.update(users) .set({ name: 'Bob' }) .where(eq(users.id, 1)); ``` **Sutando:** ```ts const user = await User.query().find(1); user.name = 'Bob'; await user.save(); ``` ## Feature Comparison | Feature | Sutando | Drizzle | |---------|---------|---------| | Pattern | Active Record | SQL query builder | | Schema | Model classes | TypeScript schema builders | | Relationships | `hasMany`, `belongsTo`, etc. | Manual joins | | Eager loading | `with('posts.comments')` | Manual join configuration | | Migrations | Schema builder + migration files | Drizzle Kit (`generate` / `push`) | | Bundle size | Small | Very small (~7.4kb min+gzip) | | Edge runtime | Yes | Yes | | Raw SQL | Via query builder | First-class `sql` template tag | | Model events | Built-in | No | | Soft deletes | Built-in | No | | Type safety | Class-based | TypeScript inference from schema | | Database support | MySQL, PostgreSQL, SQLite | PostgreSQL, MySQL, SQLite, Turso, Neon | ## Where Sutando Wins ### 1. Relationship Management This is Sutando's biggest advantage. Managing relationships in Drizzle requires explicit joins for every query. Sutando handles this with declarative relationship methods: ```ts // Sutando: one line for nested relationships const users = await User.query() .with('posts.comments.author') .get(); // Drizzle: requires multiple joins const result = await db.select() .from(users) .leftJoin(posts, eq(users.id, posts.userId)) .leftJoin(comments, eq(posts.id, comments.postId)) .leftJoin(authors, eq(comments.authorId, authors.id)); ``` ### 2. Model Lifecycle Sutando's model events let you hook into create/update/delete operations: ```ts User.creating(async (user) => { user.password = await bcrypt.hash(user.password, 10); }); User.deleting(async (user) => { await user.related('posts').delete(); }); ``` Drizzle has no equivalent — you'd need to wrap every query in custom logic. ### 3. Rapid Development For CRUD applications, Sutando requires significantly less code. You don't need to write joins, manage schema files separately, or configure Drizzle Kit. ### 4. Built-in Soft Deletes ```ts // Sutando: just add deleted_at column and use SoftDeletes const posts = await Post.query().onlyTrashed().get(); await post.delete(); // soft delete await post.forceDelete(); // hard delete ``` Drizzle requires manual filtering on every query. ## Where Drizzle Wins ### 1. SQL Control If you need precise control over generated SQL, Drizzle is unmatched. You see exactly what SQL will be executed: ```ts const result = await db.select() .from(users) .where(sql`${users.age} > ${18}`) .orderBy(sql`RANDOM()`) .limit(1); ``` ### 2. Bundle Size Drizzle is extremely lightweight (~7.4kb min+gzip). For Cloudflare Workers with strict size limits, this matters. ### 3. Performance Drizzle generates SQL directly with minimal overhead. In benchmarks, it consistently outperforms other ORMs. For high-throughput applications, this edge is real. ### 4. Raw SQL with Type Safety Drizzle's `sql` template tag lets you write raw SQL while maintaining type safety on column references — something Sutando doesn't offer. ### 5. Serverless-First Design Drizzle was built for the serverless era. It works seamlessly with Turso, Neon, Supabase, and other modern serverless database providers. ## When to Choose Sutando - Your app has complex relationships - You want Active Record productivity - You need model events, soft deletes, or scopes - You're coming from Laravel or Rails - You prioritize developer speed over SQL control ## When to Choose Drizzle - You want full SQL control - You're building for Cloudflare Workers or edge runtimes - Bundle size is critical - You're comfortable writing joins - You want maximum query performance ## Conclusion Drizzle and Sutando serve different needs. Drizzle is for developers who love SQL and want minimal abstraction. Sutando is for developers who want Active Record elegance and automatic relationship management. If your app is relationship-heavy and you value rapid development, Sutando is the better choice. If you need SQL-level control and minimal overhead, go with Drizzle. Try Sutando: `npm install sutando` — or read the [documentation](https://sutando.org/guide/getting-started).