www.ryanyogan.com
I still love Prisma in 2025
Excerpt
## Performance? Please, I'm Building Fun Stuff Here Let me be crystal clear about something: **performance optimization is the last thing I care about** for my personal projects. I'm not Netflix. ... When someone starts going on about "Prisma adds 20ms overhead compared to raw SQL," I want to ask them if they've fixed the 12 N+1 queries in their codebase or if they're still loading 5MB of uncompressed JavaScript on their landing page. A real Twitter rant I saw: "Spent 2 weeks optimizing my ORM queries to save 30ms, then realized my app was downloading a 2MB hero image. Reduced that to 200KB and saved 500ms. I am not a smart man." ... So for my personal and fun projects, the performance argument is moot. And let's be honest, in most real-world apps, the bottle neck is usually `us`, we cause the issues because we favor features over quality it would appear. … **Cons:** **New Kid Problems:**As one memorable tweet put it: *"Drizzle looks amazing until you need that ONE feature Prisma has had for years. Then you're writing a plugin at 2am on a Tuesday while questioning your life choices."* **Documentation That Assumes You're Already Friends:**Half the time I'm looking for basic examples, not philosophical treatises on database abstraction. The docs often feel like walking into a conversation that's already halfway finished. … **Framework Agnostic:**Works with any TypeScript project, which is nice when you're hopping between frameworks faster than a caffeinated rabbit. **Cons:** **Documentation From The Twilight Zone:**Finding the right way to do anything is like solving a puzzle where half the pieces are in a different box. A GitHub issue literally titled *"Documentation is like trying to learn Spanish by reading French"*has 200+ upvotes. **Migration System That Makes Me Question Reality:**I've had more predictable experiences with the weather than running TypeORM migrations. One memorable Reddit thread: *"My TypeORM migration dropped a production table and now I'm updating my resume."* **Active Record AND Data Mapper Patterns:**Can't decide which pattern to use? TypeORM said "why not both?" and created twice the confusion. It's like a restaurant serving both Italian and Chinese food—suspicious from the start. … **API Inconsistencies:**Methods like `findOne`, `findAll`, `findAndCountAll`take slightly different parameters in ways that will drive you to drink. Why is it `include`in some places and `includes`in others? Nobody knows! … **Lightweight:**It won't add 50MB to your Lambda function, which is nice. **Cons:** **No Schema Management:**Hope you like defining your schema in both your database and your code! Double the maintenance, double the fun! **No Relations Handling:**Want to fetch a user with their posts and comments? That's several manual queries or some custom code, pal. A Twitter rant I saved: *"Knex is great until you need to fetch related records, then it's DIY hour at the database factory."* … **The Query API Is... Something:**It's powerful, but the syntax is its own special language. `{ $in: [...] }`anyone? It's SQL, Jim, but not as we know it. **Performance Cliffs:**Things work great until they don't. That collection with 10,000 documents performs fine until it hits 100,000 and then your server catches fire. Real tweet: *"Our MongoDB queries went from 5ms to 5s overnight. Turns out we crossed some invisible performance threshold."* … **Cons:** **Manual Everything:**Hope you like writing `JOIN`statements by hand and updating them every time your schema changes. A Reddit comment that hit home: *"I switched to raw SQL for 'performance reasons' and spent the next 6 months fixing broken queries every time we changed the schema."* **Type Safety? LOL:**Enjoy casting your result sets manually and hoping you remembered the column types correctly. Was that an INTEGER or a BIGINT? Surprise! **Migration Management:**Roll your own or use a separate tool. Either way, it's more work than using an integrated solution.
Related Pain Points
Severe performance degradation under high transaction volumes
9MongoDB exhibits non-linear performance degradation as data volume increases. Real-world cases show response times deteriorating from 5ms to over 1 second under load, and sharding provides only temporary relief while adding operational complexity. Query performance becomes unacceptable for high-throughput transactional applications.
TypeORM migration system unreliability and data loss risk
8TypeORM's migration system produces unpredictable results with documented cases of migrations dropping production tables. The system's inconsistency makes it risky for production use.
Raw SQL requires manual JOIN maintenance across schema changes
6Using raw SQL for performance avoids ORM overhead but requires manually writing and maintaining JOIN statements. Every schema change necessitates updating all related queries, making maintenance burden significant.
Knex lack of relationship handling requires manual queries
5Knex is a query builder without built-in relationship handling. Fetching related records requires multiple manual queries or custom code, creating friction compared to ORMs with built-in relationship support.
Raw SQL lacks type safety for result sets
5Raw SQL queries require manual casting of result sets and hoping developers remember correct column types. Type information is lost, increasing risk of runtime errors.
Drizzle documentation assumes prior knowledge and lacks basic examples
4Drizzle's documentation feels incomplete and assumes the reader already understands concepts, making it difficult to find straightforward examples for common tasks. Documentation reads like joining a conversation halfway through rather than introducing concepts from scratch.
TypeORM pattern confusion from supporting both Active Record and Data Mapper
4TypeORM supports both Active Record and Data Mapper patterns simultaneously, creating confusion about which pattern to use and doubling the complexity of the API surface.
Knex query API uses custom syntax unfamiliar to SQL developers
3Knex's query API uses MongoDB-like syntax (e.g., `{ $in: [...] }`) that is neither standard SQL nor intuitive for developers familiar with SQL, creating a learning curve.