Curriculum planned

Stage 03 · NoSQL, Search & Application Data

Redis

A complete Redis path covering core and advanced data types, expiration, streams, JSON, Search, vector sets, probabilistic and time-series structures, transactions, functions, pipelining, Pub/Sub, persistence, memory/eviction, replication, Sentinel, Cluster, ACL/TLS security, application patterns, observability, performance, backup, upgrades, and production operations.

Browse planned curriculum Back to all courses

24planned chapters

120reserved lesson paths

Beginner → Advancedlearning level

Plannedcourse state

Coverage baselineRedis 8.x data structures and modern Search/JSON/vector capabilities, plus replication, Sentinel, Cluster, persistence, and operations

Course brief

Use Redis as a deliberate data-structure server, not merely “a cache.”

This syllabus deliberately separates foundations, data modeling, query behavior, internals, reliability, security, performance, operations, and production design so advanced material is not compressed into generic catch-all chapters.

By the end

You will be able to

Choose Redis data structures from operation complexity, cardinality, memory cost, persistence needs, and access patterns
Build reliable caching, counters, queues, streams, messaging, search, vector, geospatial, probabilistic, and time-series workflows
Reason about atomicity, scripting/functions, pipelining, client behavior, expiration, eviction, persistence, replication, Sentinel, and Cluster
Secure and observe Redis with ACLs, TLS, metrics, slow/latency analysis, memory diagnostics, benchmarks, backups, and tested upgrades
Design production Redis architectures that control hot keys, stampedes, locks, idempotency, failover, capacity, and disaster recovery

Complete planned syllabus

24 chapters · 120 lesson paths.

Every lesson path is reserved now but intentionally not linked until its lesson HTML is actually published. The sequence moves from foundations through advanced implementation, architecture, operations, reliability, security, tuning, and a production capstone.

Chapter 1

Redis Foundations, Redis 8, Deployment Choices, CLI, and Lab Setup

5 lessons

What Redis Is: In-Memory Data Structures, Optional Durability, and Common Workload FamiliesPlanned lesson · reserved path Chapter01/Lesson1.html

Planned02

Redis Open Source, Managed Services, and Deployment Topologies: Responsibility and Cost BoundariesPlanned lesson · reserved path Chapter01/Lesson2.html

Planned03

Install Redis or Start a Container, Connect with redis-cli, and Verify Server MetadataPlanned lesson · reserved path Chapter01/Lesson3.html

Planned04

RESP, Clients, Connections, Databases/Keyspaces, Command Atomicity, and Single-Threaded Command SemanticsPlanned lesson · reserved path Chapter01/Lesson4.html

Planned05

Build a Reproducible Lab with Configuration, Persistence Directory, Metrics, and Safe AuthenticationPlanned lesson · reserved path Chapter01/Lesson5.html

Planned

Chapter 2

Keys, Namespaces, Expiration, TTL, Scanning, and Data-Type Introspection

5 lessons

Key Naming Schemes, Namespaces, Hash Tags, Cardinality, and Operational DiscoverabilityPlanned lesson · reserved path Chapter02/Lesson1.html

Planned02

EXPIRE/PEXPIRE, EXPIREAT, TTL/PTTL, PERSIST, Conditional Expiration, and Lifecycle SemanticsPlanned lesson · reserved path Chapter02/Lesson2.html

Planned03

KEYS vs SCAN: Incremental Iteration, Cursor Semantics, and Production SafetyPlanned lesson · reserved path Chapter02/Lesson3.html

Planned04

TYPE, OBJECT, MEMORY USAGE, DUMP/RESTORE, COPY, RENAME, UNLINK, and Deletion CostPlanned lesson · reserved path Chapter02/Lesson4.html

Planned05

Design a Key Lifecycle Policy for Retention, Privacy, Cache Freshness, and CapacityPlanned lesson · reserved path Chapter02/Lesson5.html

Planned

Chapter 3

Strings, Counters, Bitmaps, Bitfields, and Binary Values

5 lessons

SET/GET Options, NX/XX, GET, EX/PX, Atomic Initialization, and Conditional WritesPlanned lesson · reserved path Chapter03/Lesson1.html

Planned02

INCR/DECR/INCRBYFLOAT: Counters, Quotas, Sequencing, and Overflow/Precision AwarenessPlanned lesson · reserved path Chapter03/Lesson2.html

Planned03

MGET/MSET, GETRANGE/SETRANGE, APPEND, Binary Payloads, and Network/Memory TradeoffsPlanned lesson · reserved path Chapter03/Lesson3.html

Planned04

Bitmaps with SETBIT/GETBIT/BITCOUNT/BITOP for Dense Boolean StatePlanned lesson · reserved path Chapter03/Lesson4.html

Planned05

BITFIELD for Packed Integers, Overflow Modes, and Memory-Efficient CountersPlanned lesson · reserved path Chapter03/Lesson5.html

Planned

Chapter 4

Hashes and Object-Like Records

5 lessons

HSET/HGET/HMGET/HGETALL and Modeling Compact Field/Value RecordsPlanned lesson · reserved path Chapter04/Lesson1.html

Planned02

HINCRBY/HINCRBYFLOAT for Atomic Per-Field Metrics and StatePlanned lesson · reserved path Chapter04/Lesson2.html

Planned03

HSCAN, Field Cardinality, Large Hashes, and Incremental ProcessingPlanned lesson · reserved path Chapter04/Lesson3.html

Planned04

Field-Level Expiration Capabilities Where Available and Version-Aware Client DesignPlanned lesson · reserved path Chapter04/Lesson4.html

Planned05

Hashes vs JSON vs Many Keys: Memory, Partial Updates, Indexing, and Schema TradeoffsPlanned lesson · reserved path Chapter04/Lesson5.html

Planned

Chapter 5

Lists, Sets, and Queue/Collection Patterns

5 lessons

Lists: LPUSH/RPUSH, LPOP/RPOP, LRANGE, LTRIM, and Ordered Sequence SemanticsPlanned lesson · reserved path Chapter05/Lesson1.html

Planned02

Blocking List Operations and Reliable Queue Limitations Compared with StreamsPlanned lesson · reserved path Chapter05/Lesson2.html

Planned03

Sets: SADD/SREM/SISMEMBER, Cardinality, Random Members, and DeduplicationPlanned lesson · reserved path Chapter05/Lesson3.html

Planned04

SUNION/SINTER/SDIFF and Set Algebra for Tags, Audiences, and PermissionsPlanned lesson · reserved path Chapter05/Lesson4.html

Planned05

Choose List vs Set vs Stream vs Sorted Set from Ordering, Delivery, Replay, and Membership NeedsPlanned lesson · reserved path Chapter05/Lesson5.html

Planned

Chapter 6

Sorted Sets, Rankings, Scheduling, and Range Queries

5 lessons

ZADD Scores, Members, Conditional Updates, and Rank SemanticsPlanned lesson · reserved path Chapter06/Lesson1.html

Planned02

ZRANGE by Rank/Score/Lex, Reverse Ordering, Pagination, and WITHSCORESPlanned lesson · reserved path Chapter06/Lesson2.html

Planned03

ZINCRBY, Leaderboards, Sliding Windows, Delayed Work, and Time-Ordered IndexesPlanned lesson · reserved path Chapter06/Lesson3.html

Planned04

ZUNION/ZINTER/ZDIFF and Weighted Ranking AggregationPlanned lesson · reserved path Chapter06/Lesson4.html

Planned05

Use Sorted Sets for Rate Limits, Schedulers, Expiration Indexes, and Secondary Access PathsPlanned lesson · reserved path Chapter06/Lesson5.html

Planned

Chapter 7

Redis Streams and Consumer Groups

5 lessons

XADD IDs, Stream Ordering, Approximate Trimming, and Event RetentionPlanned lesson · reserved path Chapter07/Lesson1.html

Planned02

XREAD for Blocking/Nonblocking Consumption and Replay from Explicit IDsPlanned lesson · reserved path Chapter07/Lesson2.html

Planned03

Consumer Groups with XGROUP/XREADGROUP: Distribution, Pending Entries, and AcknowledgmentPlanned lesson · reserved path Chapter07/Lesson3.html

Planned04

XPENDING, XCLAIM/XAUTOCLAIM, Idle Consumers, Retries, Poison Events, and RecoveryPlanned lesson · reserved path Chapter07/Lesson4.html

Planned05

Design an At-Least-Once Stream Pipeline with Idempotent Processing, Backpressure, and ObservabilityPlanned lesson · reserved path Chapter07/Lesson5.html

Planned

Chapter 8

Redis JSON and Document-Oriented Data

5 lessons

JSON.SET/GET and JSON Paths: Store and Address Nested DocumentsPlanned lesson · reserved path Chapter08/Lesson1.html

Planned02

Atomic Numeric, String, Array, and Object Mutations Without Replacing Whole DocumentsPlanned lesson · reserved path Chapter08/Lesson2.html

Planned03

Document Modeling: Embedding, Duplication, Key Design, Size, and Partial UpdatesPlanned lesson · reserved path Chapter08/Lesson3.html

Planned04

Index JSON Fields with Redis Search and Keep Schema Evolution ExplicitPlanned lesson · reserved path Chapter08/Lesson4.html

Planned05

Choose Hashes vs JSON from Query Needs, Structure, Memory, Client Ergonomics, and SearchPlanned lesson · reserved path Chapter08/Lesson5.html

Planned

Chapter 9

Redis Search: Indexes, Text/Numeric/Tag/Geo Fields, Querying, and Aggregation

5 lessons

Create Search Indexes over Hash/JSON Data and Understand Schema/Prefix ScopePlanned lesson · reserved path Chapter09/Lesson1.html

Planned02

Text Analysis, Stemming, Stop Words, Exact Tags, Numeric Ranges, and Geospatial FieldsPlanned lesson · reserved path Chapter09/Lesson2.html

Planned03

FT.SEARCH Query Syntax, Boolean Logic, Phrase/Prefix/Fuzzy Search, Sorting, and PaginationPlanned lesson · reserved path Chapter09/Lesson3.html

Planned04

FT.AGGREGATE Pipelines, Grouping, Reducers, Filters, Apply, and Result ShapingPlanned lesson · reserved path Chapter09/Lesson4.html

Planned05

Index Maintenance, Memory Cost, Query Profiling, and Choosing Search vs Key-Based AccessPlanned lesson · reserved path Chapter09/Lesson5.html

Planned

Chapter 10

Vector Sets, Vector Search, Hybrid Retrieval, and AI Workloads

5 lessons

Embeddings, Dimensions, Cosine Similarity, HNSW Concepts, Recall, and LatencyPlanned lesson · reserved path Chapter10/Lesson1.html

Planned02

VADD, VSIM, Vector-Set Metadata/Attributes, and Core Redis 8 Vector OperationsPlanned lesson · reserved path Chapter10/Lesson2.html

Planned03

Hybrid Retrieval with Structured Filters and Vector SimilarityPlanned lesson · reserved path Chapter10/Lesson3.html

Planned04

Vector Compression/Quantization Awareness, Memory Planning, and Accuracy BenchmarksPlanned lesson · reserved path Chapter10/Lesson4.html

Planned05

Design Semantic Search, Recommendations, or RAG Retrieval with Security Filters and EvaluationPlanned lesson · reserved path Chapter10/Lesson5.html

Planned

Chapter 11

Probabilistic Data Structures and Approximate Analytics

5 lessons

HyperLogLog for Approximate Cardinality: PFADD, PFCOUNT, PFMERGE, and Error TradeoffsPlanned lesson · reserved path Chapter11/Lesson1.html

Planned02

Bloom Filters: Membership with False Positives, Capacity, Error Rate, and ScalingPlanned lesson · reserved path Chapter11/Lesson2.html

Planned03

Cuckoo Filters: Membership, Deletion, Count Semantics, and Capacity PlanningPlanned lesson · reserved path Chapter11/Lesson3.html

Planned04

Count-Min Sketch, Top-K, and t-digest for Frequency, Heavy Hitters, and QuantilesPlanned lesson · reserved path Chapter11/Lesson4.html

Planned05

Choose Approximate Structures When Memory Savings Outweigh Exactness RequirementsPlanned lesson · reserved path Chapter11/Lesson5.html

Planned

Chapter 12

Time Series and Geospatial Workloads

5 lessons

Time-Series Keys, Labels, Retention, Duplicate Policies, and Compression ConceptsPlanned lesson · reserved path Chapter12/Lesson1.html

Planned02

Aggregations, Downsampling, Compaction Rules, and Multi-Series QueriesPlanned lesson · reserved path Chapter12/Lesson2.html

Planned03

Geospatial GEOADD, GEOSEARCH, Distance, Radius/Box Queries, and Sorted-Set FoundationsPlanned lesson · reserved path Chapter12/Lesson3.html

Planned04

Model Metrics/Telemetry and Location Data with Bounded Cardinality and RetentionPlanned lesson · reserved path Chapter12/Lesson4.html

Planned05

Combine Time/Geo Data with Search, Streams, and Application-Side AggregationPlanned lesson · reserved path Chapter12/Lesson5.html

Planned

Chapter 13

Transactions, WATCH, Optimistic Locking, and Atomicity

5 lessons

MULTI/EXEC Queueing Semantics, Atomic Execution, and What Transactions Do Not ProvidePlanned lesson · reserved path Chapter13/Lesson1.html

Planned02

WATCH/UNWATCH for Optimistic Concurrency and Retry LoopsPlanned lesson · reserved path Chapter13/Lesson2.html

Planned03

DISCARD, Command Errors, Runtime Errors, and Partial Semantic Surprises Inside EXECPlanned lesson · reserved path Chapter13/Lesson3.html

Planned04

Atomic Single Commands vs Transactions vs Functions/Scripts: Choose the Simplest Correct PrimitivePlanned lesson · reserved path Chapter13/Lesson4.html

Planned05

Build and Stress-Test a Conditional Update Workflow Under Concurrent ClientsPlanned lesson · reserved path Chapter13/Lesson5.html

Planned

Chapter 14

Lua Scripting and Redis Functions

5 lessons

EVAL/EVALSHA: Atomic Server-Side Logic, KEYS/ARGV, and Script Cache BehaviorPlanned lesson · reserved path Chapter14/Lesson1.html

Planned02

Scripting Constraints: Blocking Time, Determinism, Replication, and Cluster Key AccessPlanned lesson · reserved path Chapter14/Lesson2.html

Planned03

Redis Functions: Libraries, FCALL, Persistence, Deployment, and Versioned Server LogicPlanned lesson · reserved path Chapter14/Lesson3.html

Planned04

Error Handling, Read-Only Functions/Scripts, ACL Interaction, and Safe RolloutPlanned lesson · reserved path Chapter14/Lesson4.html

Planned05

Replace Multi-Round-Trip Race-Prone Logic with a Small Measured Atomic FunctionPlanned lesson · reserved path Chapter14/Lesson5.html

Planned

Chapter 15

Pipelining, Batching, Client Libraries, and Client-Side Caching

5 lessons

Pipelining vs Transactions: Network Round Trips, Ordering, Buffering, and Error HandlingPlanned lesson · reserved path Chapter15/Lesson1.html

Planned02

Batch Size, Memory, Backpressure, and Latency/Throughput TradeoffsPlanned lesson · reserved path Chapter15/Lesson2.html

Planned03

Connection Pools vs Multiplexed Clients, Timeouts, Reconnects, and Command RetriesPlanned lesson · reserved path Chapter15/Lesson3.html

Planned04

Client-Side Caching and Server-Assisted Invalidation: Freshness and Coherency BoundariesPlanned lesson · reserved path Chapter15/Lesson4.html

Planned05

Benchmark a Chatty Workflow Before and After Pipelining with Realistic PayloadsPlanned lesson · reserved path Chapter15/Lesson5.html

Planned

Chapter 16

Pub/Sub, Keyspace Notifications, and Messaging Tradeoffs

5 lessons

PUBLISH/SUBSCRIBE and Pattern/Shard Channels: Ephemeral Fan-Out SemanticsPlanned lesson · reserved path Chapter16/Lesson1.html

Planned02

At-Most-Once Delivery, Disconnect Loss, Slow Subscribers, and Why Pub/Sub Is Not a Durable QueuePlanned lesson · reserved path Chapter16/Lesson2.html

Planned03

Keyspace/Keyevent Notifications: Configuration, Event Types, Overhead, and Race ConditionsPlanned lesson · reserved path Chapter16/Lesson3.html

Planned04

Pub/Sub vs Streams vs External Brokers: Replay, Consumer State, Ordering, and DurabilityPlanned lesson · reserved path Chapter16/Lesson4.html

Planned05

Design Real-Time Notifications Without Mistaking Delivery Signals for Business StatePlanned lesson · reserved path Chapter16/Lesson5.html

Planned

Chapter 17

Persistence: RDB Snapshots, AOF, fsync, Rewrites, and Crash Recovery

5 lessons

RDB Snapshots: Forking, Copy-on-Write, Save Rules, Startup Load, and Data-Loss WindowPlanned lesson · reserved path Chapter17/Lesson1.html

Planned02

AOF Persistence: Command Logging, fsync Policies, Durability, and File GrowthPlanned lesson · reserved path Chapter17/Lesson2.html

Planned03

AOF Rewrite/Compaction, Base/Incremental Files, Fork Costs, and Disk HeadroomPlanned lesson · reserved path Chapter17/Lesson3.html

Planned04

Use RDB + AOF Together, Understand Startup Recovery Order, and Validate Persistence FilesPlanned lesson · reserved path Chapter17/Lesson4.html

Planned05

Choose Durability Settings from RPO, Latency, Memory, Fork Behavior, and Storage CharacteristicsPlanned lesson · reserved path Chapter17/Lesson5.html

Planned

Chapter 18

Memory Management, Eviction, Expiration, Fragmentation, and OOM Prevention

5 lessons

used_memory vs RSS, Allocator Overhead, Fragmentation, Buffers, and Replication/AOF MemoryPlanned lesson · reserved path Chapter18/Lesson1.html

Planned02

maxmemory and Eviction Policies: noeviction, LRU, LFU, Random, and TTL-Aware ChoicesPlanned lesson · reserved path Chapter18/Lesson2.html

Planned03

Approximate LRU/LFU Sampling, LFU Decay, Hot-Set Behavior, and Cache Hit RatePlanned lesson · reserved path Chapter18/Lesson3.html

Planned04

Big Keys, Hot Keys, Large Collections, Lazy Freeing, Active Defrag, and Memory DiagnosticsPlanned lesson · reserved path Chapter18/Lesson4.html

Planned05

Build a Memory Budget Including Data, Indexes, Replication Buffers, Fork Headroom, and FailoverPlanned lesson · reserved path Chapter18/Lesson5.html

Planned

Chapter 19

Replication, PSYNC, Backlog, Replica Reads, and Failover Foundations

5 lessons

Primary/Replica Replication, Asynchronous Semantics, Initial Sync, and Command PropagationPlanned lesson · reserved path Chapter19/Lesson1.html

Planned02

Partial Resynchronization, Replication IDs, Backlog Sizing, and Reconnect WindowsPlanned lesson · reserved path Chapter19/Lesson2.html

Planned03

Disk-Based vs Diskless Sync, Replication Buffers, Network Pressure, and Large Dataset RecoveryPlanned lesson · reserved path Chapter19/Lesson3.html

Planned04

Replica Reads, Staleness, replica-read-only, min-replicas Settings, and Durability ExpectationsPlanned lesson · reserved path Chapter19/Lesson4.html

Planned05

Failure Drill: Break Replication, Observe Lag, Recover, and Measure Data/Availability ImpactPlanned lesson · reserved path Chapter19/Lesson5.html

Planned

Chapter 20

Redis Sentinel: Monitoring, Automatic Failover, and Service Discovery

5 lessons

Sentinel Architecture, Quorum vs Majority, Objective Down, and Failure DetectionPlanned lesson · reserved path Chapter20/Lesson1.html

Planned02

Configure Multiple Sentinels, Monitored Primary, Replicas, Authentication, and NetworkingPlanned lesson · reserved path Chapter20/Lesson2.html

Planned03

Leader Election, Failover State Machine, Replica Promotion, and ReconfigurationPlanned lesson · reserved path Chapter20/Lesson3.html

Planned04

Client Discovery Through Sentinel, Reconnect Behavior, DNS/NAT/Container ConsiderationsPlanned lesson · reserved path Chapter20/Lesson4.html

Planned05

Run a Sentinel Failover Game Day and Verify Application Recovery and Data-Loss BoundsPlanned lesson · reserved path Chapter20/Lesson5.html

Planned

Chapter 21

Redis Cluster: Hash Slots, Routing, Resharding, and Cluster Availability

5 lessons

16384 Hash Slots, CRC16, Key Distribution, Nodes, Primaries, Replicas, and Cluster BusPlanned lesson · reserved path Chapter21/Lesson1.html

Planned02

MOVED vs ASK Redirections, Cluster-Aware Clients, Topology Refresh, and Retry BehaviorPlanned lesson · reserved path Chapter21/Lesson2.html

Planned03

Hash Tags and Multi-Key Operations: Co-Locating Related Keys Without Creating Hot SlotsPlanned lesson · reserved path Chapter21/Lesson3.html

Planned04

Add/Remove Nodes, Reshard Slots, Migrate Keys, Fail Over Primaries, and Maintain HeadroomPlanned lesson · reserved path Chapter21/Lesson4.html

Planned05

Cluster Partitions, Replica Migration, Availability Rules, and Designing for Node/Zone FailurePlanned lesson · reserved path Chapter21/Lesson5.html

Planned

Chapter 22

Security: ACLs, TLS, Command/Key Permissions, Secrets, and Network Boundaries

5 lessons

Default User, ACL Users, Passwords, Command Categories, Key Patterns, and Channel PatternsPlanned lesson · reserved path Chapter22/Lesson1.html

Planned02

Least Privilege for Applications, Operators, Monitoring, Replication, Sentinel, and ClusterPlanned lesson · reserved path Chapter22/Lesson2.html

Planned03

TLS for Client and Internode Traffic, Certificate Lifecycle, and Performance ConsiderationsPlanned lesson · reserved path Chapter22/Lesson3.html

Planned04

Disable/Restrict Dangerous Administration, Protect CONFIG/MODULE-Like Capabilities, and Network AccessPlanned lesson · reserved path Chapter22/Lesson4.html

Planned05

Secrets Rotation, Audit/Connection Evidence, Backups, and Incident Response for Credential ExposurePlanned lesson · reserved path Chapter22/Lesson5.html

Planned

Chapter 23

Application Patterns: Caching, Rate Limiting, Locks, Idempotency, and Hot-Key Control

5 lessons

Cache-Aside with TTL/Jitter, Negative Caching, Stampede Protection, and Stale-While-RevalidatePlanned lesson · reserved path Chapter23/Lesson1.html

Planned02

Fixed/Sliding Window, Token Bucket, and Leaky-Bucket Rate Limiting with Atomic OperationsPlanned lesson · reserved path Chapter23/Lesson2.html

Planned03

Distributed Locks: SET NX PX, Ownership Tokens, Safe Unlock, Leases, and Fencing LimitationsPlanned lesson · reserved path Chapter23/Lesson3.html

Planned04

Idempotency Keys, Deduplication, Request State Machines, and Retry-Safe APIsPlanned lesson · reserved path Chapter23/Lesson4.html

Planned05

Hot Keys, Fan-Out, Replication Read Scaling, Sharding, Local Caches, and Workload RedesignPlanned lesson · reserved path Chapter23/Lesson5.html

Planned

Chapter 24

Observability, Latency, Benchmarking, Capacity, Backup, Upgrades, and Capstone

5 lessons

INFO, LATENCY, SLOWLOG, MEMORY, CLIENT LIST, MONITOR Caveats, and Exported MetricsPlanned lesson · reserved path Chapter24/Lesson1.html

Planned02

Latency Doctor, Intrinsic Latency, Fork Pauses, Big Commands, Network, CPU, and Storage DiagnosticsPlanned lesson · reserved path Chapter24/Lesson2.html

Planned03

redis-benchmark and Custom Load Tests: Pipeline Depth, Payload, Durability, Skew, and Tail LatencyPlanned lesson · reserved path Chapter24/Lesson3.html

Planned04

Back Up RDB/AOF, Test Restore, Perform Rolling/Topology-Aware Upgrades, and Maintain Rollback PlansPlanned lesson · reserved path Chapter24/Lesson4.html

Planned05

Capstone: Design, Load-Test, Fail Over, Recover, Secure, Tune, and Operate a Production Redis PlatformPlanned lesson · reserved path Chapter24/Lesson5.html

Planned