17.4. Celery
Table of Contents
Why Use Celery?
Backend applications often need to perform work that is too slow or too heavy to run inside the normal HTTP request. Examples:
- Sending emails
- Generating PDFs
- Resizing images
- Importing or exporting large datasets
- Talking to slow external APIs
If you try to do these tasks inside the request handler, your API will feel slow and may even time out. You also cannot easily retry failures or spread work across multiple machines.
Celery is a Python library that solves this problem. It lets you:
- Send tasks to background workers
- Run tasks asynchronously
- Schedule tasks for later
- Retry failed tasks
- Distribute work across many worker processes or servers
Celery uses a message broker such as Redis or RabbitMQ to send jobs from your web app to worker processes.
Celery’s Core Concepts
To understand Celery, remember three main parts:
| Part | Role |
|---|---|
| Producer | Code that sends tasks, often your web application |
| Broker | Message system that stores tasks, for example Redis |
| Worker | Celery process that reads tasks from broker and executes them |
Celery also has some extra helpers:
- Result backend: optional storage system that remembers task results and status.
- Beat: a scheduler process that periodically creates tasks, for example every minute.
Key idea: Your web app sends tasks to the broker, workers process them in the background, and your app can continue handling requests without waiting.
Installing Celery
Celery is a Python package, so you usually install it into your virtual environment.
pip install celeryIf you want to use Redis as a broker and result backend:
pip install "celery[redis]"You will also need a running Redis or RabbitMQ instance. The details of installing Redis are in the Redis chapter, but a typical local development command (with Docker) might look like:
docker run -d -p 6379:6379 --name redis redis:7Creating a Basic Celery Application
Celery apps are usually defined in a file, often called celery_app.py or inside your main package.
A minimal setup using Redis as broker and result backend:
# celery_app.py
from celery import Celery
celery_app = Celery(
"my_app",
broker="redis://localhost:6379/0",
backend="redis://localhost:6379/1",
)
# optional configuration
celery_app.conf.update(
task_serializer="json",
result_serializer="json",
accept_content=["json"],
timezone="UTC",
enable_utc=True,
)Explanation:
"my_app"is just a name for this Celery instance.brokerURL tells Celery where to send and fetch tasks.backendURL tells Celery where to store task results.
You can keep these values in environment variables and read them from there, instead of hardcoding them.
Defining Celery Tasks
A Celery task is a normal Python function that is registered as a task. The simplest way is to use the @celery_app.task decorator.
# tasks.py
from time import sleep
from .celery_app import celery_app
@celery_app.task
def add(x, y):
sleep(2) # simulate slow work
return x + yYou can also define tasks with more control:
@celery_app.task(name="math.add", bind=True)
def add_bound(self, x, y):
# self is the task instance, you can access things like self.request.id
return x + ySome typical backend tasks:
@celery_app.task
def send_verification_email(user_id: int):
# lookup user in database
# generate verification link
# send email
return f"Verification email sent to user {user_id}"
@celery_app.task
def resize_image(image_id: str):
# load image from storage
# run resize operation
# save resized image
return f"Image {image_id} resized"Running Celery Workers
Once you have a Celery app and tasks, you need worker processes to execute them. In your project root:
celery -A celery_app.celery_app worker --loglevel=infoBreakdown:
-A celery_app.celery_apptells Celery to use thecelery_appobject incelery_app.py.workerstarts the worker process.--loglevel=infosets the log level.
If your Celery app is in a package, the path might look like:
celery -A myproject.celery_app.celery_app worker --loglevel=infoYou can control how many concurrent tasks a worker can process:
celery -A celery_app.celery_app worker --loglevel=info --concurrency=4This creates up to 4 worker processes or threads, depending on your pool configuration.
Calling Tasks Asynchronously
You do not call Celery tasks like normal functions if you want them to run in the background. Instead you call them through one of Celery’s methods.
The most common method is .delay():
from tasks import add
result = add.delay(2, 3) # returns immediately
print(result) # <AsyncResult: some-task-id>
You can also use .apply_async() for more control:
result = add.apply_async(
args=[2, 3],
countdown=10, # run after 10 seconds
)Typical usage inside a web endpoint:
def create_user(user_data):
user = save_user_to_db(user_data)
# send email in background
send_verification_email.delay(user.id)
return {"message": "User created, verification email will be sent"}The HTTP response is sent immediately. The Celery worker will handle the email later.
Checking Task Results and Status
If you have a result backend configured, every async call returns an AsyncResult object. It lets you check the task state and result.
result = add.delay(2, 3)
# check status
print(result.id) # task id
print(result.state) # PENDING, STARTED, SUCCESS, FAILURE, etc.
# wait for completion (blocks)
value = result.get(timeout=10)
print(value) # 5Useful properties and methods:
| Property / Method | Meaning |
|---|---|
result.id | Unique ID of this task |
result.state | Current state, for example SUCCESS |
result.ready() | Returns True if completed |
result.successful() | Returns True if completed successfully |
result.get() | Returns result or raises error |
In real APIs, you often:
- Start a long-running job, return its
task_idto the client. - Provide another endpoint that checks the status of a task by id.
Retrying and Handling Failures
Celery has built-in support for retries. For example, when talking to flaky external services you may want to retry a few times.
To use retries, define a bound task with bind=True and call self.retry.
from celery.utils.log import get_task_logger
from .celery_app import celery_app
logger = get_task_logger(__name__)
@celery_app.task(bind=True, max_retries=3, default_retry_delay=5)
def call_external_api(self, url: str):
try:
# for example only, use requests or httpx in real code
if some_random_failure_condition():
raise ConnectionError("Temporary failure")
return "ok"
except Exception as exc:
logger.warning("API call failed, retrying...")
raise self.retry(exc=exc)Explanation:
max_retries=3means Celery will try up to three times.default_retry_delay=5waits 5 seconds between attempts.self.retry(...)raises a special exception that tells Celery to schedule a retry.
You can also configure retry settings when calling the task:
call_external_api.apply_async(
args=["https://example.com"],
retry=True,
retry_policy={
"max_retries": 5,
"interval_start": 0,
"interval_step": 2,
"interval_max": 10,
},
)Scheduling Tasks and Celery Beat
Sometimes you need to run tasks periodically, for example:
- Clean up expired sessions every hour
- Send daily summary emails
- Refresh cached data every 5 minutes
You can treat periodic tasks as background jobs that are triggered on a schedule. Celery provides Celery Beat, a scheduler process that creates tasks at defined intervals.
A simple in-code schedule:
# celery_app.py
from celery import Celery
from celery.schedules import crontab
celery_app = Celery(
"my_app",
broker="redis://localhost:6379/0",
backend="redis://localhost:6379/1",
)
celery_app.conf.beat_schedule = {
"cleanup-every-hour": {
"task": "tasks.cleanup_temp_files",
"schedule": crontab(minute=0), # at every hour
},
"ping-every-10-seconds": {
"task": "tasks.ping",
"schedule": 10.0, # seconds
},
}Tasks:
# tasks.py
from .celery_app import celery_app
@celery_app.task
def cleanup_temp_files():
# delete temporary files, expired tokens, etc.
return "cleanup done"
@celery_app.task
def ping():
print("ping")Start beat in one process and worker in another:
# Terminal 1: worker
celery -A celery_app.celery_app worker --loglevel=info
# Terminal 2: beat
celery -A celery_app.celery_app beat --loglevel=infoBeat sends scheduled tasks to the broker. The worker executes them.
Configuring Celery
Celery has many configuration options. You can set them through celery_app.conf.update(...) or by using a dedicated config module.
Common configuration examples:
celery_app.conf.update(
broker_url="redis://localhost:6379/0",
result_backend="redis://localhost:6379/1",
task_serializer="json",
result_serializer="json",
accept_content=["json"],
timezone="UTC",
enable_utc=True,
# task routes
task_routes={
"tasks.send_email": {"queue": "emails"},
"tasks.generate_report": {"queue": "reports"},
},
# visibility timeout with Redis broker
broker_transport_options={"visibility_timeout": 3600},
)You can route different tasks to different queues and start workers that only handle specific queues:
celery -A celery_app.celery_app worker -Q emails --loglevel=infoCommon Celery Patterns in Backend Apps
Here are some realistic patterns that you will often use.
1. Fire-and-forget
You do not care about the result, you only want the task to run later.
send_verification_email.delay(user_id)2. Start job, poll for status
You start a long job and return its ID, then the client checks on it.
# start job
result = generate_report.delay(report_params)
return {"task_id": result.id}
# check job
from celery.result import AsyncResult
def get_task_status(task_id: str):
res = AsyncResult(task_id, app=celery_app)
return {"state": res.state}3. Chaining tasks
You want tasks to run one after another.
from celery import chain
from tasks import upload_file, process_file, notify_user
workflow = chain(
upload_file.s("/path/to/file"),
process_file.s(),
notify_user.s(user_id),
)
workflow.delay()4. Parallel tasks and joining results
Run multiple tasks in parallel, then process all results.
from celery import group
from tasks import resize_image, create_thumbnail
job = group(
resize_image.s("image1"),
resize_image.s("image2"),
create_thumbnail.s("image1"),
)
result = job.apply_async()
all_results = result.get() # list of individual resultsBasic Celery Project Structure Example
Here is a simple directory layout including Celery and a web backend:
myproject/
app/
__init__.py
main.py # your FastAPI / Flask app
celery_app.py # Celery instance
tasks.py # Celery tasks
requirements.txt
celery_app.py:
from celery import Celery
celery_app = Celery(
"myproject",
broker="redis://localhost:6379/0",
backend="redis://localhost:6379/1",
)
celery_app.autodiscover_tasks(["app"])
tasks.py:
from .celery_app import celery_app
@celery_app.task
def send_welcome_email(user_id: int):
# lookup user, send email
return f"Welcome email sent to user {user_id}"
Your web handler in main.py:
from fastapi import FastAPI
from .tasks import send_welcome_email
app = FastAPI()
@app.post("/register")
def register_user():
# create user in database
user_id = 42 # example
send_welcome_email.delay(user_id)
return {"message": "User registered"}Best Practices When Using Celery
Some important rules that help you avoid common problems:
- Do not pass huge objects or database models as task arguments, pass IDs or small data instead.
- Keep tasks small and focused, a task should ideally do one thing.
- Handle expected errors and use retries for temporary failures.
- Use environment variables for broker and backend configuration.
- Separate queues for different kinds of work if you have many tasks.
- Monitor your Celery workers and queues in production.
Following these practices helps keep your background processing reliable and easier to debug.
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!