17.7. Retry Strategies
Table of Contents
Why Retry Strategies Matter
In background processing, things often fail temporarily. A database might be momentarily overloaded, an email provider might return a 500 error, or a network link might drop for a second.
If you treat every error as permanent, you will lose work. If you treat every error as temporary and retry blindly, you can overload your own systems or external services.
A retry strategy is a set of rules that decide:
- When to retry a failed job.
- How many times to retry.
- How long to wait between retries.
- When to give up and mark the job as permanently failed.
A good strategy maximizes successful completion of tasks while avoiding overload and infinite loops.
A background system without a well‑defined retry strategy is a reliability risk. It can either lose important work or create retry storms that overload your own services and external APIs.
What Can Be Safely Retried?
Not every failure should be retried. Some are permanent and will never succeed, others are transient and might succeed later.
Transient vs Permanent Errors
Examples of transient errors (good candidates for retry):
- Temporary network failures (connection timeouts, DNS timeouts).
- HTTP 5xx responses from external services.
- Database “too many connections” or “deadlock detected” errors.
- Message broker temporarily unavailable.
Examples of permanent errors (usually do not retry):
- Invalid input that breaks validation.
- HTTP 4xx client errors like 400, 401, 403, 404, 422.
- Business rule violations, for example “user does not have enough balance.”
- Resource not found that will not appear later, for example “product id 123 does not exist” in a stable catalog.
In code, you usually:
- Classify exceptions into “retryable” and “non‑retryable.”
- Stop the retry loop immediately on non‑retryable errors.
- Only do backoff for retryable ones.
Example in Python‑style pseudocode:
class PermanentError(Exception):
pass
class TransientError(Exception):
pass
def process_job(job):
if not job.data_is_valid():
raise PermanentError("Invalid job data")
try:
external_service_call(job)
except TimeoutError as exc:
raise TransientError("Temporary network issue") from exc
The worker’s retry logic will treat PermanentError and TransientError very differently.
Basic Retry Parameters
Every retry strategy is defined by a few key parameters.
Maximum Number of Attempts
You almost always define a maximum number of attempts, including the first try.
For example:
max_attempts = 1means no retry, only one attempt.max_attempts = 3means 1 initial attempt plus up to 2 retries.max_attempts = ∞is usually a bad idea.
Never allow unlimited retries for a job. Always set a maximum number of attempts or a maximum total time window for retries.
Delay Between Attempts
You also define how long to wait before each retry:
- No delay, retry immediately.
- Fixed delay, for example always wait 10 seconds.
- Backoff delay, grow the wait time for each attempt.
Even a small delay reduces pressure on failing systems.
Fixed Delay Strategy
The simplest strategy is fixed delay.
- You set
max_attemptsand adelayin seconds. - After each failure, you wait exactly
delayseconds before trying again.
Example:
max_attempts = 5delay = 10seconds
Timeline:
Attempt | Result | Next retry in
--------|---------|---------------
1 | Fails | 10 s
2 | Fails | 10 s
3 | Fails | 10 s
4 | Fails | 10 s
5 | Fails | Stop
Pseudocode:
max_attempts = 5
delay = 10 # seconds
for attempt in range(1, max_attempts + 1):
try:
perform_task()
break
except TransientError as exc:
if attempt == max_attempts:
log_failure(exc)
break
sleep(delay)When fixed delay is useful:
- The remote system is rate limited but you know a safe delay.
- You want very simple, predictable behavior.
Downside:
- It does not reduce load quickly when many jobs fail together.
- It may still hammer a sick system too frequently.
Exponential Backoff
Exponential backoff increases the delay after each failure. Each retry waits longer than the previous one, typically doubling the wait time.
Common formula:
$$
\text{delay}_n = \text{base\_delay} \times 2^{(n - 1)}
$$
Where:
- $\text{delay}_n$ is the delay before the $n$‑th retry (not including the first attempt).
- $\text{base\_delay}$ is the initial delay in seconds.
Example with base_delay = 2 seconds, max_attempts = 5:
Attempt | Delay before this attempt | Comment
--------|---------------------------|--------
1 | 0 s | First attempt
2 | $2 \times 2^{0} = 2$ s | 2 seconds
3 | $2 \times 2^{1} = 4$ s | 4 seconds
4 | $2 \times 2^{2} = 8$ s | 8 seconds
5 | $2 \times 2^{3} = 16$ s | 16 seconds
Total waited time is $2 + 4 + 8 + 16 = 30$ seconds.
Pseudocode:
max_attempts = 5
base_delay = 2 # seconds
attempt = 1
while attempt <= max_attempts:
try:
perform_task()
break
except TransientError as exc:
if attempt == max_attempts:
log_failure(exc)
break
delay = base_delay * (2 ** (attempt - 1))
sleep(delay)
attempt += 1Benefits:
- Fast retries at first, since the issue may resolve quickly.
- Longer waits later, which reduces pressure on the failing system.
Exponential Backoff With Maximum Delay
Pure exponential backoff can grow too large. You usually add a maximum delay cap.
Always set a maximum backoff delay to avoid extremely long waits. For example, cap delays at 1 minute or 5 minutes.
Formula with cap:
$$
\text{delay}_n = \min\left(\text{base\_delay} \times 2^{(n - 1)}, \text{max\_delay}\right)
$$
Example:
base_delay = 2secondsmax_delay = 30seconds
Attempt | Raw delay | Capped delay
--------|-----------|-------------
1 | 0 | 0
2 | 2 | 2
3 | 4 | 4
4 | 8 | 8
5 | 16 | 16
6 | 32 | 30 (capped)
7 | 64 | 30 (capped)
Jitter: Avoiding Thundering Herds
If all workers use the same retry schedule, they may all retry at exactly the same times. This can cause a thundering herd effect: many clients hit a recovering service at once and keep it down.
Jitter is randomization added to the delay. Instead of sleeping exactly 10 seconds, you sleep a random duration around 10 seconds.
Common patterns:
- Full jitter: random delay between 0 and the computed backoff.
- Equal jitter: average between base and full jitter.
- Decorrelated jitter: uses previous delay in the formula.
A simple full jitter version:
$$
\text{delay}_n = \text{random}(0, \text{base\_delay} \times 2^{(n - 1)})
$$
Example with full jitter:
- Backoff value without jitter for attempt 3 is 4 seconds.
- With jitter, you pick a random value in
[0, 4], for example2.7seconds.
Pseudocode with full jitter:
import random
import time
max_attempts = 5
base_delay = 2 # seconds
max_delay = 30 # seconds
for attempt in range(1, max_attempts + 1):
try:
perform_task()
break
except TransientError as exc:
if attempt == max_attempts:
log_failure(exc)
break
# Exponential backoff with cap
backoff = base_delay * (2 ** (attempt - 1))
backoff = min(backoff, max_delay)
# Apply jitter
delay = random.uniform(0, backoff)
time.sleep(delay)Large systems often use some form of exponential backoff with jitter for external calls.
Time‑Based vs Attempt‑Based Limits
You can limit retries by:
- Number of attempts: for example
max_attempts = 5. - Total time: for example stop retrying after 15 minutes, regardless of attempts.
- Or a combination of both.
Example combined rule:
- Up to 10 attempts.
- Stop if the job is older than 1 hour.
Pseudocode:
MAX_ATTEMPTS = 10
MAX_AGE_SECONDS = 3600
def should_retry(job, attempt, error):
if attempt >= MAX_ATTEMPTS:
return False
if time.time() - job.created_at_timestamp > MAX_AGE_SECONDS:
return False
if isinstance(error, PermanentError):
return False
return TrueThis prevents stuck jobs that keep retrying for days.
Idempotency and Retries
When you retry a job, the code can run multiple times for the same logical operation. You must make sure retries do not create unwanted side effects.
An operation is idempotent if performing it multiple times has the same effect as performing it once.
Examples:
- Setting a user’s email to
"alice@example.com"is idempotent. Doing it twice has the same final state. - Charging a credit card
$10is not idempotent, because doing it twice charges$20.
For background jobs:
- Safe to retry: sending a notification that is designed to deduplicate, updating a record to a known value, upserting data.
- Dangerous to retry: blindly charging payments, creating duplicate orders, double sending irreversible messages.
To make non‑idempotent operations safer, you can:
- Use idempotency keys.
- Check whether an operation was already applied before applying it again.
- Design your data model to support upserts (
INSERT OR UPDATE).
Example: avoid double charging with an idempotency key:
def charge_user(user_id, amount, operation_id):
if payment_already_processed(operation_id):
return # Do nothing, this retry is safe
# perform actual charge
result = payment_gateway.charge(user_id, amount)
# store operation_id as processed
mark_payment_processed(operation_id, result)
If the job retries with the same operation_id, it will not charge again.
Never implement retries for non‑idempotent operations without an explicit strategy to avoid duplicate side effects.
Categorizing Failures for Retry
In a real system you often decide whether to retry based on error types, error codes, or HTTP status codes.
HTTP Based Decisions
Typical rules for calling external HTTP APIs:
Status | Retry? | Reason
-------|--------|-------
2xx | No | Request succeeded
4xx | No | Client or input error, fix the request instead
408 | Yes | Request timeout, usually transient
429 | Yes | Too many requests, back off and retry later
5xx | Yes | Server errors are usually transient
599 | Yes | Network timeout or proxy error
Example:
def should_retry_http(status_code: int) -> bool:
if 200 <= status_code < 300:
return False
if status_code == 408:
return True
if status_code == 429:
return True
if 500 <= status_code < 600:
return True
return FalseDatabase Based Decisions
For databases, you can retry some errors:
Retryable:
- Deadlocks.
- Connection timeouts.
- “Too many connections” (with backoff).
Not retryable:
- Unique constraint violations (duplicate key).
- Foreign key violations.
- Syntax errors.
You usually map database error codes to retryable / non‑retryable classifications.
Retry Strategies in Job Queues
Most background job systems and message queues have built‑in support for retries. You configure the strategy instead of writing all logic yourself.
Example: Simple Retry in a Worker
A generic worker pattern:
def worker_loop():
while True:
job = queue.pop()
attempt = job.attempts + 1
try:
process_job(job)
mark_done(job)
except TransientError as exc:
reschedule(job, attempt, exc)
except PermanentError as exc:
mark_failed(job, exc)
Where reschedule uses your strategy:
def reschedule(job, attempt, error):
delay = compute_delay(attempt)
if not should_retry(job, attempt, error):
mark_failed(job, error)
return
job.attempts = attempt
job.next_run_at = now() + delay
queue.push(job)Example Settings for a Real System
Here is a realistic configuration you might choose for sending emails:
Parameter | Value
------------------|-------
Max attempts | 8
Base delay | 5 seconds
Max delay | 15 minutes
Backoff | Exponential with jitter
Total time limit | 24 hours
Retry only on | Network errors and provider 5xx codes
For payment jobs you might choose something stricter:
Parameter | Value
------------------|-------
Max attempts | 4
Base delay | 10 seconds
Max delay | 5 minutes
Backoff | Exponential with jitter
Total time limit | 1 hour
Retry only on | Explicitly marked retryable errors from gateway
Idempotency key | Required per operation
Guardrails and Monitoring
Retries can hide problems. If every third attempt fails but retries succeed, users might not notice, but your system is under stress.
You need metrics and alerts:
- Count of retries per job type.
- Number of jobs that hit the maximum attempts.
- Average number of attempts before success.
- Delays between job creation and completion.
Example alerts:
- “More than 5% of jobs for
send_emailare reaching maximum retries.” - “Average attempts for
charge_paymentabove 1.5 for the last 10 minutes.”
Also consider circuit breakers (covered elsewhere in the course). If too many retries fail, you may temporarily stop sending new requests to a service, instead of endlessly retrying.
Practical Guidelines
To design a retry strategy for a new background task:
- Decide if the task is safe to retry.
- If not idempotent, design idempotency first.
- Identify retryable errors.
- Map exceptions and status codes to retryable / non‑retryable.
- Choose limits.
max_attemptsand possibly a total time limit.- Pick a delay pattern.
- For most cases, use exponential backoff with jitter and a max delay.
- Set clear failure behavior.
- Where do jobs go after final failure, for example a dead‑letter queue?
- Monitor and adjust.
- Start conservative, then tune based on real failure patterns.
If you apply these rules consistently, your background processing system will be both robust and gentle on the systems it depends on.
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!