Learn Redis with Node and Express: Build Real-Time Projects

Explore Redis, its in-memory design, and set up a Docker container to build real-time projects in a clean development environment.

Discover how Redis stores data in memory for speed, using simple structures like strings, lists, and sets, with optional persistence and lightweight, no-disk design for real-time applications.

Set up a clean development environment with Docker, Docker Desktop, and Docker Hub to run redisai in containers, using images, ports, and volumes for stable, reusable setups.

Create and run a Redis container using Docker Compose to keep the development environment simple, reliable, and easily resettable, then verify the container is running and accessible via port 6379.

Set up and connect Redisai with Redisai Insight using Docker, then explore and manage data through the Redisai Insight GUI and Redis server commands.

Explore Redis strings, using the set command and clear key naming patterns. Master expire and TDL for data lifetimes, plus append, string length, and counters via increments and decrements.

Learn to set string values in Redisai using set and variants like NX, XX, and TTL (EX/PX), including updates, conditional writes, and basic get usage.

Learn how to name and structure Redis keys with prefixes and colon separators to prevent collisions, enable pattern-based lookups, and choose safe search methods like scan over keys.

Learn how redisai handles key expiration with expire and ttl to manage memory and lifecycles, including checking, updating, and removing keys. Use persist and x/px for seconds and milliseconds lifetimes.

Master retrieving strings in Redis with get and mget, check key existence with exists, and gracefully handle missing keys for real-time Node and Express projects.

Learn how to use the Redis append command to extend string values and the string.length command to measure byte length, including handling non-existent keys and multi-byte characters.

Learn to use Redisai strings as atomic counters with incr and decr, creating keys on first use and tracking numeric values for real-time metrics.

Explore Redis hashes and how they store field value pairs under a key for objects; learn to create, read, update, and delete fields, and manage key naming and expiry.

Learn how Redis hashes store multiple related values under a single key, using fields and values to group user data, enabling fast, targeted updates and memory efficiency.

Create and update hashes in Redis using HSET, storing related fields like name, email, and age under a single key, with all values stored as strings.

Read hash data efficiently with Redis commands like hget, hmget, and hgetall, then validate fields with hexists and hlen to inspect key structure.

Learn how to update Redis hashes with hset, including replacing existing fields silently, adding new fields, and updating multiple fields in a single command for efficiency.

Delete specific fields with HDEL and remove the entire hash key with DEL; Redis auto removes the hash after the last field is deleted, and beware of non-existent fields.

Manage Redis hash keys with clear naming, metadata, and expiry strategies to improve traceability and performance. Use colons for namespaces, TTLs, and scan to monitor memory and lifecycle.

Learn to use Redis hash operations efficiently and safely, explore pipelines for batching commands, and apply transactions for atomic hash updates, choosing the right approach for your code.

Learn how Redis pipelines batch commands to reduce network round trips and latency, speeding up bulk hash, string, set, and list operations by sending a single request.

Explore Redis reading transactions with MULTI and EXEC to queue commands and execute them in order, ensuring predictable sequences, isolation, and no automatic rollback, with discard to cancel.

Design and implement a session-based cart system using PostgreSQL for persistence and Redis for speed, containerized for scalable backend services, with Swagger UI to interact.

Establish the foundation of a redis with node and express project by containerizing postgresql, scaffolding the express app, integrating a prisma schema, and documenting the api with swagger ui.

Containerize a Postgres database with Docker, define a docker compose file, and seed inventory data via an init SQL script and CSV files.

Learn to scaffold a type-safe Express.js API with TypeScript, including middleware, routing, a simple root endpoint, hot reload, Swagger docs, and Prisma-backed Postgres ready for Redis.

Containerize the express app with a node 24 image, load environment variables, bind mount /app, and expose ports 3000 and 5055 for hot reloading and consistent development.

Configure Prisma as the ORM for a Postgres database, introspect existing tables, generate a typed Prisma client, and wire it into the dockerized Express app.

Explore Postgres SQL data visually with Prisma Studio, a built-in interface for inspecting, editing, and debugging records from the browser.

Configure Swagger UI to document and test an Express API with live open API docs generated by swagger auto gen and jsdoc. Expose docs endpoint and interact with Redis endpoints.

Integrate Redis to power a real-time, session-backed cart system, enabling atomic operations for dynamic cart updates, promotions, and product validation while maintaining fast performance.

Set up scalable session management with Redis in an Express app using express-session, connect-redis, and ioredis, linking cart data to a session ID stored in Redis for persistence across containers.

Learn to implement a session-based add to cart feature using Redis with Node and Express, including middleware, cart routes, Redis hash storage, and type-safe cart items.

Build a get cart endpoint that retrieves a user's cart from Redis using hgetall, transforms hash data into cart item objects, and returns the cart contents.

Remove a specific item from a Redis-backed cart by using the Del command on the cart hash, identified by product id via a delete endpoint.

Learn to clear an entire cart in Redis with a single atomic del operation on the cart hash, triggered by a delete /clear endpoint using a cart identifier.

Increment or decrement a cart item's quantity with backend logic that removes it when zero. Validate input, identify cart and product IDs, and update the cart via post.

Apply a promo code to a user cart by storing the code in redis as a separate key within the cart namespace, exposed via a post endpoint with validation.

Validate and synchronize cart data with the database using a Prisma endpoint that compares cart items to the source of truth, updating mismatches for accurate checkout.

Refactor the cart quantities in Redis to boost precision and performance beyond basic session storage. Implement expiration strategies and use Redis pipelines and atomic transactions for real-time updates.

Set a seven-day time-to-live for the cart and promo code in Redis, refreshing TTL on every cart interaction. This keeps data clean by removing stale entries and saving memory.

Refactor the Redis cart to a split hash pattern that separates quantity from product details and promo codes, enabling atomic quantity updates, memory efficiency, and scalable, maintainable carts.

Learn how to boost cart performance by batching Redis commands with pipelines and enforcing all-or-nothing updates using atomic transactions, ensuring speed, consistency, and data integrity.

We review strings and hashes from the first project, then introduce lists, sets, and persistent patterns as we prepare for the second project, expanding our Redis toolkit.

Explore Redis lists, a simple yet powerful data type that stores a sequence of strings in insertion order, supports left and right pushes, and is created automatically on first use.

Insert elements at the left or right of a Redis list with lpush and rpush, then verify ordering using lrange and negative one to show all items.

Learn to read and remove items from a Redis list with lrange, lpop, and rpop, observe leftmost and rightmost removals, and note lists are linked-list-like with end pushes and pops.

Explore Redis blocking list operations like BLPOP and BRPOP to pause until data arrives, enabling simple queue coordination and efficient multi-list waiting.

Learn how to trim Redis lists in place using LTRIM to keep only the desired range, using positive or negative indexes, and handle edge cases to prevent memory bloat.

Explore how Redis handles sets, learn to add, remove, and check values, and manage multiple sets through simple, effective comparisons and combinations for clear, practical use.

Discover how Redis sets store unique strings, skip duplicates, and enable fast membership checks, while contrasting them with lists that preserve order and support indexing.

Learn how to add and remove members in a Redis set using sadd and srem, handle duplicates, and view the set's members, including behavior when sets are empty or non-existent.

Use sismember to test membership in a set, returning 1 for members and 0 otherwise; Redis stores values as strings and offers constant-time lookups.

Learn how to count set members in Redis with scard, including creating a set, adding elements, returning the size for existing keys, and handling non-existent keys or wrong types.

Learn how Redis sets can be compared and combined using union, sinter, and sdiff to find unique elements, overlaps, and differences across multiple sets, including empty or missing keys.

Build a real-time polling app with PostgreSQL for storage and Redis for fast in-memory voting, featuring a rest api, anonymous voting, session tracking, rate limiting, and flag-based, cache-driven availability.

Lay the groundwork for a real-time poll app with a dockerized environment, an express API with modular routes, and session support for anonymous users, plus swagger docs before Redis integration.

Quickly containerize a polling app using docker compose to wire up postgres, redis, and an express api with env files, port mappings, and prisma ui for development.

Bootstraps an express-based poll app by initializing a node project and creating a test api route to verify connectivity, with the app running in containers via docker compose.

Configure swagger UI to document and test your express API with auto-generated OpenAPI docs, syncing with code and serving interactive endpoints through a docs route.

Implement Redis-backed sessions with express-session to track voter participation in real-time polls, throttle votes, and enable future authentication workflows using session IDs stored in cookies.

Integrate Redis as the primary engine for voting logic, rate limiting, and duplicate prevention to deliver real-time performance and resilience.

Model a Postgres schema with Prisma, seed data, and expose a create poll API in a dockerized Express app, with Zod validation for poll input.

Implement an anonymous vote endpoint with Redice integration, using a Redice hash to store per-poll vote counts and atomic increments for fast, reliable voting in a node and express app.

Enforce one vote per session by creating a session and tracking voters with Redisai using session IDs on polls. This protects poll integrity without authentication and scales under load.

Track vote history in Redis by recording each vote into a history list with lpush and ltrim, maintaining a fixed 100-entry, ordered log via atomic pipelines.

Implement IP-based rate limiting for poll submissions using Redis; track per-IP counts with TTL, enforce ten requests per 60 seconds, and handle proxies via x-forwarded-for in Express middleware.

Apply a read-through cache with Redis and Postgres to ensure only active polls receive votes, using an is_active flag and a five-minute expiry.