Data Science & AI NoSQL and Cloud Data Architecture

NoSQL Concepts: MongoDB, Redis, and DynamoDB

Design, model, query, and operate modern NoSQL systems with confidence

Log In to Enroll About this course Get unlimited access
NoSQL Concepts: MongoDB, Redis, and DynamoDB logo
Quick Course Facts
20
Self-paced, Online, Lessons
20
Videos and/or Narrated Presentations
7.5
Approximate Hours of Course Media
About the NoSQL Concepts: MongoDB, Redis, and DynamoDB Course

NoSQL Concepts: MongoDB, Redis, and DynamoDB is a practical course for developers, architects, and data professionals who want to understand how modern non-relational Databases work. You will learn how to Design, model, query, and operate modern NoSQL systems with confidence while choosing the right database approach for real application workloads.

Build Reliable NoSQL Databases For Modern Applications

  • Compare relational, document, key-value, and wide-column database models with clear decision-making criteria.
  • Learn practical data modeling patterns for MongoDB, Redis, and DynamoDB.
  • Understand replication, partitioning, consistency, indexing, caching, sharding, and production operations.
  • Design a complete NoSQL data strategy for scalable, cost-aware, real-world systems.

Master the core concepts behind NoSQL Databases and apply MongoDB, Redis, and DynamoDB effectively in production-ready architectures.

This course begins with the foundations of NoSQL, explaining why these Databases exist, what problems they solve, and how they differ from traditional relational systems. You will explore distributed data concepts such as replication, partitioning, and consistency, then learn how access-pattern-driven modeling shapes the way modern applications store and retrieve data.

Through the MongoDB section, you will work with documents, collections, flexible schema Design, relationship modeling, query patterns, indexes, aggregation pipelines, transactions, replication, and sharding. The Redis lessons focus on in-memory data structures, caching strategies, TTL, invalidation, rate limiting, queues, Pub/Sub, and real-time application patterns.

The DynamoDB portion covers tables, items, partition keys, sort keys, single-table Design, secondary indexes, capacity modes, cost-aware architecture, streams, TTL, global tables, and serverless workloads. By the end of NoSQL Concepts: MongoDB, Redis, and DynamoDB, you will be able to evaluate tradeoffs, model data around application needs, query efficiently, and operate modern NoSQL systems with confidence.

Course Lessons

Full lesson breakdown

Lessons are organized by topic area and each includes descriptive copy for search visibility and student clarity.

Foundations of NoSQL

4 lessons

Lesson 1: Why NoSQL Exists and What Problems It Solves

20 min Preview
This lesson explains why NoSQL databases emerged, what pressures exposed the limits of traditional relational designs, and how systems such as MongoDB, Redis, and DynamoDB solve different classes of a…

Lesson 2: Comparing Relational, Document, Key-Value, and Wide-Column Models

21 min
This lesson compares four major data models used in modern database design: relational, document, key-value, and wide-column. You will learn how each model represents data, what kinds of questions it …

Lesson 3: Core Distributed Data Concepts: Replication, Partitioning, and Consistency

24 min
This lesson introduces the distributed systems ideas that make NoSQL databases useful at scale: replication, partitioning, and consistency. Students learn why MongoDB, Redis, and DynamoDB distribute d…

Lesson 4: Access-Pattern-Driven Data Modeling

22 min
Access-pattern-driven data modeling is the discipline of designing NoSQL data structures from the questions an application must answer, not from a normalized entity diagram. In this lesson, Professor …

MongoDB Fundamentals

4 lessons

Lesson 5: MongoDB Documents, Collections, and Flexible Schema Design

20 min
This lesson introduces MongoDB’s core data organization model: documents , collections , and flexible schemas. Learners will see how MongoDB stores application data as BSON documents, how collections …

Lesson 6: Modeling Relationships in MongoDB: Embedding, Referencing, and Tradeoffs

23 min
This lesson teaches how to model relationships in MongoDB using embedded documents, references, and hybrid patterns. Learners will evaluate relationship shape, access patterns, update frequency, docum…

Lesson 7: MongoDB Querying, Filtering, Projection, and Update Patterns

21 min
In this lesson, Professor Victoria Okafor teaches practical MongoDB query and update patterns used in everyday application development. Learners move beyond basic document storage into precise filteri…

Lesson 8: MongoDB Indexes, Aggregation Pipelines, and Performance Tuning

25 min
In this lesson, students learn how MongoDB uses indexes, aggregation pipelines, and query plans to make document workloads fast and predictable. The focus is practical: choosing indexes that match rea…

MongoDB in Production

1 lesson

Lesson 9: MongoDB Transactions, Replication, Sharding, and Operational Concerns

24 min
This lesson moves MongoDB from application development into production design. You will learn when MongoDB transactions are appropriate, how replica sets provide high availability, how sharding distri…

Redis Fundamentals

2 lessons

Lesson 10: Redis as an In-Memory Data Platform

19 min
This lesson introduces Redis as more than a simple cache: an in-memory data platform built around fast key-based access, rich data structures, atomic commands, and optional durability. Learners will u…

Lesson 11: Redis Data Structures: Strings, Hashes, Lists, Sets, Sorted Sets, and Streams

24 min
This lesson explains Redis through the data structures that make it useful: strings, hashes, lists, sets, sorted sets, and streams. Rather than treating Redis as a simple key-value cache, learners wil…

Redis Application Patterns

2 lessons

Lesson 12: Caching Patterns with Redis: Aside, Write-Through, TTL, and Invalidation

23 min
Redis is often introduced as a fast key-value store, but its real value in application architecture comes from using it deliberately. This lesson covers practical caching patterns: cache-aside, write-…

Lesson 13: Redis for Rate Limiting, Queues, Pub/Sub, and Real-Time Features

22 min
This lesson shows how Redis supports high-speed application patterns beyond simple caching. You will learn how to use Redis for rate limiting, lightweight queues, Pub/Sub messaging, and real-time stat…

DynamoDB Fundamentals

2 lessons

Lesson 14: DynamoDB Tables, Items, Partition Keys, and Sort Keys

21 min
In this lesson, Professor Victoria Okafor introduces the core building blocks of Amazon DynamoDB tables: items, attributes, partition keys, and sort keys. Learners will see why DynamoDB design starts …

Lesson 15: DynamoDB Access Patterns and Single-Table Design

25 min
This lesson teaches DynamoDB access-pattern-first design, with a practical focus on single-table modeling. Learners will translate application questions into partition keys, sort keys, item types, and…

DynamoDB in Production

2 lessons

Lesson 16: DynamoDB Secondary Indexes, Capacity Modes, and Cost-Aware Design

24 min
This lesson focuses on the DynamoDB production choices that most directly affect query flexibility, performance, and monthly cost: secondary indexes, capacity modes, and access-pattern-driven design. …

Lesson 17: DynamoDB Streams, TTL, Global Tables, and Serverless Architectures

22 min
This lesson explains how DynamoDB production systems use Streams, TTL, Global Tables, and serverless event patterns together. Students learn how to react to data changes, expire data safely, replicate…

Architecture and Decision Making

3 lessons

Lesson 18: Choosing Between MongoDB, Redis, and DynamoDB for Real Workloads

23 min
In this lesson, Professor Victoria Okafor shows how to choose between MongoDB, Redis, and DynamoDB for real production workloads. The focus is not on which database is "best," but on matching workload…

Lesson 19: Designing a Polyglot Persistence Architecture

24 min
Polyglot persistence is the practice of using different data stores for different parts of a system when one database cannot serve all access patterns well. In this lesson, Professor Victoria Okafor s…

Lesson 20: Capstone: Building a NoSQL Data Strategy for a Modern Application

25 min
In this capstone lesson, learners synthesize the course concepts into a practical NoSQL data strategy for a modern application. The focus is not on choosing a favorite database, but on matching data m…

Take this course at your own pace

Create a free account to enroll, keep your progress, and preview lessons — it takes 30 seconds.

Create a Free Account
About Your Instructor
Professor Victoria Okafor

Professor Victoria Okafor

Professor Victoria Okafor guides this AI-built Virversity course with a clear, practical teaching style.