16.2. Application Caching
Table of Contents
Why Application Caching Matters
Application caching is the technique of storing the result of expensive work so that you can reuse it instead of doing the work again.
In backend development this usually means:
- Storing computed data in memory instead of recomputing it
- Storing frequently requested database results so you do not hit the database every time
- Storing prepared responses so you can send them back very quickly
Caching can drastically reduce:
- Response times
- Database load
- CPU usage
and can often delay or avoid the need for expensive infrastructure scaling.
Key idea: Cache what is expensive to do and cheap to store.
Example situation:
- An endpoint
/reports/dailyruns 10 SQL queries and some heavy calculations - It takes 2 seconds to run
- Users might hit it hundreds of times per hour
- The underlying data only changes once every 10 minutes
In this case it is very effective to compute the report once, cache the result for 10 minutes, and serve the cached result for all other requests during that time.
Types of Application Caches
Application caching happens inside or very close to your backend application. Common types:
| Type | Where stored | Typical scope |
|---|---|---|
| In‑process / in‑memory | Inside app process RAM | Single instance |
| Shared cache (Redis, etc.) | Separate cache service | Multiple instances / whole cluster |
| Local on-disk cache | Local disk / filesystem | Single server |
HTTP caching is covered separately in the HTTP Caching chapter. Here we focus on what your application code controls directly.
In‑Process / In‑Memory Cache
This is the simplest form of application caching.
- Data is stored in variables or in an in‑memory structure inside your app
- When the app process restarts, the cache is lost
- Each app instance has its own separate cache
Example in Python:
product_cache = {} # simple in‑memory cache
def get_product(product_id: int):
if product_id in product_cache:
return product_cache[product_id] # cached value
product = query_product_from_database(product_id) # expensive
product_cache[product_id] = product
return productThis is fast and easy, but it does not work well when you have many application instances, because each instance has its own copy of the cache.
Shared Cache (Using Redis or Similar)
A shared cache is a separate service, such as Redis, that all your application instances talk to.
- All instances can read and write the same cache keys
- When you add more app servers, they all share the same cache
- Cache can survive application restarts, as long as the cache server is running
Example pattern:
Client -> Your app -> Redis (cache) -> Database- App checks Redis for cached value
- If found, use that value
- If not found, query the database, store result in Redis, and return it
Shared caches are the most common choice in production systems.
What to Cache in Your Application
You should not cache everything. Cache the things that:
- Are expensive to compute or retrieve
- Are requested often
- Do not change very frequently
Common examples:
| What | Why cache it? |
|---|---|
| Product catalog | Many reads, few writes |
| User profiles (public data) | Often shown, not updated on every request |
| Configuration / feature flags | Rarely change, used in many places |
| Computed statistics | Expensive aggregation queries |
| HTML templates after rendering | For non personal content |
Avoid Caching Highly Dynamic or Personal Data
Data that changes very often or is specific to each user is usually a poor cache candidate, unless you control it carefully.
Examples:
- A stock price that updates every second
- A personal dashboard with live notifications
- A one‑time password or login code
You might still cache parts of such data, for example, the list of products that is the same for everyone, and then add per user data on top of it without caching.
Cache-aside Pattern (The Most Common Pattern)
The most used pattern in application caching is called cache‑aside.
The algorithm is:
- Check the cache for the value
- If it exists, return it
- If it does not exist, fetch from the original source (usually database)
- Store the new value in the cache
- Return the value
Cache-aside rule:
Application reads first from cache. On miss, read from database and then write to cache.
Example of Cache-aside in Python
Imagine you want to cache user profiles by user id.
import json
from typing import Optional
import redis
r = redis.Redis(host="localhost", port=6379, db=0)
def get_user_from_db(user_id: int) -> dict:
# very simplified example
# in a real app you'd use an ORM like SQLAlchemy
return {"id": user_id, "name": "Alice", "age": 30}
def get_user(user_id: int) -> Optional[dict]:
cache_key = f"user:{user_id}"
cached = r.get(cache_key)
if cached is not None:
return json.loads(cached)
# cache miss
user = get_user_from_db(user_id)
if user is None:
return None
# write to cache with expiration of 1 hour (3600 seconds)
r.setex(cache_key, 3600, json.dumps(user))
return userThis code:
- Tries Redis first
- If no cached value, hits the database
- Stores the result back into Redis with expiration
Time-to-Live (TTL) and Expiration
Every cache entry should have a lifetime. This is how long the entry is considered valid.
TTL is usually expressed in seconds, for example:
- 60 seconds for very dynamic content
- 300 seconds (5 minutes) for frequently updated but not critical data
- 3600 seconds (1 hour) or more for mostly static data
Important rule:
Never rely on the cache as the only source of truth. Always be ready to reload from the database or original source when cache entries expire or are missing.
Example: Setting a TTL in Redis
# cache for 10 minutes
r.setex("config:homepage", 600, json.dumps(config))Choosing TTL Values
Use these rough guidelines:
| Data type | Suggested TTL |
|---|---|
| Feature flags, configs that rarely change | 10 minutes to 24 hours |
| Product catalog | 5 to 60 minutes |
| Home page blocks / marketing banners | 1 to 15 minutes |
| Dashboard statistics | 30 seconds to 5 minutes |
| OAuth tokens | Same as token lifetime |
TTL choice is always a trade‑off between performance and freshness.
Cache Keys and Namespacing
A cache key is a string that identifies one cached value.
Typical structure:
<namespace>:<resource_type>:<identifier>Examples:
user:profile:123product:details:42stats:dashboard:globalconfig:feature_flags:v1
Why Namespaces Matter
Namespaces make it easy to:
- Avoid key collisions
- Group related keys
- Clear groups of keys when data is updated
For example, if all your product related keys start with product:, you can delete them using a pattern when product data changes.
Cache Invalidation Basics
Cache invalidation is the process of removing or updating cached data when the underlying data changes.
It is the hardest part of caching, because:
- If you forget to invalidate, users see stale data
- If you invalidate too often, you lose the performance benefit
There are three basic strategies:
- TTL based
Let the cache expire automatically after a certain time. - Write-through / write-behind
Update both cache and database when data changes. - Explicit invalidation
When updating data in the database, also delete or update related cache keys.
Example: Explicit Invalidation
Imagine you cache product:details:<id> and you have an API to update products.
def update_product(product_id: int, data: dict) -> dict:
updated = update_product_in_db(product_id, data)
# Invalidate related cache
cache_key = f"product:details:{product_id}"
r.delete(cache_key)
return updatedNext time a client asks for the product, the cache will miss, and your app will fetch the fresh data from the database and store it again in the cache.
Cache Hit and Cache Miss
Two important terms:
- Cache hit, the value was found in the cache
- Cache miss, the value was not found, you have to load it from the original source
You want a high hit rate, but not necessarily 100 percent. Sometimes it is fine that some requests go to the database, as long as your system stays fast and stable.
You can calculate hit rate like this:
$$
\text{hit\_rate} = \frac{\text{hits}}{\text{hits} + \text{misses}}
$$
Remember:
Caching only helps when the hit rate is high enough to reduce the real load on your database or service.
Function-level Caching (Memoization)
You can cache the results of function calls based on their arguments. This pattern is called memoization.
A simple example in Python using functools.lru_cache:
from functools import lru_cache
@lru_cache(maxsize=1024)
def fibonacci(n: int) -> int:
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)This is very helpful for:
- Pure functions where output depends only on inputs
- Repeated computations inside your application process
In web backends, this is often used for:
- Loading configuration from disk or environment
- Parsing large static files
- Transforming reference data that does not change during runtime
Caching Database Queries
Many backend bottlenecks come from heavy or frequently used database queries.
A common pattern is:
- Build a cache key from the query parameters
- Check the cache before running the query
- Cache the result if it is not in the cache
Example: Caching a List of Products
Imagine an endpoint /products?category=phone&page=1.
You might build the key like this:
def build_product_list_key(category: str, page: int, page_size: int) -> str:
return f"product:list:category={category}:page={page}:size={page_size}"And then:
def list_products(category: str, page: int, page_size: int = 20):
cache_key = build_product_list_key(category, page, page_size)
cached = r.get(cache_key)
if cached:
return json.loads(cached)
# expensive DB query
products = query_products_from_db(category, page, page_size)
r.setex(cache_key, 60, json.dumps(products)) # cache for 1 minute
return productsNotice that the function includes all relevant parameters in the cache key. This is very important, otherwise you might return results for the wrong query.
Caching Partial Responses
Sometimes you do not want to cache an entire API response, because it depends on a mix of static and dynamic data.
For example, an article page might include:
- The article body and title, which barely change
- A view count, which changes often
- A personalized recommendation list
A good approach is:
- Cache the article data by article id
- Fetch the view count and recommendations separately, without caching or with shorter TTL
- Combine them in the response
This gives you a large performance win while keeping dynamic parts fresh.
Dealing With Stale Data
Cached data is almost always slightly out of date. You must decide how much staleness is acceptable.
Options:
- Strong freshness, always fetch from the source when something changes, and immediately update or invalidate the cache.
- Eventual consistency, allow cached data to be a bit old for a defined period, like 1 or 5 minutes.
For many use cases, eventual consistency is fine. For example:
- Product price changes might take 1 minute to appear everywhere
- Blog post edits might take a few seconds to update on the public page
For very sensitive data, like balances in a banking system, you might avoid caching entirely or use very careful designs that combine transactions and cache updates.
Cache Warmup and Cold Starts
When your application or cache server starts and the cache is empty, you have a cold cache. This can cause a spike in load on your database, because every request is a cache miss at first.
To avoid this, sometimes you:
- Run a script that preloads important cache keys at startup
- Slowly ramp up traffic to a new deployment, instead of all at once
Example warmup script:
def warmup_cache():
# preload popular products
for product_id in [1, 2, 3, 4, 5]:
product = get_product_from_db(product_id)
r.setex(f"product:details:{product_id}", 3600, json.dumps(product))When Not to Use Application Caching
Caching is powerful, but not always appropriate.
Avoid or be very careful with caching when:
- You need strong consistency, for example, financial transactions and balances
- Data changes very frequently and is almost never read twice in a short time
- The cost of recomputing is very low compared to the complexity of caching
- Security or privacy concerns make storing data in a cache risky
In many small projects, you can start without caching, measure performance, and add caching only where it clearly helps.
Practical Guidelines for Application Caching
To use application caching effectively, keep these principles in mind:
- Start with measurement
Find slow endpoints or high load queries before adding caches. - Cache only what matters
Focus on the top 10 to 20 percent of operations that cause most of the load. - Choose clear cache keys
Use namespaces and include all relevant parameters in the key. - Always set an expiration
Do not store data in the cache forever, unless you know exactly why. - Plan invalidation
Decide how and when to clear or update caches when data changes. - Monitor hit rate
Track how often cache is used. If hit rate is low, your cache design might not be effective. - Keep the database the source of truth
Treat cache as a helper, not a replacement for your primary storage.
By following these guidelines, you will be able to add application caching to your backend in a safe and effective way, and you will avoid many common pitfalls such as stale data, inconsistent behavior, or wasted complexity.
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!