Home / Learn / Databases

🗄️ Databases

Storing, querying and scaling data. 51 topics, from beginner to advanced.

Databases store, organize and retrieve data reliably. This area covers relational models and SQL, indexing and query planning, transactions and consistency, and the trade-offs of NoSQL and distributed storage. Understanding these topics explains why an application is fast, why data stays correct after a crash, and how systems grow beyond one machine.

Who this area is for

Backend developers, data analysts who write SQL, and anyone designing an application that must store data safely.

Real-world use cases

Storing customer orders, accounts and inventory in a relational database.
Speeding up slow reports with the right indexes and query rewrites.
Choosing a document, key-value or wide-column store for high write volume.
Generating a monthly sales report with GROUP BY and aggregate functions.
Keeping an order and its payment consistent when the database server fails during checkout.

Topics in Databases

Beginner (17)

What is a Database — Organized collection of data managed for efficient access.
DBMS — Software that stores, retrieves and manages database content.
Relational Model — Data organized into tables of rows and columns.
Tables, Rows and Columns — The basic building blocks of relational storage.
Primary Keys — Column that uniquely identifies each row.
Foreign Keys — Column referencing another table's key to link records.
SQL Basics — Declarative language for querying relational data.
SELECT Queries — Statements retrieving data from tables.
WHERE and Filtering — Clauses restricting which rows are returned.
ORDER BY and LIMIT — Sorting results and capping their count.
INSERT, UPDATE, DELETE — Statements that modify stored rows.
Aggregate Functions — COUNT, SUM, AVG and similar summarizers.
GROUP BY and HAVING — Grouping rows and filtering the groups.
Joins — Combining rows from tables on related columns.
Inner and Outer Joins — Joins differing in how unmatched rows are handled.
Entity-Relationship Modeling — Diagramming entities and their relationships.
Data Types in SQL — Column types like INT, VARCHAR and DATE.

Intermediate (17)

Subqueries — Queries nested within other queries.
Views — Saved queries presented as virtual tables.
Indexes — Auxiliary structures speeding up lookups.
Normalization — Organizing tables to reduce redundancy.
Normal Forms — Progressive rules 1NF through BCNF for table design.
Denormalization — Deliberately adding redundancy to speed reads.
Transactions — Groups of operations executed as an atomic unit.
ACID Properties — Atomicity, consistency, isolation and durability guarantees.
Isolation Levels — Settings trading concurrency for protection from anomalies.
Concurrency Control — Techniques coordinating simultaneous database access.
Locking and Two-Phase Locking — Using locks to serialize conflicting operations.
MVCC — Keeping multiple versions so readers don't block writers.
Stored Procedures and Triggers — Server-side code run on demand or on events.
Query Optimization — Choosing efficient execution plans for queries.
Query Execution Plans — Operator trees showing how a query will run.
Window Functions — Calculations across related rows without collapsing them.
Common Table Expressions — Named temporary result sets within a query.

Advanced (17)

Recovery and Logging — Write-ahead logs restoring state after failure.
Database Partitioning — Splitting tables into smaller physical pieces.
Replication — Copying data across servers for availability.
Sharding — Distributing data horizontally across nodes.
NoSQL Databases — Non-relational stores built for scale and flexibility.
Document Stores — Databases holding JSON-like documents.
Key-Value Stores — Simple stores mapping keys to opaque values.
Column-Family Stores — Wide-column stores optimized for large writes.
Graph Databases — Stores built around nodes, edges and traversals.
CAP Theorem — Trade-off among consistency, availability and partition tolerance.
Eventual Consistency — Replicas converge to the same state given time.
Data Warehousing — Analytical stores integrating data from many sources.
OLTP vs OLAP — Transaction-heavy versus analysis-heavy workloads.
LSM Trees — Write-optimized structures merging sorted runs.
NewSQL and Distributed SQL — Databases combining SQL semantics with horizontal scale.
Time-Series Databases — Stores specialized for timestamped measurements.
Vector Databases — Stores indexing embeddings for similarity search.

How to study Databases

Design a small schema for a real problem, such as a library or a shop, then write queries against it. Use EXPLAIN on each query to see how the database runs it. Read the transaction topics with a concrete example, such as a bank transfer, in mind.

Frequently asked questions

SQL or NoSQL: which should I use?

Use SQL when data has clear relationships and you need transactions and flexible queries. NoSQL fits known access patterns, very large scale or flexible schemas. Many production systems use both.

Why do database indexes make queries faster?

An index is a sorted structure, usually a B-tree, that lets the database find matching rows without scanning the whole table. The trade-off is extra storage and slower writes.

What does ACID mean?

ACID stands for Atomicity, Consistency, Isolation and Durability. Together they guarantee that transactions either complete fully or not at all and survive crashes.

Should I learn SQL before NoSQL?

Yes. Relational concepts such as keys, joins and transactions appear in most data systems, and they make it easier to understand what NoSQL databases trade away.

Do I need a database administrator skill set to be a backend developer?

Not at first. Knowing how to model data, write efficient queries and read a query plan covers most day-to-day needs. Operations skills such as backups and replication can come later.

Open the interactive Databases area Take the Databases quiz