Node.js ORMs in 2026: revisit Prisma, Drizzle and TypeORM before you write another data layer

A new service usually starts the same way. Someone installs the ORM the team used last time, copies the folder structure from an older repository, and writes a UserRepository before the first table exists. Six months later the team is debugging a page that fires two hundred queries, a migration that worked on a laptop but not in staging, and a serverless function that runs out of database connections. None of this came from the database. It came from a data layer that was copied, not chosen.

In 2026 that copy step is riskier than usual, because all three big TypeScript ORMs changed. Prisma dropped its Rust query engine, moved the generated client into your source tree and is now shipping Prisma 8 as a release candidate. Drizzle is on its way to 1.0 with a new relational query API, and its core team joined PlanetScale. TypeORM, which many people had written off as unmaintained, got new maintainers and finally released 1.0 in May 2026.

This post revisits Prisma, Drizzle ORM and TypeORM, with a short look at Kysely and MikroORM. Versions and dates come from npm, GitHub releases and official documentation, checked on 9 November 2026, and are listed at the end.

The short version

• Prisma: a schema-first ORM with a generated, fully typed client. Prisma 7 (7.10.1 is current) runs without the Rust engine and needs a driver adapter such as @prisma/adapter-pg. Prisma 8, a TypeScript rewrite, is a release candidate, and a bare npm install prisma now gives you its CLI. Best fit when you want an opinionated model layer and built-in migrations.
• Drizzle ORM: a TypeScript-first ORM close to SQL. Tables are defined in TypeScript and queries read like SQL. Stable is 0.45.x; 1.0 has been a release candidate since April 2026 (1.0.0-rc.5 on 21 October). Best fit for teams comfortable with SQL.
• TypeORM: a decorator-based, class-centric ORM in the Hibernate style, with Active Record and Data Mapper patterns. It reached 1.0 on 19 May 2026 under new maintainers; 1.1.2 is current. Best fit for existing TypeORM and NestJS codebases.
• Kysely: a type-safe SQL query builder, not an ORM. Best fit when you want typed SQL and nothing more.
• MikroORM: a Data Mapper ORM with unit of work and identity map. Version 7 (March 2026) replaced Knex with Kysely underneath. Best fit for domain-heavy backends.

What job is the ORM actually doing

Each tool does a different mix of these jobs.

• Mapping. Turning rows into objects and back again.
• Type safety. Letting the compiler catch a misspelt column or a wrong type. The types may come from a generator, from a schema written in TypeScript, or from decorators on classes.
• Query building. Writing queries without string concatenation, through an object API, SQL-shaped method chains, or both.
• Relations. Loading a user with their orders without writing joins by hand. This is where N+1 problems are born.
• Migrations. Keeping the schema in step with the code across laptops, CI, staging and production.
• Connections and transactions. Pools, timeouts and transactions, usually invisible until they fail.

Kysely does only type safety and query building. TypeORM and MikroORM try to do all six. Prisma and Drizzle sit in between.

A short history of the tools

Prisma

Prisma grew out of Graphcool, a GraphQL backend service. Prisma 2, the version most people now call Prisma ORM, was announced as production ready on 9 June 2020, built around the Prisma schema language, a generated and precisely typed client, and Prisma Migrate. For most of its life the client talked to the database through a query engine written in Rust, shipped as a native binary.

Prisma 6.0 arrived in November 2024. In 6.16.0 (September 2025), Prisma announced that the Rust-free ORM and driver adapters were generally available, after describing the move from Rust to TypeScript in its ORM manifesto. Prisma 7.0, released on 19 November 2025, made the Rust-free, ESM client the default. In March 2026 Prisma published its plans for Prisma 8, developed under the working name Prisma Next, as a full rewrite in TypeScript. The Prisma 8 release candidate line started in August 2026. Prisma is developed by Prisma Data, Inc., and the ORM is licensed under Apache 2.0.

Drizzle ORM

Drizzle started in 2021. Its co-creators, Andrii Sherman and Oleksandr Blokh, had first built a similar idea in Java and then moved it to TypeScript. The project grew without venture funding, through sponsors, and the team is based in Ukraine. On 3 March 2026, PlanetScale announced that the Drizzle core team was joining the company. Both PlanetScale and the Drizzle team say Drizzle stays an independent open source project with its own roadmap. The drizzle-orm package is licensed under Apache 2.0; npm lists drizzle-kit, the migrations CLI, under MIT.

Drizzle has never released a 1.0 until now. The 0.x line moved quickly, with frequent minor versions. The 1.0 betas started in 2025, and the first 1.0 release candidate came out on 30 April 2026.

TypeORM

TypeORM was started in 2016 by Umed Khudoiberdiev and became one of the most used Node.js ORMs, helped by NestJS. Version 0.3.0 came out in March 2022, and then maintenance slowed sharply. By 2024 there were thousands of open issues, and the Vendure project, which depends on TypeORM, was discussing a fork.

In October 2024, Michael Bromley and David Hoeck, through their company Elevantiq (the team behind Vendure), announced that they would take over maintenance with the agreement of the original maintainers, with a plan for a non-profit foundation. The TypeORM blog says that through 2025 the new team released 8 patch versions, merged 575 pull requests and closed over 2,300 issues. TypeORM 1.0 was released on 19 May 2026, followed by 1.1.0 in July and 1.1.2 in October 2026. TypeORM is licensed under MIT.

Kysely and MikroORM

Kysely was created by Sami Koskimäki, who also wrote Objection.js and contributed to Knex for years. It started in 2021 as a type-safe query builder inspired by Knex, and is now led by Sami Koskimäki and Igal Klebanov. It is still on 0.x: 0.29.0 came out in May 2026, 0.29.8 is current, and 0.30 is in beta. It is MIT licensed.

MikroORM is led by Martin Adámek and follows the Data Mapper, Unit of Work and Identity Map patterns. Version 7.0 came out on 11 March 2026; 7.2.8 is current. It is MIT licensed.

What changed by 2026

Four changes make an old ORM decision worth checking again.

Prisma dropped the Rust engine and changed its setup. In Prisma 7 you must pass a driver adapter, such as PrismaPg, or an Accelerate URL to PrismaClient. The generated client needs an output path, and Prisma recommends generating it inside src instead of node_modules. The datasource URL moved to prisma.config.ts, environment variables are no longer loaded automatically, and prisma migrate no longer runs generate and seed for you. MongoDB users were told to stay on Prisma 6, which gets security patches only until 19 November 2026.

Prisma 8 is a different product, and already the default install. It replaces schema.prisma with a “contract”, written in the Prisma schema language or TypeScript, adds a typed SQL query builder, and supports PostgreSQL, SQLite and MongoDB. Its release status page said general availability was expected in October 2026; on 9 November it was still a release candidate, with $extends, atomic increment, most nested writes and transaction isolation levels not yet available. Prisma 7 gets fixes for 18 months after Prisma 8 reaches general availability. The practical point: npm’s latest tag for prisma now gives you the Prisma 8 CLI, which does not read schema.prisma and has no migrate dev, so an unpinned CI install can break a Prisma 7 project.

Drizzle is close to 1.0, with breaking changes. The 1.0 line brings Relational Queries v2: one defineRelations definition for all tables, object-style where filters, filtering by relations, and through for many-to-many. RQB v1 is removed from the drivers in the release candidates, the casing API changed, and an explicit undefined in a relational filter now throws instead of silently skipping the condition, which used to return every row.

TypeORM 1.0 is a clean-up release. It needs Node.js 20 or newer, replaces Connection with DataSource, removes globals like getRepository, and moves to mysql2 and better-sqlite3. Two behaviour changes matter: null or undefined in a where condition now throws by default, and non-nullable many-to-one relations use INNER JOIN, which can hide rows with orphaned foreign keys. It also closed several SQL injection paths, and @typeorm/codemod handles most mechanical changes.

Side by side

Type safety

• Prisma generates types from the schema. The result types follow your select and include exactly, which is its biggest strength. The cost is a generate step: if someone forgets to run prisma generate after a schema change, the types lie. In Prisma 7 this step is explicit, so put it in your build and CI scripts.
• Drizzle infers types from table definitions written in TypeScript, so there is no generator. Change the schema file and the types change immediately. The query builder results are typed from the selected columns.
• TypeORM takes types from your entity classes and decorators. Simple find calls are typed reasonably well, but the QueryBuilder often returns entity types that do not match what you actually selected, and raw results are untyped. The compiler will trust the class even when the query loaded only half its fields.
• Kysely is very strict about query types, but you supply the database interface yourself, usually generated from the live schema by a separate tool.

Query model and SQL control

• Prisma gives an object API (findMany, create, nested include) that hides SQL. When you need SQL, Prisma 7 has $queryRaw as a tagged template, so values are sent as parameters, and TypedSQL, which turns .sql files into typed functions. Prisma 8 adds a typed SQL query builder and db.raw.sql.
• Drizzle has two layers. The SQL-like builder (db.select().from(users).where(...)) maps almost one to one to SQL. The relational query API (db.query.users.findMany({ with: { posts: true } })) handles nested loading. The sql template tag lets you drop raw fragments into either, with parameters.
• TypeORM offers repository find options, a QueryBuilder that covers most SQL, and query() for raw SQL. TypeORM 1.0 added INSERT INTO ... SELECT and a returning option for update and upsert.
• Transactions exist everywhere but look different: Prisma has $transaction with an array or an interactive callback, Drizzle has db.transaction() with nested transactions as savepoints, and TypeORM has dataSource.transaction() or a manual QueryRunner, with a DataSource-level default isolation level since 1.0.

Migrations

• Prisma Migrate uses a shadow database to generate SQL migration files that you commit and review: migrate dev for development, migrate deploy for production. Since 7.10.1 it refuses to run if the shadow database URL points at the main database, after a bug where that setup could drop the real schema. Prisma 8 changes the commands completely.
• drizzle-kit offers generate (SQL files from schema changes), migrate (apply them), push (apply changes directly, no files), pull (introspect a database into TypeScript) and export (print SQL for an external tool).
• TypeORM generates migrations from entity changes or runs hand-written ones. Its synchronize option alters the schema on boot: handy locally, dangerous in production.
• Kysely has a small migrator for hand-written migrations, and MikroORM has its own migrations package.

The reviewed SQL file is what matters. If you already run a dedicated migration tool, Drizzle’s export and Prisma’s generated SQL can feed it; we covered those tools in https://revisit.tech/blog/schema-migrations-in-2026-revisit-atlas-flyway-and-liquibase-before-you-ship-another-alter/

Performance and runtime footprint

Treat every ORM benchmark as the vendor’s own run, on the vendor’s chosen queries.

• Prisma says the Rust-free client gives about 90% smaller bundles and up to 3x faster queries. These are Prisma’s own figures. The bigger practical change is that there is no native binary to match to your platform, so Docker images and serverless bundles are simpler.
• Drizzle is a thin layer over the driver. In 1.0.0-rc.1 it added opt-in JIT row mappers and reported a 25 to 30% reduction in latency in its own benchmarks.
• TypeORM makes no headline speed claim in its 1.0 notes. Measure your own heaviest queries.
• MikroORM 7 has zero runtime dependencies in core, and Kysely adds very little on top of the driver.

In practice, one badly loaded relation costs more than any mapper overhead.

Serverless and edge

• Prisma 7 works through driver adapters, including serverless adapters for Neon, PlanetScale, Cloudflare D1 and Prisma Postgres. Pool settings now come from the driver. For the pg adapter, Prisma’s docs list a default pool size of 10 and a default connection timeout of 0, meaning no timeout, where Prisma 6 used 5 seconds. That change alone can turn a pool shortage into requests that hang instead of failing.
• Drizzle supports many drivers directly, including HTTP and WebSocket drivers for serverless databases, and runs on Node.js, Bun, Deno and Cloudflare Workers.
• TypeORM is built around long-running Node.js processes. It fits containers and virtual machines well, not edge functions.
• Kysely runs in any JavaScript runtime with a suitable dialect. MikroORM 7 removed hard Node.js dependencies from core and added a compile command that pre-generates its hydration functions, because runtimes like Cloudflare Workers do not allow new Function.

Licence and governance

• Prisma: Apache 2.0, developed by a company that also sells Prisma Postgres and Accelerate. The company sets the roadmap, as the Prisma 8 rewrite shows.
• Drizzle: Apache 2.0 for the ORM, MIT for drizzle-kit per npm. The core team is employed by PlanetScale, which says Drizzle stays independent.
• TypeORM: MIT, maintained by a team led from Elevantiq with community contributors. Its recent record is strong; long-term health depends on sponsorship.
• Kysely and MikroORM: MIT, each led by a small core team.

How to choose

• Choose Prisma 7 if you want a clear schema file, generated types, built-in migrations and an API junior developers can use safely. Pin version 7 and plan the Prisma 8 move separately, after general availability.
• Choose Drizzle if your team thinks in SQL, deploys to serverless or edge runtimes, and wants the schema in TypeScript with no generate step. For a new project today, decide whether to start on 0.45 and migrate, or start on the 1.0 release candidate and accept small breaking changes before final.
• Stay on TypeORM if you already run it, especially with NestJS, and plan the 1.x upgrade. It is maintained again, so a rewrite just to escape it is harder to justify than in 2024.
• Choose Kysely if you want typed SQL and you are happy to own relations and migrations yourself.
• Choose MikroORM if your domain is rich, you want a unit of work and identity map, and you prefer explicit flushes to scattered saves.

Do not choose on stars or benchmark charts. Write your three or four hardest queries in each candidate and read the SQL each one produces.

Common mistakes

• The N+1 query. A list page loads fifty orders, then loads each order’s customer inside a loop. Every tool allows this. Use Prisma include, Drizzle with, TypeORM relations or a join, and check query counts in logs, not just response time.
• Hidden lazy loading. TypeORM lazy relations (declared as Promise types) and eager relations load data you did not ask for, or one row at a time. Make loading explicit at the call site.
• Undefined filters. A where: { tenantId: undefined } that is silently skipped turns a tenant query into a query over every tenant. TypeORM 1.0 and the Drizzle 1.0 release candidates now throw. Do not switch this off to make an upgrade pass.
• Migration drift. prisma db push, drizzle-kit push or TypeORM synchronize against a shared database leaves no real schema history. Use them on laptops only.
• Pool exhaustion in serverless. Each function instance has its own pool. Fifty instances with a pool of 10 each is 500 connections, more than many managed PostgreSQL plans allow. Keep pools small, create the client outside the handler, set an acquire timeout, and put a pooler in front.
• Unpinned versions. With Prisma’s latest tag on Prisma 8 and Drizzle and Kysely on 0.x, unpinned installs bring breaking changes. Commit lockfiles and pin CI commands, for example npx prisma@7.

A step-by-step plan

1. List your data access. Note the ORM version of each service and whether CI installs are pinned. Fix pinning first.
2. Log queries in a test environment. Count queries per request on your ten busiest endpoints. A count that grows with page size is an N+1 problem.
3. Check migrations. Every production schema change should come from a reviewed migration file, with no push or synchronize against shared databases.
4. Check pools. Multiply pool size by instance count for each service and compare with the database connection limit.
5. Plan version moves. Prisma 6 to 7, TypeORM 0.3 to 1.x with the codemod, Drizzle 0.x to 1.0 with the RQB v2 guide once 1.0 is final. Start with one service.
6. Prototype only for a reason. If a service has real pain, write its hardest queries in one alternative and compare SQL, query counts and code size.
7. Write the decision down. Which tool, which version, why, and what would make you revisit it.

A scenario from an Indian team

This is an invented but realistic example. A 15-person team in Nagpur runs a school fee collection platform for a few hundred schools: a NestJS monolith on TypeORM 0.3, plus newer serverless functions that send fee reminders, written with Prisma 6.

In the first week of the new term, the parent dashboard becomes slow and the reminder functions fail with connection errors. Query logs show the dashboard loading each child’s fee records inside a loop, about 120 queries for a family with three children. The reminder functions scale to 40 instances in the morning batch, each with its own pool, against a managed PostgreSQL plan with a low connection limit.

The team rewrites nothing. They replace the loop with relations and one QueryBuilder join, bringing the dashboard to four queries. They put a pooler in front of PostgreSQL, set small pools and an acquire timeout, and cap function concurrency. Then they plan two upgrades: the monolith to TypeORM 1.x with the codemod, and the functions to Prisma 7 with the pg adapter and prisma@7 pinned in CI.

Closing thoughts

In 2026 the better ORMs offer typed access to SQL you can still see. That is the lesson to learn. Unlearn the habit of picking the ORM you used last time and the idea that the types tell you everything about the database. Re-learn what each tool changed recently: Prisma’s driver adapters and its Prisma 8 rewrite, Drizzle’s relational queries v2, TypeORM’s 1.0 clean-up. Practise by turning on query logging and reading the SQL of your busiest endpoints, and by writing your hardest query in a second tool. Then apply it in small steps: pin versions, fix the N+1 queries, make migrations reviewable and size your pools. A data layer chosen this way will outlast the next round of release candidates.

Sources

• Prisma ORM release status (Prisma 8 RC, Prisma 7 and 6 support): https://www.prisma.io/docs/orm/release-status
• Prisma 7.0.0 release notes: https://github.com/prisma/prisma/releases/tag/7.0.0
• Prisma 6.16.0 release notes (Rust-free ORM generally available): https://github.com/prisma/prisma/releases/tag/6.16.0
• Prisma 7.10.0 and 7.10.1 release notes: https://github.com/prisma/prisma/releases/tag/7.10.1
• Prisma 8 release candidate notes (rc.1): https://github.com/prisma/prisma/releases/tag/v8.0.0-rc.1
• The Next Evolution of Prisma ORM (Prisma blog): https://www.prisma.io/blog/the-next-evolution-of-prisma-orm
• Announcing Prisma 2 (Prisma blog): https://www.prisma.io/blog/announcing-prisma-2-n0v98rzc8br1
• Prisma ORM v7 connection pool: https://www.prisma.io/docs/orm/v7/prisma-client/setup-and-configuration/databases-connections/connection-pool
• Prisma ORM v7 database connections and serverless: https://www.prisma.io/docs/orm/v7/prisma-client/setup-and-configuration/databases-connections
• Prisma ORM v7 database drivers: https://www.prisma.io/docs/orm/v7/core-concepts/supported-databases/database-drivers
• Prisma 8 advanced queries and SQL builder: https://www.prisma.io/docs/orm/fundamentals/advanced-queries
• prisma on npm: https://www.npmjs.com/package/prisma
• Drizzle ORM releases: https://github.com/drizzle-team/drizzle-orm/releases
• Drizzle 1.0.0-rc.1 release notes: https://github.com/drizzle-team/drizzle-orm/releases/tag/v1.0.0-rc.1
• Drizzle 1.0.0-rc.5 release notes: https://github.com/drizzle-team/drizzle-orm/releases/tag/v1.0.0-rc.5
• Drizzle Relational Queries v1 to v2 guide: https://orm.drizzle.team/docs/relations-v1-v2
• Drizzle migrations fundamentals: https://orm.drizzle.team/docs/migrations
• Drizzle sustainability page: https://orm.drizzle.team/docs/sustainability
• Drizzle joins PlanetScale (PlanetScale blog): https://planetscale.com/blog/drizzle-joins-planetscale
• drizzle-orm on npm: https://www.npmjs.com/package/drizzle-orm
• TypeORM 1.0 release notes: https://typeorm.io/docs/releases/1.0/release-notes
• TypeORM blog (TypeORM 1.0 is here): https://typeorm.io/blog
• TypeORM releases: https://github.com/typeorm/typeorm/releases
• Vendure RFC on forking TypeORM (2024 maintenance context): https://github.com/vendurehq/vendure/issues/3102
• typeorm on npm: https://www.npmjs.com/package/typeorm
• Kysely repository: https://github.com/kysely-org/kysely
• Kysely vs Knex (Kysely docs): https://kysely.dev/docs/comparisons/kysely-vs-knex
• MikroORM 7 release post: https://mikro-orm.io/blog/mikro-orm-7-released
• MikroORM releases: https://github.com/mikro-orm/mikro-orm/releases