8.7. Exception Handling
Table of Contents
Why Exception Handling Matters in FastAPI
Every real application fails at some point. Files are missing, databases are down, users send invalid data, or you simply have a bug. If you do nothing, FastAPI will return a generic 500 Internal Server Error with a traceback in the logs.
Exception handling is about:
- Returning clear, consistent error responses to clients
- Hiding internal details of your code and infrastructure
- Logging errors so you can debug them
- Converting low-level errors into meaningful API errors
In FastAPI, exception handling is built on top of Starlette. You can use:
- Built-in exceptions like
HTTPException - Custom exception classes
- Global exception handlers
You will use all three in a real project.
Using `HTTPException`
The most common way to signal an error in a FastAPI route is to raise HTTPException. This tells FastAPI:
- Which HTTP status code to use
- What error message to send
- Optional custom headers to add
Basic usage:
from fastapi import FastAPI, HTTPException
app = FastAPI()
@app.get("/items/{item_id}")
def read_item(item_id: int):
fake_db = {1: "Apple", 2: "Banana"}
if item_id not in fake_db:
raise HTTPException(
status_code=404,
detail="Item not found",
)
return {"id": item_id, "name": fake_db[item_id]}The JSON response looks like:
{
"detail": "Item not found"
}Common patterns with `HTTPException`
1. Returning 400 Bad Request
Use this when the client did something wrong, but validation did not catch it:
from fastapi import HTTPException, status
@app.post("/transfer")
def transfer_money(amount: float):
if amount <= 0:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Amount must be greater than zero"
)
return {"status": "ok"}2. Returning 401 Unauthorized or 403 Forbidden
Use for authentication or authorization issues:
from fastapi import Depends
def get_current_user(token: str):
if token != "secret":
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid authentication credentials",
headers={"WWW-Authenticate": "Bearer"},
)
return {"username": "alice"}
@app.get("/profile")
def read_profile(user=Depends(get_current_user)):
return user
Note the WWW-Authenticate header. Many auth flows depend on it.
3. Returning 409 Conflict, 422, etc.
You can use any status code:
@app.post("/users")
def create_user(username: str):
existing_users = {"alice", "bob"}
if username in existing_users:
raise HTTPException(
status_code=409,
detail=f"User '{username}' already exists"
)
return {"username": username}
::danger
Rule: Use HTTPException to represent expected API errors, not programming bugs. Bugs should usually result in a 500 error and be logged, not turned into a fake "valid" response.
Custom Exception Classes
HTTPException is good, but as your app grows you will want domain-specific exceptions, such as:
UserNotFoundErrorOutOfStockErrorPaymentFailedErrorPermissionDeniedError
These make your code more readable and allow centralized handling.
Basic custom exception:
class OutOfStockError(Exception):
def __init__(self, item_id: int):
self.item_id = item_idYou do not return anything here. You just define what information the exception carries. The conversion into an HTTP response will be done by an exception handler, described later.
Example: service layer using custom exceptions
class UserNotFoundError(Exception):
def __init__(self, user_id: int):
self.user_id = user_id
def get_user_from_db(user_id: int):
fake_db = {1: "Alice"}
if user_id not in fake_db:
raise UserNotFoundError(user_id)
return {"id": user_id, "name": fake_db[user_id]}In the route you can either:
- Catch and convert to
HTTPExceptionlocally, or - Let a global exception handler handle it (recommended)
Local handling:
from fastapi import HTTPException, status
@app.get("/users/{user_id}")
def get_user(user_id: int):
try:
return get_user_from_db(user_id)
except UserNotFoundError as exc:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"User {exc.user_id} not found",
)This works but repeats error conversion logic. A centralized handler is cleaner.
Global Exception Handlers
FastAPI lets you register a handler for any exception type. This handler is called whenever that exception is raised anywhere in your app, including dependencies.
General structure:
from fastapi import Request
from fastapi.responses import JSONResponse
@app.exception_handler(OutOfStockError)
async def out_of_stock_handler(request: Request, exc: OutOfStockError):
return JSONResponse(
status_code=400,
content={"detail": f"Item {exc.item_id} is out of stock"},
)Now:
- Any
raise OutOfStockError(42)in your code will return a 400 JSON error. - You do not need to wrap every call in
try/except.
Full example
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
app = FastAPI()
class OutOfStockError(Exception):
def __init__(self, item_id: int):
self.item_id = item_id
inventory = {
1: {"name": "Laptop", "stock": 0},
2: {"name": "Mouse", "stock": 5},
}
def purchase_item(item_id: int):
item = inventory.get(item_id)
if item is None:
raise KeyError(f"Item {item_id} does not exist")
if item["stock"] <= 0:
raise OutOfStockError(item_id)
item["stock"] -= 1
return item
@app.exception_handler(OutOfStockError)
async def out_of_stock_handler(request: Request, exc: OutOfStockError):
return JSONResponse(
status_code=400,
content={"detail": f"Item {exc.item_id} is out of stock"},
)
@app.get("/buy/{item_id}")
def buy(item_id: int):
return purchase_item(item_id)Request:
GET /buy/1Response:
{
"detail": "Item 1 is out of stock"
}Handling library or framework exceptions
You can also handle exceptions raised by libraries. For example, SQLAlchemy:
from sqlalchemy.exc import IntegrityError
@app.exception_handler(IntegrityError)
async def integrity_error_handler(request: Request, exc: IntegrityError):
return JSONResponse(
status_code=400,
content={"detail": "Database integrity error"},
)
Now any IntegrityError from any endpoint will turn into a 400 response.
::danger
Rule: Use @app.exception_handler(SomeError) for cross-cutting concerns, like mapping your domain exceptions and library errors to proper HTTP responses in one place.
Handling Validation Errors
FastAPI automatically validates request bodies, query parameters, path parameters, etc. When validation fails, it raises RequestValidationError. There is also ValidationError from Pydantic when model validation fails manually.
By default, FastAPI returns a 422 response like:
{
"detail": [
{
"loc": ["body", "item", "price"],
"msg": "field required",
"type": "value_error.missing"
}
]
}Sometimes you want your own error format.
Custom handler for `RequestValidationError`
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi import Request, status
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
errors = []
for err in exc.errors():
loc = ".".join(str(p) for p in err["loc"])
errors.append({
"field": loc,
"message": err["msg"],
"type": err["type"],
})
return JSONResponse(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
content={"errors": errors},
)Now validation errors will look like:
{
"errors": [
{
"field": "body.item.price",
"message": "field required",
"type": "value_error.missing"
}
]
}This can be easier for frontend developers to work with.
Example endpoint with validation
from pydantic import BaseModel
class Item(BaseModel):
name: str
price: float
quantity: int
@app.post("/items")
def create_item(item: Item):
return itemIf you send:
{
"name": "Pen",
"price": "not-a-number",
"quantity": 5
}Your custom handler will format the error response.
Handling Pydantic `ValidationError` directly
If you create models manually, Pydantic can raise ValidationError. You can also write a handler for that:
from pydantic import ValidationError
@app.exception_handler(ValidationError)
async def pydantic_validation_handler(request: Request, exc: ValidationError):
return JSONResponse(
status_code=422,
content={"detail": exc.errors()},
)Returning Consistent Error Responses
In a real API, you want all errors to have a consistent JSON structure. For example:
{
"error": {
"code": "USER_NOT_FOUND",
"message": "User 123 not found",
"details": null
}
}Or:
{
"detail": "Human readable message",
"code": "SOME_CODE",
"errors": []
}Whatever structure you choose, stick with it.
Defining an error schema with Pydantic
from pydantic import BaseModel
from typing import Optional, Any, List
class APIError(BaseModel):
code: str
message: str
details: Optional[Any] = NoneUse it in handlers:
class UserNotFoundError(Exception):
def __init__(self, user_id: int):
self.user_id = user_id
@app.exception_handler(UserNotFoundError)
async def user_not_found_handler(request: Request, exc: UserNotFoundError):
error = APIError(
code="USER_NOT_FOUND",
message=f"User {exc.user_id} not found",
details={"user_id": exc.user_id},
)
return JSONResponse(
status_code=404,
content={"error": error.model_dump()},
)
Now all UserNotFoundError responses have the same shape.
Consistent format for all server errors
You can also handle the catch-all Exception type:
import logging
logger = logging.getLogger(__name__)
@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
# Log the error with stack trace
logger.exception("Unhandled error: %s %s", request.method, request.url)
error = APIError(
code="INTERNAL_SERVER_ERROR",
message="An unexpected error occurred. Please try again later.",
)
return JSONResponse(
status_code=500,
content={"error": error.model_dump()},
)
::danger
Rule: Return a generic message to the client for 500 errors. Never leak stack traces, SQL queries, or secrets in responses.
Combining Exception Handling with Dependencies
Dependencies in FastAPI are a common place for exceptions. For example, authentication:
from fastapi import Depends, Header
class NotAuthenticatedError(Exception):
pass
def get_current_user(authorization: str = Header(None)):
if authorization != "Bearer secret-token":
raise NotAuthenticatedError()
return {"username": "alice"}
@app.exception_handler(NotAuthenticatedError)
async def not_authenticated_handler(request: Request, exc: NotAuthenticatedError):
return JSONResponse(
status_code=401,
content={"detail": "Not authenticated"},
headers={"WWW-Authenticate": "Bearer"},
)
@app.get("/me")
def read_me(user=Depends(get_current_user)):
return userHere:
get_current_usercan be used by many paths.- All failures produce the same 401 error without duplicating logic.
Practical Patterns and Tips
Pattern 1: Domain exceptions plus handlers
- Define domain-specific exceptions in your "service" or "domain" layer.
- Register global handlers in your FastAPI app that map them to HTTP responses.
Example table:
| Domain exception | HTTP status | Example code |
|---|---|---|
UserNotFoundError | 404 | USER_NOT_FOUND |
DuplicateUserError | 409 | USER_ALREADY_EXISTS |
PermissionDeniedError | 403 | PERMISSION_DENIED |
OutOfStockError | 400 | OUT_OF_STOCK |
This keeps business logic free of HTTP concerns.
Pattern 2: Local vs global handling
- Use local
try/exceptwhen that route needs special behavior. - Use global handlers for common errors that should always behave the same.
Example local handling:
@app.get("/dangerous")
def dangerous_route():
try:
result = do_something_risky()
except SpecificError as exc:
# Maybe adjust message or call external service
raise HTTPException(400, detail=str(exc))
return resultDebug vs production behavior
In development, you often want to see full tracebacks in the browser. In production, you want:
- Minimal error message to clients
- Full error details in logs
Use environment variables and settings (covered in other chapters) to switch between modes.
Summary
- Use
HTTPExceptionto return expected HTTP errors from routes and dependencies. - Define custom exception classes for your domain and raise them in business logic.
- Register global exception handlers with
@app.exception_handler(...)to transform exceptions into consistent JSON responses. - Customize handling of validation errors (
RequestValidationErrorandValidationError) to match your API error format. - Centralize error response structure with Pydantic models like
APIError. - Handle authentication and authorization failures via exceptions in dependencies plus corresponding handlers.
- Log internal errors and avoid exposing sensitive details to clients, especially for 500 responses.
With these tools, your FastAPI application can fail gracefully, give clear feedback to clients, and remain safe and maintainable as it grows.
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!