9 chapters · 41 lessons
First lesson: Why NoSQL if you have PostgreSQL
A hands-on NoSQL course from scratch · Redis, MongoDB, Cassandra
Not everything should be a table.
Redis, MongoDB and Cassandra from zero.
A course for complete beginners: what a database is, why a cache, documents and a ring of servers live next to it, how to pick a store for the job and not bring the system down. All hands-on: the course Redis and MongoDB, along with a Cassandra model, run right in the browser.
The first chapter is free · the other 8 chapters are part of Pro · What Pro includes
- Stores are chosen by the questions, not the hype
- Exercises are checked automatically
- Live cells for Redis, MongoDB and a Cassandra model
- Zero installation: all in the browser
redis> SET session:42 "Пазл 1000 деталей" EX 1800OKredis> TTL session:42(integer) 1800… half an hour and one second later …redis> GET session:42(nil)
What hurts
A task from work — and the technique that closes it
A cache, documents, a ring of servers and search — next to the main database. Under each task, the technique from the program and what the chapter covers.
The price was updated, but the site shows the old one
cache invalidationThe main database already knows the new price, the cache does not. The caching chapter covers when to delete a key and when to update it, and why a stale value sometimes finds its way back into the cache.
One key expired and the main database went down
cache stampedeHundreds of requests missed the cache at once and went to the database. The course shows it as a number — how many times the database was hit — and teaches you to spread expiry times and shield the database.
A cart query in MongoDB found the wrong order
$elemMatchThe product and quantity conditions were met by different array elements. The document-query chapter takes this trap apart on data and shows how to ask about one and the same element.
A customer document keeps growing forever
embed or referenceAn order history inside the customer document is handy while there are ten orders. The course teaches what to embed and what to reference, and how to live with several document versions at once.
Cassandra refuses a simple query
a table per query“All parcels to Kazan” is not a partition-key query, and the ring of servers says no. The Cassandra chapter teaches you to design the table from the question rather than from the entities.
A deleted record came back
tombstones and repairA replica was down for a while, the delete never reached it, and then it came back. The replicas chapter makes you watch it happen: which copy is right, what QUORUM means and why a delete is a write too.
Written to the database, but not to the cache
outboxTwo writes into two stores are not one transaction. The final chapter teaches you to survive an unknown write outcome and deliver changes from the main database with a transactional outbox.
This course is for you if
- Anyone starting from zero who wants to understand what databases are and why there are so many
- Backend developers who plug in Redis and MongoDB “like in the tutorial” and want to know where the rakes are
- Analysts and QA engineers who meet NoSQL in a project and want to understand what is going on
- Anyone preparing for an interview and the question “why this database?”
And NOT for you if
- Anyone who needs to administer clusters: installation, sharding setup and backups are not covered
- Anyone preparing for a single-vendor certification: the course is about choice and models, not every command of one system
- Anyone after vector databases for AI: the course doesn’t cover them
How it works
Command — failure — explanation
Lessons have live cells, quizzes and auto-checked exercises. First you see a store give a strange answer, then you learn why.
Live stores, nothing to install
The course Redis and MongoDB, along with a Cassandra model, run right in the browser. You can move time in the course environment with one line, so you see at once what happens to the cache half an hour later.
Breaking the system on purpose
A cache stampede, a hot partition, a lagging replica, a resurrected delete — every failure shows up as a number: how many database hits, how many replicas answered.
Honest about the model
Where a course store is simpler than the real one, the lesson says so directly in an “it works differently in a real system” note. That makes it clear where the course model ends.
The tenth shift of one story
The Dark Gallery
Kotomarket’s main database survived in full: customers, products, orders. But the shop did not live in one database. Next to it ran a fast memory for carts, a store of product cards, a ring of delivery servers, a shop-window search. All of them went dark on the shop’s last evening, 24 February 2025, and now stand behind the dark glass of Vault-9.
The station powers up the Dark Gallery for the first time. The Commandant wants to know what can still be saved and why the shop needed so many stores. The mentor is the same — QUERY, the old archive intelligence with the temper of a cat: “The main database keeps what must not be lost. The others are given speed, flexibility or work across many servers — and every advantage has a price. Let’s find out what it is.”
The program
9 chapters, 41 lessons, 21 h 10 min
Lessons and progress for every chapter; the first chapter is free, the rest are part of Pro.
Not everything should be a table
Starting from zero: what a database is and why not everything lives in tables. Five ways to store data, chosen by the job rather than the name; questions about the data before the choice of a store; a first copy that answers with stale data. At the end — a bet on where Kotomarket kept what.
Redis: structures and atomicity
Kotomarket’s cache wakes up at 18:00 on 24 February, and the time-to-live clocks keep ticking. Strings, hashes, lists, sets and leaderboards; atomic operations against a race between two clients; rate limiters and keys that stop a request from running twice.
Redis in production: cache and its pitfalls
How the cache sat in front of the main database and once took it down. Cache-aside, invalidation and its races, a stampede of misses, memory and eviction, restarts, a replica and a simple lock with a token.
MongoDB: querying documents
In the shop window three products look different: is the archive damaged, or did the shop store them that way? Documents and collections, queries into a document and the array trap, update operators, aggregations instead of GROUP BY and JOIN, indexes and the query plan.
MongoDB: design
One product card, three generations of documents. What to embed and what to reference, how to live with several schema versions, where one document is enough and where a transaction is needed — and when PostgreSQL does the job.
Cassandra: a table built for the query
The delivery service’s ring of servers refuses a simple query: “all parcels to Kazan”. The partition key and the order inside a partition, one table per question, denormalization instead of JOIN, large partitions and time buckets.
Who’s right when replicas disagree
The replicas disagree, and a cancelled delivery is “in transit” again. Replication and the coordinator, the ONE, QUORUM and ALL consistency levels, last write wins by the clock, tombstones, repair — and how a deleted record comes back to life.
Other stores: match the task
One customer question, three stores: find a product by words, show what people buy with it, check the partner’s stock. A search index, a graph of links, DynamoDB and a map of every kind of store you will meet at work.
NoSQL doesn't live alone
The gallery is assembled into one system around the surviving main database. Dual writes and unknown outcomes, the transactional outbox, search next to the database — and the final project: the Kotomarket architecture after the incident. Then the exam.
The honest boundary
What is not in the course, and why
Installation and administration
Installing and administering clusters are out of scope: the course is about using a store and where it breaks.
Everything runs right in the browser with nothing to install. Node failures, lagging replicas and restarts are shown on the course models.
Absolute speed benchmarks
The course stores run in the browser, and their milliseconds say nothing about real systems.
The cost of a decision is shown with numbers that do not lie: how many times the database was hit, how many records a query scanned, how many replicas answered.
Kafka and CDC in depth
They have their own courses on the platform.
The final chapter covers the transactional outbox and where CDC fits in the system. Kafka and CDC are covered in detail in separate courses on the platform.
FAQ
Frequently asked
No. The course starts with what a database is and explains every idea the first time it appears. Knowing SQL helps: the comparison with a familiar table runs through the whole course.
The gallery is waiting
The first chapter is open in full — 4 lessons, no subscription and no card.