Understanding Databases from a Front-End Developer's Perspective: Series Guide

As a front-end developer, you work with databases every day — you just don't see them directly:

• localStorage is only a small "temporary shelter" inside the browser; the data that really matters lives in the server-side database;
• the fallback data in useSWR, the lists you get back from fetch — underneath, they're all the results of SQL queries;
• the Prisma schema you write eventually becomes a set of tables and a bunch of queries.

Yet most front-end developers treat the database as a black box — as long as the data comes out, it's fine; when a query gets slow, wrap it in a cache; when the database breaks, call the DBA.

This series aims to open up that black box.

From a front-end developer's perspective, we'll break the database down layer by layer, from the ground up: why databases exist in the first place, how data is stored, why indexes make queries faster, how concurrent operations stay correct, through the ORMs and connection pools you use every day without digging deeper, and finally what happens as traffic grows.

We won't try to cover everything. Instead, we focus on the key concepts that help you truly understand how data is organized and how it flows.

This series follows "the life of a record" — from birth, to being organized and accessed concurrently, to scaling up. Reading in order is recommended.

You've stored data in JSON files or localStorage before. When the data grows, you need to search by conditions, and you need multiple pieces of data to stay consistent — that's when file-based approaches start to fall apart. Start here to understand the fundamental problem a database solves.

Starting from localStorage and JSON files, we'll rebuild the concept of "tables" step by step — rows, columns, primary keys, data types — and see which pain points of hand-rolled files a database solves.

Know what a table is but not how to query it? This is the missing bridge: the SELECT skeleton, WHERE / GROUP BY / HAVING / JOIN, and the keywords behind 90% of daily queries.

What does your casually-written SELECT actually go through inside the database? Parser, optimizer, executor — and your first look at EXPLAIN, seeing what a query plan looks like.

Slow queries are the most common database problem front-end developers face. This layer answers two questions: where does the data actually live, and why does adding an index make things faster?

A database doesn't just dump data into files. Understand disk, pages, row storage, and WAL, and you'll know why "reading from disk" is the performance bottleneck.

(Coming soon) How Indexes Work: B+ Trees, Hash Indexes, and Composite Indexes

Why do indexes make queries faster? What does a B+ tree look like, and why don't databases use red-black trees? What are composite indexes and the leftmost-prefix rule?

(Coming soon) Table Lookups and Covered Indexes: Clustered vs. Non-Clustered

Why does a query sometimes "find the row, then have to look again"? How do covered indexes let a query skip that extra trip.

Your front end is single-threaded, but a database always serves hundreds of concurrent requests. Staying correct under concurrency is exactly this layer's job.

(Coming soon) Transactions and ACID: Why Multi-Step Operations Can't Be Split

Why must a transfer either fully succeed or fully fail? What are atomicity and isolation, really — and what do redo/undo logs do behind the scenes?

(Coming soon) Isolation Levels and MVCC: Dirty Reads, Non-Repeatable Reads, and Phantom Reads

What exactly do the four isolation levels "isolate"? How does MVCC let reads and writes proceed without blocking each other, using version chains?

(Coming soon) Locks and Deadlocks: The Price of Concurrency Control

Row locks, table locks, gap locks... the more locks you add, the lower the concurrency. How do deadlocks happen, and how does a database rescue itself?

This layer is closest to your daily work: ORMs, connection pools, and slow-query diagnosis. With the storage and index fundamentals from earlier layers, everything here becomes visible — you'll actually see the mechanism behind it.

(Coming soon) How Prisma Generates SQL: ORMs and the N+1 Problem

What SQL does your Prisma query actually become? Why is N+1 the most common ORM performance trap?

(Coming soon) Connection Pools: Why Does the Connection Count Blow Up?

Opening a database connection is far more expensive than you'd think. How do pools reuse connections, and what really happens when you "run out of connections"?

(Coming soon) EXPLAIN in Practice: A Health Check for Slow Queries

Put the earlier layers to work: read query plans with EXPLAIN, and turn a Seq Scan into an Index Scan.

A single-machine database has a ceiling. This layer looks at how a database "grows up" as the data volume climbs.

(Coming soon) Master-Slave Replication and Read/Write Splitting: How Databases Clone Themselves

The master writes, replicas read. How does streaming replication work? What does read/write splitting solve, and what new problems does it introduce?

(Coming soon) Sharding, Partitioning, and the Art of Splitting a Database

What if a single table can't handle tens of millions of rows? Partitioning, vertical splitting, horizontal sharding — and why sharding is the "last resort."

(Coming soon) Cache and Database Consistency: The Love-Hate Story of Redis and the DB

A cache absorbs read amplification, but how do the cache and the database stay consistent? Penetration, breakdown, avalanche — the three mountains.

(Coming soon) NoSQL Selection: Redis, MongoDB, and Vector Databases

Relational databases aren't a silver bullet. When is NoSQL the better choice? Understand the positioning of Redis, MongoDB, and vector databases through their data models.

Front-end developers with some SQL experience (or who write SQL "indirectly" through Prisma or another ORM), but without a systematic grasp of database internals. Curious about "how a database actually works." Who want to understand, not memorize.

People studying for certification — this series won't cover every exam point. People building database internals — we focus on "understanding," not "implementation."

Each article stands on its own, but reading in roadmap order is recommended. Short on time? Prioritize Files to Relational Tables → Writing SQL from Scratch → The Journey of a SQL Statement → Where Data Actually Lives → How Indexes Work → Transactions and ACID → Isolation Levels and MVCC → Prisma and N+1 → Connection Pools → EXPLAIN in Practice — this line forms the core database knowledge chain for everyday front-end development.

The series is updated continuously: as each article is published, the roadmap above will be updated with its link.