Tutorial

NoSQL Databases: Architecture, Data Models, and Practical Use

Understand why NoSQL databases emerged and how their architectures differ from relational systems. This tutorial explores document, key-value, wide-column, and graph databases; data modeling; partitioning; sharding; replication; consistency; CAP; transactions; caching; CQRS; microservices; and polyglot persistence. It concludes with practical architecture decisions for ownership, data flow, scaling, performance, and failure scenarios.

1. Lesson 1

   Lesson 1: Why NoSQL Exists

   Demo
   Open lesson
2. Lesson 2

   Lesson 2: Relational vs. NoSQL: The Fundamental Differences

   Demo
   Open lesson
3. Lesson 3

   Lesson 3: The Distributed Systems Foundations of NoSQL

   Demo
   Open lesson
4. Lesson 4

   Lesson 4: Document Databases

   Demo
   Open lesson
5. Lesson 5

   Lesson 5: Key-Value Databases

   Demo
   Open lesson
6. Lesson 6

   Lesson 6: Wide-Column Databases

   Locked
   Unlock
7. Lesson 7

   Lesson 7: Graph Databases

   Locked
   Unlock
8. Lesson 8

   Lesson 8: Data Modeling in NoSQL

   Locked
   Unlock
9. Lesson 9

   Lesson 9: Partitioning and Sharding

   Locked
   Unlock
10. Lesson 10

    Lesson 10: Replication

    Locked
    Unlock
11. Lesson 11

    Lesson 11: Consistency Models

    Locked
    Unlock
12. Lesson 12

    Lesson 12: CAP Theorem in Practice

    Locked
    Unlock
13. Lesson 13

    Lesson 13: Transactions in NoSQL

    Locked
    Unlock
14. Lesson 14

    Lesson 14: ACID, BASE, and Eventual Consistency

    Locked
    Unlock
15. Lesson 15

    Lesson 15: Handling Relationships Without Relational Joins

    Locked
    Unlock
16. Lesson 16

    Lesson 16: MongoDB Architecture and Design

    Locked
    Unlock
17. Lesson 17

    Lesson 17: Redis Architecture and Use Cases

    Locked
    Unlock
18. Lesson 18

    Lesson 18: Cassandra Architecture and Data Modeling

    Locked
    Unlock
19. Lesson 19

    Lesson 19: DynamoDB Architecture and Design

    Locked
    Unlock
20. Lesson 20

    Lesson 20: Graph Databases with Neo4j

    Locked
    Unlock
21. Lesson 21

    Lesson 21: NoSQL in Microservices

    Locked
    Unlock
22. Lesson 22

    Lesson 22: NoSQL, Caching, CQRS, and Event-Driven Architecture

    Locked
    Unlock
23. Lesson 23

    Lesson 23: Choosing the Right Database: Architecture Decision Framework

    Locked
    Unlock
24. Lesson 24

    Lesson 24: Designing a Polyglot Persistence System

    Locked
    Unlock
25. Lesson 25

    Lesson 25: Assigning Data Ownership to Services

    Locked
    Unlock
26. Lesson 26

    Lesson 26: Designing the Database Architecture

    Locked
    Unlock
27. Lesson 27

    Lesson 27: Designing the Data Flow

    Locked
    Unlock
28. Lesson 28

    Lesson 28: Consistency, Replication, and Failure Scenarios

    Locked
    Unlock
29. Lesson 29

    Lesson 29: Scaling and Performance Architecture

    Locked
    Unlock
30. Lesson 30

    Lesson 30: Defending the Architecture: ADR and Architectural Trade-offs

    Locked
    Unlock