8.8. Background Tasks
Table of Contents
Why Background Tasks Matter in FastAPI
In many backend applications you need to do work that should not block the response to the client. Examples:
- Sending a confirmation email after user registration
- Writing analytics logs to another service
- Generating reports or thumbnails
- Notifying other services through webhooks
If you do all of this inside the request handler, the user waits for everything to finish. Background tasks let you send the HTTP response first, and then run extra work in the background inside the same FastAPI process.
FastAPI has a built‑in feature for simple background jobs, called BackgroundTasks. It is different from full message queue systems like Celery, but very useful for lightweight tasks.
In this chapter you will learn how to:
- Define and register background tasks
- Use them correctly with path operations
- Pass parameters to them
- Handle errors and logging
- Understand when you should use a real worker system instead
The `BackgroundTasks` Object
FastAPI provides a special class BackgroundTasks in fastapi. You can use it as a dependency argument in your path operation function.
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
You do not create it yourself. FastAPI creates and injects it when you declare it as a parameter, similar to how it injects Request or Depends.
Basic pattern:
from fastapi import BackgroundTasks
def my_background_function():
print("Doing something after response...")
@app.post("/do-something")
def do_something(background_tasks: BackgroundTasks):
background_tasks.add_task(my_background_function)
return {"status": "queued"}
The line background_tasks.add_task(...) registers work that will be executed after the response is sent to the client.
Creating Background Tasks
Defining a Task Function
A background task is usually a normal Python function. It can be sync or async.
Simple synchronous example:
def write_log(message: str):
with open("activity.log", "a") as f:
f.write(message + "\n")Now use it as a background task:
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
@app.post("/log")
def log_activity(background_tasks: BackgroundTasks, message: str):
background_tasks.add_task(write_log, f"User said: {message}")
return {"detail": "Message received. Log will be written."}The request finishes immediately. The file write happens in the background.
Async Background Functions
You can also use an async function:
import httpx
async def notify_webhook(url: str, data: dict):
async with httpx.AsyncClient() as client:
await client.post(url, json=data)
@app.post("/send-webhook")
async def send_webhook(background_tasks: BackgroundTasks):
payload = {"event": "user_signup", "user_id": 123}
background_tasks.add_task(
notify_webhook,
"https://example.com/webhook",
payload
)
return {"detail": "Webhook scheduled"}FastAPI will await the async function in the background context after the response.
Using `BackgroundTasks` in Path Operations
Adding Tasks with Arguments
add_task accepts:
- The callable (function) as first argument
- Any positional and keyword arguments that should be passed to it
Example with multiple parameters:
def send_email(to: str, subject: str, body: str, *, html: bool = False):
# pretend to send email
print(f"Sending email to {to}, subject={subject}, html={html}")
@app.post("/register")
def register_user(
background_tasks: BackgroundTasks,
email: str
):
# here you would create the user in the database...
background_tasks.add_task(
send_email,
email,
"Welcome!",
"Thanks for registering.",
html=True
)
return {"detail": "User created. Welcome email will be sent."}Important points:
- Use normal function calls for the task function itself, not
send_email()directly - Pass any parameters to
add_taskjust like you would call the function
Multiple Background Tasks
You can add more than one background task in a single request.
def log_registration(user_id: int):
print(f"User {user_id} registered")
def send_welcome_email(email: str):
print(f"Sending welcome email to {email}")
@app.post("/signup")
def signup(
background_tasks: BackgroundTasks,
email: str
):
user_id = 42 # example, normally from DB
background_tasks.add_task(log_registration, user_id)
background_tasks.add_task(send_welcome_email, email)
return {"detail": "Signup complete"}Every registered task will be executed once the response has been sent.
Using `BackgroundTasks` with Dependencies
You can also use BackgroundTasks inside dependency functions. This is useful when some shared behavior needs a background job.
from fastapi import Depends
def log_request(background_tasks: BackgroundTasks):
def _log():
with open("requests.log", "a") as f:
f.write("Request received\n")
background_tasks.add_task(_log)
@app.get("/items", dependencies=[Depends(log_request)])
def list_items():
return [{"id": 1}, {"id": 2}]Here the endpoint does not know about the logging. The dependency adds a background task to log each request.
Common Use Cases
1. Sending Emails After an Action
Typical pattern: user registers, you send them a welcome email without making them wait.
def send_confirmation_email(email: str, confirmation_link: str):
# Imagine this is slow (SMTP server, templates, etc.)
print(f"Email to {email}: click {confirmation_link}")
@app.post("/users")
def create_user(background_tasks: BackgroundTasks, email: str):
# Save user to DB here...
confirmation_link = f"https://example.com/verify?email={email}"
background_tasks.add_task(
send_confirmation_email,
email,
confirmation_link
)
return {"detail": "User created. Please check your email."}2. Writing Logs or Audit Records
If logging to a file or external service is slow, move it to a background task.
def write_audit_log(action: str, user_id: int | None):
with open("audit.log", "a") as f:
f.write(f"user={user_id}, action={action}\n")
@app.post("/payment")
def process_payment(
background_tasks: BackgroundTasks,
user_id: int,
amount: float,
):
# process payment...
background_tasks.add_task(write_audit_log, "payment", user_id)
return {"detail": "Payment accepted"}3. Calling External APIs
If your backend needs to inform other systems about events, use background tasks so the user does not wait for those external calls.
import httpx
async def notify_analytics(user_id: int, event: str):
url = "https://analytics.example.com/events"
async with httpx.AsyncClient() as client:
await client.post(url, json={"user_id": user_id, "event": event})
@app.post("/purchase")
async def create_purchase(
background_tasks: BackgroundTasks,
user_id: int,
product_id: int
):
# create purchase record...
background_tasks.add_task(
notify_analytics,
user_id,
"purchase_created"
)
return {"detail": "Purchase created"}4. Post Processing Uploaded Files
Example, generating thumbnail images after upload.
from pathlib import Path
from fastapi import File, UploadFile
def generate_thumbnail(path: Path):
# Here you might use Pillow or another library
print(f"Generating thumbnail for {path}")
@app.post("/upload-image")
async def upload_image(
background_tasks: BackgroundTasks,
file: UploadFile = File(...)
):
file_location = Path("uploads") / file.filename
with file_location.open("wb") as f:
f.write(await file.read())
background_tasks.add_task(generate_thumbnail, file_location)
return {"detail": "Image uploaded. Thumbnail will be generated."}Error Handling and Logging in Background Tasks
Background tasks run after the HTTP response is sent. If they fail, the client does not see that error in the same request.
Important:
- Exceptions in background tasks do not change the HTTP response that was already sent.
- You must handle errors inside the task function and log them.
Basic Error Handling
Wrap background code in try/except:
import logging
logger = logging.getLogger(__name__)
def safe_send_email(to: str, subject: str, body: str):
try:
# pretend to send email
print(f"Sending email to {to}")
# raise RuntimeError("SMTP error") # for testing
except Exception as exc:
logger.error("Error sending email to %s: %s", to, exc)Use this safer function as the background task:
@app.post("/notify")
def notify_user(background_tasks: BackgroundTasks, email: str):
background_tasks.add_task(
safe_send_email,
email,
"Notification",
"Something happened"
)
return {"detail": "Notification scheduled"}When You Need Reliability
Background tasks in FastAPI:
- Run in the same process as the app
- Are lost if the process stops or crashes before they run
- Do not persist in a queue or database
So they are best for tasks that are:
- Optional (logging, metrics, notifications)
- Short lived
- Not critical to complete with 100% reliability
For critical work, you usually need a real background worker system with a message queue (for example Celery + Redis or RabbitMQ). That topic is covered in another part of this course.
Lifecycle and Limitations
When Do Tasks Run?
FastAPI executes background tasks at the end of each request cycle:
- Your path operation runs
- FastAPI creates the response
- FastAPI sends the response to the client
- FastAPI runs all background tasks registered for that request
If the app process stops between step 3 and 4, some tasks may not run.
Execution Model
Background tasks are not separate processes by default. They use the same event loop and thread context as the request handling, just after the response is finished. So:
- They still consume the same CPU and memory
- They do not give you horizontal scaling by themselves
- They should not do very heavy work or long running loops
Rule of thumb:
Use FastAPI BackgroundTasks only for short, non critical, fire and forget operations.
Use real workers (Celery, RQ, Dramatiq, etc.) for heavy, long, or critical background processing.
No Shared State Between Requests
Each request gets its own BackgroundTasks object. You cannot share tasks or data between them directly. If you need cross request coordination, use a database or a message queue.
Testing Background Tasks
Since background tasks are executed after the response, testing them directly can be tricky. Here are simple approaches for beginners.
Test the Task Function Itself
The most important part is usually the function that does the work. You can test it alone like any normal function.
def test_write_log(tmp_path):
log_file = tmp_path / "test.log"
def write_log(message: str, path: str):
with open(path, "a") as f:
f.write(message + "\n")
write_log("hello", str(log_file))
assert log_file.read_text() == "hello\n"
In your real app, you would use the same write_log as a background task.
Simple Integration Check
If you use TestClient from fastapi.testclient, background tasks are executed before the response is returned to the test.
Example:
from fastapi.testclient import TestClient
client = TestClient(app)
def test_background_task_execution(tmp_path, monkeypatch):
calls = []
def fake_task(msg: str):
calls.append(msg)
# Small test app
from fastapi import BackgroundTasks
@app.post("/test-task")
def test_endpoint(background_tasks: BackgroundTasks):
background_tasks.add_task(fake_task, "hello")
return {"ok": True}
response = client.post("/test-task")
assert response.status_code == 200
assert "hello" in callsThis works because in the testing environment the client waits until background tasks finish.
Summary
Background tasks in FastAPI are a simple, built in way to run extra work after your HTTP response is sent. You:
- Use
BackgroundTasksas a parameter in your path operation or dependencies - Register functions with
background_tasks.add_task(func, args, *kwargs) - Use them for short, non critical tasks like sending emails, logging, and webhooks
- Handle errors inside the task functions and log them
- Remember that they run in the same process and are not a replacement for real worker queues
They are an excellent first step into asynchronous backend behavior and are often enough for many small and medium projects.
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!