16.3.3. Keys and Values
Table of Contents
Understanding Keys and Values in Redis
Redis is a key value store, so everything starts with understanding what a key is and what a value is. Even when you later work with lists, sets, hashes, and more complex data, they are still stored under keys.
In this chapter you will learn how keys and values work in Redis, how to choose good keys, and how to store and retrieve data.
What Is a Key in Redis?
A key in Redis is a string that uniquely identifies a piece of data. You can think of it as a variable name or as a row primary key in a database, but it is always a string.
Some examples of valid keys:
"user:1"
"session:abc123"
"cart:42"
"config:site_name"
"counter:visits"Keys:
- Are always strings internally, even if they look like numbers.
- Point to one value each.
- Must be unique in a given Redis database.
If you set the same key again, you overwrite the old value.
Basic rule:
Each Redis key maps to exactly one value at a time.
What Is a Value in Redis?
A value is the data stored under a key. In Redis, values can be of different types, such as:
- Simple string (text or binary data)
- List
- Set
- Sorted set
- Hash
- Stream
- Other specialized types
In this chapter we focus on the idea of key and value in general, and especially on string values, since many commands work with strings.
Examples:
- Key
"username:1"→ Value"alice" - Key
"counter:page_views"→ Value"1032" - Key
"image:logo"→ Value is binary image data - Key
"config:maintenance_mode"→ Value"true"
Even numbers are stored as strings by default. Redis can interpret some string values as integers for operations like INCR, but they are still stored as strings.
Basic Key Value Commands
The most important commands for simple key value operations are:
SET: Store a Value
SET saves a value under a key.
SET user:1:name "Alice"
SET user:1:age "30"- If
user:1:namedoes not exist, Redis creates it. - If it already exists, Redis overwrites its value.
You can also store numbers as strings:
SET counter:visits "0"GET: Retrieve a Value
GET returns the value stored under a key.
GET user:1:name
# "Alice"
GET user:1:age
# "30"
If the key does not exist, GET returns a special null reply:
GET user:2:name
# (nil) (means "no value")EXISTS: Check If a Key Exists
EXISTS tells you if a key is present.
EXISTS user:1:name
# (integer) 1 (exists)
EXISTS user:2:name
# (integer) 0 (does not exist)DEL: Delete Keys
DEL removes one or more keys and their values.
DEL user:1:name
DEL user:1:age
DEL returns how many keys were removed:
DEL user:1:name user:1:age
# (integer) 2If you delete a key, the value is gone and memory is freed.
Key Naming Conventions
Choosing good key names is very important in Redis. There are no tables or schemas, so key names are your main way to organize data.
Common Pattern: Use `:` as a Separator
Most Redis users follow a convention similar to:
<namespace>:<object_type>:<id>:<field>Examples:
user:1:nameuser:1:emailuser:2:emailsession:abc123:user_idcart:42:itemsorder:2024-0001:status
This is not mandatory, but it makes keys:
- Easier to understand.
- Easier to list and search with patterns.
- More consistent across your code.
Examples of Good vs Bad Key Names
| Purpose | Good key name | Bad key name | Why good? |
|---|---|---|---|
| User name for id 1 | user:1:name | name1 | Clear model and id |
| User email for id 12 | user:12:email | u12e | Easy to read, no guesswork |
| Shopping cart for user 5 | cart:user:5 | cart5 | Contains both cart and user in name |
| Global page view counter | counter:page_views | pv | Indicates purpose clearly |
| Feature flag: new_checkout | feature:new_checkout | flag1 | Meaningful name, easy to search/filter |
Avoiding Key Collisions
If you mix different types of data, you must name keys carefully to avoid collisions.
Bad:
SET user:1 "Alice"
SET user:1 "something else" # Overwrites the previous valueBetter:
SET user:1:name "Alice"
SET user:1:age "30"Or store structured data under a single key using another type (this is covered in the data structures chapter).
Key Length and Limits
Redis allows keys up to 512 MB in length, but you should not use very long keys.
Practical guidelines:
- Keep keys short but meaningful.
- Avoid putting entire texts, JSON objects, or long URLs directly in keys.
- Put such data in the value, not the key.
Bad:
"user:{"id":1,"name":"Alice","email":"alice@example.com"}"Good:
"user:1"Where the value contains the data (as a string, JSON, hash, etc).
Working With Numeric Values
Even though Redis stores values as strings, you often want to work with numbers. Redis provides atomic operations for integer values.
INCR and DECR
INCR increases a numeric value by 1. Redis interprets the value as an integer.
SET counter:visits "0"
INCR counter:visits
# (integer) 1
INCR counter:visits
# (integer) 2
GET counter:visits
# "2"
DECR decreases by 1:
DECR counter:visits
# (integer) 1
**The value must be a valid integer string, such as "0", "42", or "-5".
If the value is not an integer string, commands like INCR will fail.**
Example of an error:
SET counter:visits "hello"
INCR counter:visits
# (error) ERR value is not an integer or out of rangeINCRBY and DECRBY
You can change a numeric value by more than 1:
SET counter:downloads "10"
INCRBY counter:downloads 5
# (integer) 15
DECRBY counter:downloads 3
# (integer) 12Example: Implementing a Simple Page View Counter
Imagine you want to count how many times a page is viewed.
Each time a user opens the page:
INCR counter:page:homeTo display the count:
GET counter:page:home
# "123"
In code (Python with redis-py style client):
import redis
r = redis.Redis(host="localhost", port=6379, db=0)
def track_page_view(page_id: str) -> int:
key = f"counter:page:{page_id}"
new_value = r.incr(key) # INCR command
return new_value
views = track_page_view("home")
print("Home page views:", views)Key Expiration and Temporary Values
Sometimes you want a key to exist only for a limited time, for example for a login session, a password reset token, or a cache entry.
Redis supports key expiration. After a certain time, the key is automatically deleted.
SET with EX
You can set a key with a time to live in seconds:
SET session:abc123 "user:1" EX 60
This creates session:abc123 which will live for 60 seconds.
After 60 seconds:
GET session:abc123
# (nil)
You can use PX for milliseconds:
SET temp:code "123456" PX 300000 # 5 minutesEXPIRE Command
You can set or change expiration after creating a key:
SET session:abc123 "user:1"
EXPIRE session:abc123 120 # 120 seconds
EXPIRE returns 1 if the timeout was set, 0 if the key does not exist.
Check remaining time to live with TTL:
TTL session:abc123
# (integer) 97 (seconds left)
**When a key expires, it is automatically deleted and cannot be recovered.
Always handle the case where an expected key no longer exists.**
Listing and Searching Keys
For learning and testing, you might want to see what keys exist.
KEYS (for development only)
KEYS lets you search for keys that match a pattern:
KEYS *
# lists all keys
KEYS "user:*"
# lists all keys starting with "user:"
KEYS "session:*:user*"
# lists keys matching the patternPatterns use glob style wildcards:
| Pattern | Meaning |
|---|---|
* | Match any number of characters |
? | Match any single character |
[abc] | Match any one character in the set |
However:
**Never use KEYS in production on large databases.
It can block Redis while scanning all keys.
Use SCAN instead for production systems.**
SCAN is more advanced and covered elsewhere. For now, just know that KEYS is fine for a small local instance when learning.
Overwriting and Replacing Values
Since each key maps to one value, if you call SET multiple times with the same key, Redis always stores the latest value.
Example:
SET user:1:name "Alice"
GET user:1:name
# "Alice"
SET user:1:name "Bob"
GET user:1:name
# "Bob"You can also control overwriting behavior:
SETNX: Set Only If Not Exists
SETNX means "SET if Not eXists":
SETNX config:site_name "MySite"
# (integer) 1 (key created)
SETNX config:site_name "OtherSite"
# (integer) 0 (key already exists, not changed)
GET config:site_name
# "MySite"This is useful when you want to initialize settings or create locks without overwriting existing data.
Practical Key and Value Patterns
1. Caching Example
Imagine you have a slow database query to get a product by id.
You can cache the result:
- Key:
cache:product:<id> - Value: JSON representation of the product
- Expiration: 60 seconds
Commands:
SET cache:product:42 '{"id":42,"name":"Phone","price":299}' EX 60
GET cache:product:42In code:
def get_product_cached(product_id: int):
key = f"cache:product:{product_id}"
cached = r.get(key)
if cached is not None:
return cached # in real code, decode JSON
# simulate slow database query
product = {"id": product_id, "name": "Phone", "price": 299}
r.set(key, json.dumps(product), ex=60)
return product2. Session Example
For user sessions after login:
- Key:
session:<session_id> - Value: user id or serialized session data
- Expiration: lifetime of the session
SET session:abc123 "user:1" EX 3600
GET session:abc123
# "user:1"3. Feature Flags Example
To control features in your app:
- Key:
feature:<feature_name> - Value:
"on"or"off", or"true"and"false"
SET feature:new_checkout "on"
GET feature:new_checkout
# "on"Inspecting Key Types
As mentioned, Redis values can be different types. To see the type of a given key, use TYPE:
SET user:1:name "Alice"
TYPE user:1:name
# string
LPUSH user:1:logins "2024-01-01"
TYPE user:1:logins
# listThis is useful when debugging your data model.
**Do not mix different types under the same key.
If a key is used as a string, do not later use list commands on it.
Always keep one key associated with one consistent type.**
Summary
In Redis, everything starts with keys and values:
- A key is a string that uniquely identifies a single value.
- A value can be a simple string or a complex data type.
- Use
SET,GET,DEL,EXISTSto manage basic key value pairs. - Use clear and consistent key naming conventions, often with
:as a separator. - Keys are always strings, and values are often strings, even when representing numbers.
- Use
INCR,DECR,INCRBY,DECRBYto handle numeric values safely. - Use expirations (
EX,PX,EXPIRE) for temporary data. - Be careful with
KEYSin production, and avoid changing types for existing keys.
With these basics, you can model many common backend problems, such as counters, sessions, and caches, using Redis keys and values.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!