Where does application data live after a user closes the app?

Think about an e-commerce website.

A customer creates an account, adds products to the cart, places an order, and then closes the browser.

Hours later, they return and everything is still there.

How?

The answer is simple: databases.

Applications come and go. Servers restart. Browsers close. But data must survive. Databases are the systems responsible for storing information permanently and making it available whenever needed.

Before understanding tools like Prisma or Drizzle, we first need to understand why databases exist and how applications communicate with them.

Why Applications Need Databases

Modern applications revolve around data.

Every interaction users perform creates information that needs to be stored.

Examples include:

• User accounts

• Blog posts

• Orders

• Products

• Comments

• Messages

• Payments

• Notifications

Without databases, all this information would disappear when the application stops running.

Structured vs Unstructured Data

Structured Data

Data organized into rows and columns.

Example:

User ID	Name	Email
1	Alice	alice@gmail.com
2	Bob	bob@gmail.com

Common examples:

• Banking systems

• E-commerce platforms

• Inventory systems

Unstructured Data

Data without a fixed format.

Examples:

• Images

• Videos

• Documents

• JSON objects

• Chat messages

Social media platforms often combine structured and unstructured data.

Databases in Modern Applications

Databases act as the memory of applications.

User → Application → Database

Examples:

E-commerce

Stores:

• Users

• Products

• Orders

• Payments

Social Media

Stores:

• Profiles

• Posts

• Followers

• Likes

• Comments

Blogging Platforms

Stores:

• Authors

• Articles

• Categories

• Tags

SQL vs NoSQL Databases

Modern databases generally fall into two categories.

SQL Databases

SQL databases store information in tables with relationships.

Popular examples:

• PostgreSQL

• MySQL

• SQLite

• SQL Server

Example:

Users Table

id	name
1	John

Orders Table

id	user_id
10	1

Order 10 belongs to User 1.

This relationship is what makes SQL databases powerful.

Best For

• Banking systems

• SaaS applications

• E-commerce platforms

• Analytics systems

NoSQL Databases

NoSQL databases are document-oriented or key-value based.

Popular examples:

• MongoDB

• Firebase

• Redis

• Cassandra

Example:

{
  "name": "John",
  "orders": [
    {
      "product": "Laptop",
      "price": 1000
    }
  ]
}

Everything is stored together as a document.

Best For

• Flexible schemas

• Real-time applications

• Large-scale distributed systems

• Event-driven systems

SQL vs NoSQL

Feature	SQL	NoSQL
Structure	Tables	Documents
Schema	Fixed	Flexible
Relationships	Strong	Limited
Transactions	Excellent	Varies
Scaling	Vertical	Horizontal
Examples	PostgreSQL, MySQL	MongoDB, Firebase

Neither is universally better.

The right choice depends on the application's requirements.

The Problem with Raw Database Queries

Applications can communicate directly with databases using SQL.

Example:

SELECT * FROM users WHERE email='alice@gmail.com';

Although powerful, writing raw queries everywhere creates several problems.

Repetitive Code

The same queries appear across multiple files.

Maintainability

Changing table names means updating many queries manually.

Security Concerns

Improper query handling can lead to SQL Injection attacks.

Example:

SELECT * FROM users
WHERE email='user input';

Unsafe queries can expose sensitive data.

Scaling Complexity

As applications grow, managing hundreds of queries becomes difficult.

Developers needed a better abstraction.

This gave rise to ORMs.

What is an ORM?

ORM stands for:

Object Relational Mapper

An ORM translates objects in code into database records.

Instead of writing:

SELECT * FROM users;

You might write:

users.findMany()

The ORM converts that into SQL behind the scenes.

Application → ORM → Database

Frontend
    ↓
Backend
    ↓
ORM
    ↓
Database

Benefits of ORMs

Better Developer Experience

Work with objects instead of SQL strings.

Type Safety

Errors are caught before deployment.

Less Boilerplate

Write less repetitive code.

Easier Refactoring

Changing schemas becomes safer.

Productivity

Developers focus on business logic instead of query syntax.

Tradeoffs

ORMS are not magic.

They introduce:

• Abstraction overhead

• Learning curves

• Sometimes reduced query flexibility

• Performance costs in complex scenarios

They are productivity tools, not replacements for SQL knowledge.

Understanding Prisma

Prisma is one of the most popular modern ORMs.

Its philosophy is:

Schema First Development

Developers define models inside a schema file.

Example:

model User {
  id    Int @id
  email String @unique
}

Prisma generates a type-safe client automatically.

Then queries become:

prisma.user.findMany()

Why Developers Love Prisma

Excellent Developer Experience

Autocompletion and type safety.

Migrations

Schema changes are tracked automatically.

Generated Client

Strong TypeScript support.

Rich Ecosystem

Includes:

• Prisma Client

• Prisma Migrate

• Prisma Studio

• Accelerate

• Optimize

Prisma Architecture

Application
     ↓
Prisma Client
     ↓
Query Engine
     ↓
Database

Prisma prioritizes developer experience.

Understanding Drizzle

Drizzle follows a different philosophy.

Instead of hiding SQL, it embraces it.

Its approach is:

SQL First

Schemas are written directly in TypeScript.

Example:

export const users = pgTable("users", {
    id: serial("id").primaryKey(),
    name: text("name")
});

Queries remain very close to SQL.

db.select().from(users);

Why Developers Like Drizzle

Type Safety

Strong TypeScript support.

Lightweight

Minimal overhead.

SQL-Centric

Feels closer to traditional SQL.

Simplicity

Less magic compared to conventional ORMs.

Drizzle Architecture

Application
      ↓
Drizzle ORM
      ↓
SQL
      ↓
Database

Drizzle focuses on transparency and performance.

Prisma vs Drizzle

Feature	Prisma	Drizzle
Philosophy	Schema First	SQL First
Learning Curve	Easier	Moderate
Type Safety	Excellent	Excellent
Query Style	High-level API	SQL-like
Performance	Good	Very Good
Bundle Size	Larger	Lightweight
Ecosystem	Mature	Growing
Developer Experience	Outstanding	Flexible

Production Use Cases

Prisma

Great for:

• SaaS startups

• Teams prioritizing productivity

• Rapid development

Drizzle

Great for:

• Performance-sensitive systems

• Developers comfortable with SQL

• Serverless applications

There is no winner.

Different philosophies solve different problems.

Database Migrations

Applications evolve.

New features require new columns and tables.

Suppose an e-commerce platform initially has:

Users
Products
Orders

Later, it needs:

Discounts
Coupons
Reviews
Wishlists

Changing production databases manually is risky.

Migrations solve this.

Migration Lifecycle

Schema Change
      ↓
Generate Migration
      ↓
Review
      ↓
Apply Migration
      ↓
Database Updated

Why Migrations Matter

They provide:

• Version control for databases

• Team collaboration

• Reproducibility

• Safer deployments

Common Challenges

• Migration conflicts

• Data loss risks

• Rollback complexity

Database evolution should always be treated carefully.

Designing Data Models

Good applications start with good data models.

Think in terms of entities and relationships.

One-to-One Relationship

Example:

User ↔ Profile

User
 └── Profile

One user owns one profile.

One-to-Many Relationship

Example:

Author → Posts

Author
 ├── Post 1
 ├── Post 2
 └── Post 3

One author can create many posts.

Many-to-Many Relationship

Example:

Students ↔ Courses

Student A ---- Course 1
Student A ---- Course 2

Student B ---- Course 1

Many students can enroll in many courses.

Real-World Example: E-Commerce

User
 ↓
Orders
 ↓
Order Items
 ↓
Products

Understanding relationships is more important than understanding any ORM.

Tools change.

Data modeling principles remain.

Choosing the Right Tool

The best tool depends on context.

Startup Projects

Prisma shines because of developer experience and speed.

Enterprise Applications

Both Prisma and Drizzle are capable.

Team expertise matters more.

Performance-Critical Systems

Drizzle's lightweight architecture can provide advantages.

Long-Term Maintenance

Consistency and team familiarity often matter more than benchmarks.

Final Thoughts

Databases are the foundation of every modern application.

ORMs are not magical layers that replace SQL—they are productivity tools that help developers build software faster and safer.

Prisma emphasizes developer experience through a schema-first approach.

Drizzle emphasizes control through a SQL-first philosophy.

Neither is universally superior.

The real goal isn't choosing the "best ORM."

It's understanding how data flows:

Application
     ↓
ORM
     ↓
Database

Once you understand that architecture, switching between tools becomes easy.

Because frameworks change.

Libraries evolve.

But good data modeling and database fundamentals remain timeless.