CMU 15-445: Database Systems
15-445 is CMU's database systems course — storage, buffer pools, indexes, query execution and optimization, concurrency control, and recovery — built around implementing real components inside the BusTub teaching database in C++. Its public lectures and projects have made it the internet's default database-internals curriculum.
Fennie is independent and not affiliated with Carnegie Mellon University. This is an unofficial study guide.
Build my 15-445 study planWhat makes it hard
The projects are serious C++ systems programming: each builds inside a real codebase where your component must satisfy interfaces you didn't design, and concurrency bugs in the later projects don't reproduce on demand. Self-learners arrive in waves from the famous lectures and discover the projects assume systems maturity the videos don't supply.
What you'll cover
- • Storage and buffer pool management
- • B+Tree indexes
- • Query execution and join algorithms
- • Query optimization
- • Concurrency control and transactions
- • Logging and crash recovery
The 15-445 study guide
How to study for CMU 15-445, step by step.
- 1
Get C++-fluent before the first project, not during
BusTub is modern C++ in a real codebase, and language friction during a project deadline is self-inflicted. If your C++ is approximate, spend the early weeks making it concrete.
- 2
Read the project's surrounding code first
Each project lives inside interfaces and invariants you didn't write. An hour reading the headers and tests before coding beats three hours of misled implementation.
- 3
Trace each mechanism on paper before implementing
B+Tree splits, buffer eviction, two-phase locking — work small examples by hand until the algorithm is yours, then code it. Implementing from a half-understood description is the slowest path through every project.
- 4
Budget double for the concurrency projects
When transactions and latching arrive, bugs stop reproducing reliably and progress turns nonlinear. Start those projects the day they open and test with sanitizers from the first commit.
- 5
Self-learners: pair every lecture with its project work
The lectures are famous for a reason, but database internals compile into understanding only through BusTub. Schedule project milestones with real dates — the abandoned-fork statistics are a warning, not trivia.
- 6
Run the project pipeline with Fennie
Upload the 15-445 schedule — campus or the public course — and Fennie's Daily Plan paces project milestones and exam review across the semester, with quizzes generated from the actual lecture notes. It's free to start.
Start my 15-445 plan free
How Fennie helps with 15-445
Fennie's Daily Plans pace 15-445's project pipeline from each release date — with the concurrency projects given the double runway they genuinely need — for enrolled students and the worldwide self-study crowd alike. Chat through B+Tree mechanics or locking protocols step by step before you implement them, with quizzes built from the actual course notes.
FAQ
Is 15-445 hard?
The projects are the difficulty: real C++ components inside a real codebase, with later projects adding concurrency bugs that resist reproduction. Conceptually it's well-taught and well-paced; students with solid systems footing who start projects early consistently succeed.
Can I take 15-445 online for free?
The lectures, notes, and BusTub projects are public, and the course has become the standard self-study path into database internals worldwide. No credit, full content — and the projects, not the videos, are where the learning actually happens.
What should I know before 15-445?
Real C++ (not just C), data structures fluency, and systems basics at the 15-213 level — the buffer pool and recovery units assume you understand memory and caching natively. SQL familiarity helps but the course is about what's underneath SQL.
Pass 15-445 with a plan, not a cram
Upload your 15-445 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore CMU courses
15-112 — Fundamentals of Programming and Computer Science
15-112 is CMU's famous fast-paced introduction to programming in Python — control flow, functions, data structures, recursion, OOP, and efficiency — ending in an open-ended term project. Its public course website and the related CMU CS Academy platform give it a search footprint far beyond Pittsburgh.
15-110 — Principles of Computing
15-110 is CMU's gentler introduction to computing — Python programming plus computing concepts like data representation, algorithms, and the limits of computation — designed for students who aren't CS majors or who want a runway before 15-112. It's one of the largest courses on campus.
15-122 — Principles of Imperative Computation
15-122 teaches imperative programming with correctness front and center — contracts, loop invariants, and reasoning about code in the C0 teaching language before transitioning to real C — covering data structures from stacks and queues through hash tables, trees, and graphs. It's the second course of the CMU CS core.
15-150 — Principles of Functional Programming
15-150 teaches functional programming in Standard ML — types, recursion and induction, higher-order functions, and reasoning about programs as mathematical objects — alongside 15-122 in the CMU CS core. For most students it's the first time programming and proof become the same activity.