32.14. Performance Optimization
Table of Contents
Why Performance Optimization Matters
In a production backend, performance is not just about “making it fast.” It affects:
- User experience (slow APIs feel broken).
- Infrastructure cost (more CPU, more RAM, more money).
- Scalability (how many users you can support).
- Reliability (overloaded systems fail in strange ways).
For your final project, performance optimization means you:
- Measure where time and resources are spent.
- Choose the right strategy for each bottleneck.
- Make changes that are safe, testable, and observable.
This chapter focuses on practical techniques you can apply to your project, not on theoretical micro-optimizations.
Key rule: Always measure before and after you optimize. Never guess where the bottleneck is, and never change code for performance without checking that it actually helps.
Step 1: Define Performance Goals
Before changing anything, decide what “good” means. Examples for an API:
- Latency: 95% of requests (P95) should complete in under 200 ms.
- Throughput: Handle at least 200 requests per second (RPS) during peak.
- Error rate: Less than 1% of requests fail.
- Resource usage: Average CPU below 70%, memory below 80% of container limit.
You do not need perfect numbers, but you do need targets so you can see if you are improving.
Example target table for an e‑commerce backend:
| Metric | Endpoint | Target |
|---|---|---|
| P95 latency | GET /products | ≤ 150 ms |
| P95 latency | POST /orders | ≤ 400 ms |
| Throughput | Overall | ≥ 150 RPS |
| Error rate | All 5xx responses | < 1% |
| DB response time | Average query time | ≤ 20 ms |
Step 2: Measure and Profile
Basic Timing in Code
If you do not have a full metrics stack yet, you can still get useful timing information.
Example: FastAPI middleware to log request duration:
import time
from fastapi import FastAPI, Request
import logging
logger = logging.getLogger(__name__)
app = FastAPI()
@app.middleware("http")
async def log_request_time(request: Request, call_next):
start = time.perf_counter()
response = await call_next(request)
duration = (start - time.perf_counter()) * -1000 # ms
logger.info(
"method=%s path=%s status=%s duration_ms=%.2f",
request.method,
request.url.path,
response.status_code,
duration,
)
return responseThis gives you per-request latency in logs. You can use it to see which endpoints are slowest.
Profiling CPU-bound Code
If a specific function seems slow, you can profile it.
Example profiling script:
import cProfile
import pstats
from myapp.some_module import slow_function
if __name__ == "__main__":
profiler = cProfile.Profile()
profiler.enable()
slow_function()
profiler.disable()
stats = pstats.Stats(profiler).sort_stats("cumulative")
stats.print_stats(20) # show top 20 functionsLook at:
- Cumulative time: total time including subcalls.
- Per-call time: time per call, to see if the function is too often or too slow.
Using Load Testing Tools
You must test the application under load, not just locally by hand. Common tools:
locustk6wrk
Simple wrk example:
wrk -t4 -c100 -d30s http://localhost:8000/products-t44 threads.-c100100 open connections.-d30sfor 30 seconds.
You will get latency percentiles and RPS. Compare these numbers before and after changes.
Important: Always load test non-production environments with similar configuration. Never stress your real users and production database when experimenting.
Step 3: Identify the Bottleneck
Performance problems usually fall into one of these categories:
| Category | Symptoms | Typical Fixes |
|---|---|---|
| DB bound | Slow queries, DB CPU high, many I/O waits | Indexes, query optimization, caching, batching |
| I/O bound | Waiting on external APIs, file or network | Async I/O, caching, queues, parallel requests |
| CPU bound | High CPU usage, tight loops, heavy compute | Algorithm changes, offloading to background workers |
| Concurrency / lock bound | Many requests, low throughput | Connection pooling, fewer locks, better architecture |
Use logs and metrics:
- Slow endpoints: check logs for per-route timings.
- Database metrics: slow query logs, query plans.
- External dependencies: HTTP call timing.
Do not optimize everything. Start with the top 1 or 2 bottlenecks.
Database Performance
In a typical backend, the database is often the first real bottleneck.
Use Efficient Queries
Common problems:
- N+1 queries.
- Selecting too many columns.
- Unnecessary joins or nested subqueries.
Example of N+1 problem:
# Inefficient: one query for users, and one per user for orders
users = session.query(User).all()
for user in users:
print(user.name, len(user.orders)) # triggers a query per userBetter, use eager loading:
from sqlalchemy.orm import selectinload
users = (
session.query(User)
.options(selectinload(User.orders))
.all()
)
for user in users:
print(user.name, len(user.orders)) # no extra queriesUse Indexes Wisely
Indexes speed up WHERE, ORDER BY, and JOIN conditions.
For example, a slow query:
SELECT * FROM orders WHERE user_id = 123 ORDER BY created_at DESC LIMIT 20;Add an index to support this pattern:
CREATE INDEX idx_orders_user_created_at
ON orders (user_id, created_at DESC);You can inspect query plans in PostgreSQL:
EXPLAIN ANALYZE
SELECT * FROM orders WHERE user_id = 123 ORDER BY created_at DESC LIMIT 20;Look for:
- Sequential scan on large tables where an index scan would be better.
- Large row estimates or large actual row counts.
Rule: Always confirm index usefulness with EXPLAIN ANALYZE. An index that is never used just slows down writes and takes disk.
Limit Data Returned
Returning a lot of rows or large payloads slows everything.
Techniques:
- Pagination: Always paginate lists, use
LIMITandOFFSETor cursor-based pagination. - Select only needed columns: For heavily used endpoints, avoid
SELECT *.
Example:
SELECT id, name, price
FROM products
WHERE category_id = 5
ORDER BY created_at DESC
LIMIT 20 OFFSET 0;In SQLAlchemy:
products = (
session.query(Product.id, Product.name, Product.price)
.filter(Product.category_id == category_id)
.order_by(Product.created_at.desc())
.limit(limit)
.offset(offset)
.all()
)Using Caching Effectively
Caching can give huge gains with minimal code changes, especially for read-heavy endpoints.
Cache Where It Makes Sense
Ideal candidates:
- Public, read-heavy endpoints:
GET /products,GET /categories. - Rarely changing data: product categories, configuration.
- Expensive derived data: aggregated statistics.
Types of caches in your project:
| Level | Example | Use case |
|---|---|---|
| Application cache | In-memory dict in a process | Very fast, but not shared |
| Redis | Key-value data across instances | Shared cache for multiple replicas |
| HTTP cache | Client or proxy cache (CDN) | Public data, static responses |
Simple Redis Cache Pattern
Example: cache product list by category.
import json
from typing import List
import aioredis
from fastapi import Depends
redis = aioredis.from_url("redis://redis:6379", decode_responses=True)
CACHE_TTL_SECONDS = 60
async def get_products_by_category(category_id: int) -> List[dict]:
cache_key = f"category:{category_id}:products"
cached = await redis.get(cache_key)
if cached is not None:
return json.loads(cached)
# Fallback to DB
products = (
session.query(Product)
.filter(Product.category_id == category_id)
.order_by(Product.created_at.desc())
.all()
)
data = [p.to_dict() for p in products]
await redis.set(cache_key, json.dumps(data), ex=CACHE_TTL_SECONDS)
return dataCache Invalidation
The hard part of caching is invalidation.
Examples:
- When a product is updated, delete its cache key.
- When a category changes, delete category-related cache keys.
Example invalidation on update:
async def update_product(product_id: int, data: ProductUpdate):
product = session.get(Product, product_id)
# ... update fields ...
session.commit()
# Invalidate cache
product_key = f"product:{product_id}"
category_key = f"category:{product.category_id}:products"
await redis.delete(product_key, category_key)
return productRule: If you are not 100% sure that cached data is fresh enough, prefer correctness over caching. Do not serve stale or wrong data only to be faster.
Asynchronous I/O and Concurrency
Backends often spend time waiting on I/O, such as:
- Database queries.
- Calls to other services (payment provider, email API).
- File operations and network calls.
You can use async endpoints to handle more requests without blocking.
Async Endpoints for I/O Bound Work
Example: calling an external payment API.
import httpx
from fastapi import APIRouter
router = APIRouter()
@router.post("/payments")
async def create_payment(order_id: int):
async with httpx.AsyncClient(timeout=5.0) as client:
response = await client.post(
"https://payment.example.com/charge",
json={"order_id": order_id},
)
response.raise_for_status()
return response.json()This does not block the server worker while waiting for the payment service.
Do Not Use Async for CPU-Bound Work
Long, CPU-heavy tasks should run in background workers, not directly inside API requests.
If you must run some CPU work synchronously, consider returning early and processing it with a queue, which you learned about in the background workers chapter.
Reducing Work in the Request Path
A simple, powerful strategy is to move non-critical work out of the request path.
Good candidates:
- Sending emails.
- Generating PDFs.
- Large image processing or data imports.
- Slow third-party integrations that are not needed immediately.
Use Background Jobs
Example: create order now, send email later.
from fastapi import APIRouter, BackgroundTasks
router = APIRouter()
def send_order_confirmation_email(order_id: int, email: str):
# slow function, external SMTP or API calls
...
@router.post("/orders")
async def create_order(order_data: OrderCreate, background_tasks: BackgroundTasks):
order = create_order_in_db(order_data)
background_tasks.add_task(
send_order_confirmation_email,
order_id=order.id,
email=order.customer_email,
)
# Response is fast, email is sent in background
return {"id": order.id, "status": "created"}For more complex workloads, use Celery or similar workers, already covered earlier.
Efficient Serialization and Responses
Serialization and response building can also be a source of latency, especially when you return large objects.
Return Only What Clients Need
Example, instead of this:
class Product(BaseModel):
id: int
name: str
description: str
price: float
created_at: datetime
updated_at: datetime
internal_notes: strFor a public listing endpoint, define a smaller response model:
class ProductListItem(BaseModel):
id: int
name: str
price: floatUse that in your endpoint:
@router.get("/products", response_model=List[ProductListItem])
async def list_products(...):
...Less data means:
- Less CPU to serialize.
- Smaller JSON.
- Lower network latency.
Avoid Unnecessary Work in Response Building
Be careful with operations like:
- Sorting large lists in Python instead of in SQL.
- Repeatedly converting DB models to dicts in slow ways.
- Copying big data structures.
If possible, let the database handle sorting and filtering, and construct your response in a straightforward way.
Connection Pooling and Resource Limits
When your backend scales to multiple replicas, connection usage becomes critical.
Database Connection Pooling
Using SQLAlchemy or async drivers, you should:
- Reuse connections via a pool.
- Avoid opening a new connection per request.
Example SQLAlchemy configuration:
engine = create_engine(
DATABASE_URL,
pool_size=10,
max_overflow=5,
pool_timeout=30,
)You must size the pool based on:
- Max connections allowed by PostgreSQL.
- Number of application instances.
- Average concurrency per instance.
Example calculation:
If PostgreSQL max_connections = 200, and you run 5 app instances, you might give each instance:
pool_size = 20- Some headroom for admin and monitoring connections.
$$
\text{max\_pool\_connections\_total} = \text{instances} \times \text{pool\_size}
$$
You want:
$$
\text{max\_pool\_connections\_total} \le \text{max\_connections} - \text{reserved\_connections}
$$
Rule: If you see “too many connections” errors or high DB CPU, do not just increase max connections. First, check and tune your pools and queries.
HTTP Client Pooling
For external services, reuse HTTP clients where possible:
import httpx
client = httpx.AsyncClient(timeout=5.0)
@router.get("/external")
async def call_external():
resp = await client.get("https://api.example.com/data")
return resp.json()Creating a new client per request wastes time, sockets, and memory.
Using HTTP Caching and Compression
HTTP Caching Headers
When responses are cacheable, you should set headers like:
Cache-ControlETagLast-Modified
Example FastAPI response with headers:
from fastapi import Response
@router.get("/public-products")
async def public_products():
data = get_public_products()
body = json.dumps(data)
headers = {"Cache-Control": "public, max-age=60"}
return Response(content=body, media_type="application/json", headers=headers)Clients or proxies can then reuse responses instead of hitting your server again.
Compression
Most clients support gzip or similar. Use your web server or ASGI server to compress responses.
This reduces bandwidth for mid-to-large responses but adds some CPU. For JSON APIs, compression is almost always beneficial.
Optimize Critical Paths First
Not all endpoints are equal. Focus on:
- High-traffic endpoints, like
GET /products,GET /cart,POST /orders. - Expensive endpoints, like complex filters or reports.
A typical improvement loop for a single endpoint:
- Measure baseline latency and RPS with load testing.
- Inspect logs and DB queries for that endpoint.
- Apply one improvement:
- Add index.
- Add small cache.
- Remove unnecessary work.
- Load test again.
- Compare metrics.
Example results table:
| Change | P95 latency | RPS | Notes |
|---|---|---|---|
| Baseline | 420 ms | 80 | N+1 queries, no cache |
| Add eager loading | 260 ms | 120 | Fewer DB roundtrips |
| Add Redis cache (60s) | 90 ms | 300 | DB load reduced significantly |
Avoid Common Anti-patterns
Some patterns look simple but can destroy performance.
Doing Work in Loops That Could Be Batched
Slow:
orders_summary = []
for order_id in order_ids:
order = session.get(Order, order_id)
orders_summary.append(order.to_summary())Faster:
orders = (
session.query(Order)
.filter(Order.id.in_(order_ids))
.all()
)
orders_summary = [o.to_summary() for o in orders]Fetching All Rows Without Need
Avoid SELECT * FROM big_table without limits.
At API level, never design an endpoint that “returns all entries” for large collections. Always require pagination.
Synchronous Blocking in Async Code
In async endpoints, do not call blocking functions directly, such as:
- Synchronous database drivers.
- Synchronous HTTP clients.
- Heavy CPU-bound operations.
They block the event loop and reduce concurrency.
Validate Performance With Tests
You do not need full performance tests in your unit test suite, but you should:
- Keep simple smoke load tests that you can run after major changes.
- Run heavier load tests before releases.
You can also add simple timing asserts in integration tests for critical paths:
import time
def test_products_endpoint_is_fast(client):
start = time.perf_counter()
response = client.get("/products?limit=20")
duration = time.perf_counter() - start
assert response.status_code == 200
assert duration < 0.5 # 500 msThese do not guarantee real-world performance, but they help catch regressions.
Putting It All Together for the Final Project
For your production-ready final project, a practical performance optimization plan might look like this:
- Set targets
- For example, P95 latency ≤ 250 ms for main GET endpoints.
- Instrument your app
- Add request timing middleware.
- Log slow queries from PostgreSQL.
- Enable basic metrics collection.
- Optimize database usage
- Fix N+1 patterns.
- Add missing indexes for most common filters and joins.
- Implement pagination everywhere lists are returned.
- Introduce caching
- Use Redis for expensive, frequently read endpoints.
- Invalidate cache entries on writes.
- Move non-critical work to background
- Emails, some external integrations, heavy processing.
- Tune connection pools
- Configure reasonable DB pool sizes for the number of app instances.
- Reuse HTTP clients.
- Run load tests
- Before deployment and after significant changes.
- Compare against your targets and adjust.
- Monitor in production
- Track latency, throughput, error rate, and resource usage.
- Set alerts when metrics exceed thresholds.
Final principle: Performance optimization is a continuous process, not a one-time task. Measure, improve, deploy, and observe, then repeat when usage patterns or requirements change.
With these practices, your final project will not only function correctly, it will also handle real-world traffic and grow with your users.
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!