5.16. Python Backend Best Practices
Table of Contents
Writing Maintainable Python Backend Code
This chapter focuses on practical habits and patterns that help you write Python backends that are readable, testable, and ready for production.
You have already seen core Python features and how to build web backends. Here you will connect that knowledge into concrete best practices.
Project and Code Organization
A clear structure makes it easy to find things and to grow your codebase safely.
Prefer a Package Structure
Even for small APIs, structure your project as a package:
myapp/
pyproject.toml # or setup.cfg / requirements.txt
README.md
.env.example
myapp/
__init__.py
config.py
main.py # app entry point (FastAPI / Flask / etc.)
api/
__init__.py
v1/
__init__.py
users.py
items.py
core/
security.py
logging.py
models/
__init__.py
user.py
item.py
db/
__init__.py
session.py
migrations/
tests/
__init__.py
test_users.py
test_items.pyKey ideas:
- Group by responsibility:
api,core,models,db. - Keep files small. A file with thousands of lines is a smell.
- Make your package importable:
myapp.main,myapp.api.users, etc.
Separate Layers
Do not mix HTTP logic, business logic, and database logic in one function.
A common layering:
- API layer: request parsing, HTTP status codes, response models.
- Service layer: business rules, validations, workflows.
- Repository / data access layer: queries, ORM operations.
Example structure:
myapp/
api/
users.py # FastAPI routes
services/
users.py # business logic
repositories/
users.py # DB operationsThis separation keeps each part small, testable, and replaceable.
Code Style and Formatting
Consistent style helps teams read and maintain code.
Use a Formatter
Use a formatter like Black to format Python code automatically.
pip install black
black myappBlack enforces things like:
- 4 spaces indentation.
- Reasonable line length.
- Consistent string quotes.
You focus on logic, not spacing.
Lint Your Code
Use linters to catch problems early:
flake8orrufffor style and simple errors.mypyfor type checking (see below).
pip install ruff mypy
ruff myapp
mypy myappExample of a linter catch:
# Bug: unused variable, shadowed name, etc.
def find_user(id, db):
id = int(id)
return db.get_user()
A linter will point to the suspicious id = int(id) and unused id.
Type Hints and Static Checking
Type hints make your code safer and easier to understand.
Add Type Hints to Functions
from typing import Optional, List
from dataclasses import dataclass
@dataclass
class User:
id: int
email: str
is_active: bool = True
def get_user_by_id(user_id: int) -> Optional[User]:
...Use them for:
- Parameters:
user_id: int - Returns:
-> Optional[User] - Collections:
List[int],dict[str, str](Python 3.9+).
Use mypy or Pyright
Type check your project:
mypy myappExample issue:
def send_email(user_email: str) -> None:
...
user_id: int = 123
send_email(user_id) # mypy: Argument 1 has incompatible type "int"; expected "str"You catch bugs before running the code.
Rule: In backend code, add type hints to all public functions and methods and run a type checker regularly.
Configuration and Environment
Never hardcode secrets or environment-specific values in code.
Use Environment Variables
Typical config values:
- Database URL
- Secret keys
- Debug flag
- External API URLs
Use pydantic or similar to load them once:
from pydantic import BaseSettings
class Settings(BaseSettings):
debug: bool = False
database_url: str
secret_key: str
class Config:
env_file = ".env"
settings = Settings()Then use:
from myapp.config import settings
engine = create_engine(settings.database_url)Do Not Commit Secrets
Maintain an .env.example:
DEBUG=false
DATABASE_URL=postgresql+psycopg2://user:pass@localhost:5432/mydb
SECRET_KEY=your-secret-key-here
And keep real .env files out of version control with .gitignore.
Rule: Never commit real passwords, secret keys, tokens, or private keys to Git.
Dependency Management
Keep dependencies under control and reproducible.
Use a Requirements or pyproject File
Two common approaches:
requirements.txt:
pip freeze > requirements.txt
pip install -r requirements.txtpyproject.tomlwith tools like Poetry or Hatch:
[project]
name = "myapp"
version = "0.1.0"
dependencies = [
"fastapi",
"uvicorn[standard]",
"sqlalchemy",
"psycopg2-binary",
]Pin Versions
For production apps, pin versions:
fastapi==0.115.0
uvicorn[standard]==0.30.0
sqlalchemy==2.0.32
psycopg2-binary==2.9.9This avoids surprises when libraries change.
Error Handling and Exceptions
Backends must fail in controlled, predictable ways.
Raise Domain-Specific Exceptions
Instead of using generic Exception, define your own:
class UserNotFoundError(Exception):
pass
class EmailAlreadyUsedError(Exception):
passService layer:
from .exceptions import UserNotFoundError, EmailAlreadyUsedError
def register_user(email: str, password: str) -> User:
if user_repo.exists(email=email):
raise EmailAlreadyUsedError(f"Email {email} already used")
...Then map these to HTTP errors in the API layer.
Never Hide Errors Silently
Avoid:
try:
do_something()
except Exception:
passBetter:
import logging
logger = logging.getLogger(__name__)
try:
do_something()
except SpecificError as exc:
logger.exception("Failed to do something")
raiseYou can handle known errors, but log them clearly.
Logging
Logging is your main window into a running backend.
Use the Standard Logging Module
Configure logging once, for example in myapp/core/logging.py:
import logging
import sys
def configure_logging() -> None:
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
handlers=[
logging.StreamHandler(sys.stdout),
],
)
Call configure_logging() in your entry point:
from myapp.core.logging import configure_logging
def create_app():
configure_logging()
...Use Log Levels Properly
| Level | Use for |
|---|---|
| DEBUG | Detailed info for debugging, not in prod by default |
| INFO | High-level application events |
| WARNING | Something unexpected but continuing |
| ERROR | A failure that affects a request or workflow |
| CRITICAL | Serious errors, application may be unusable |
Example:
logger = logging.getLogger(__name__)
def create_order(...):
logger.info("Creating order for user_id=%s", user_id)
try:
...
except PaymentError as exc:
logger.error("Payment failed for user_id=%s: %s", user_id, exc)
raiseDatabase Access and ORM Best Practices
Databases are often the bottleneck and failure point.
Use a Session per Request
Do not share a single global session for all requests.
With SQLAlchemy:
from sqlalchemy.orm import sessionmaker
SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()In FastAPI:
@app.get("/users/{user_id}")
def read_user(user_id: int, db: Session = Depends(get_db)):
return user_repo.get(db, user_id)Keep Queries Close to the Repository
In repositories/users.py:
from sqlalchemy.orm import Session
from myapp.models.user import User
def get(db: Session, user_id: int) -> User | None:
return db.query(User).filter(User.id == user_id).first()
def get_by_email(db: Session, email: str) -> User | None:
return db.query(User).filter(User.email == email).first()Service code should rarely write raw queries itself, and API code should never talk to the database directly.
Testing and Testability
A backend without tests is fragile.
Write Tests from the Start
Examples:
- Unit tests for services.
- Integration tests for endpoints.
- Database tests for repository functions.
Simple service test:
def test_register_user_creates_user(user_service, fake_db):
user = user_service.register_user("test@example.com", "password123")
assert user.email == "test@example.com"Prefer Injected Dependencies
Instead of:
# Hard to test
def send_welcome_email(user: User) -> None:
smtp = SmtpClient("smtp.example.com", 587)
smtp.send(...)Use dependency injection:
class EmailSender:
def send_welcome_email(self, user: User) -> None:
...
def create_user(email: str, password: str, mailer: EmailSender) -> User:
user = user_repo.create(email=email, password=password)
mailer.send_welcome_email(user)
return user
In tests, pass a fake EmailSender that records calls.
Rule: Design functions so that external services are passed in as parameters. This makes code testable and reusable.
Performance and Asynchronous Code
Backend performance often depends on I/O, such as database calls or HTTP requests.
Use Async When Appropriate
In async frameworks like FastAPI, define handlers as async def when:
- They await database calls using an async driver.
- They call other async services or APIs.
Example:
@app.get("/items/{item_id}")
async def read_item(item_id: int):
item = await item_service.get_item(item_id)
return itemKeep in mind:
- Do not use
time.sleepin async code, useawait asyncio.sleep(...). - Long CPU tasks block the event loop and should be run in a thread or worker.
Avoid Premature Optimization
Focus on:
- Clear, simple code.
- Correctness and tests.
- Measure performance with profiling or load tests.
- Then optimize real bottlenecks.
Security-Oriented Habits
Security should be part of your everyday coding.
Validate Inputs
For APIs:
- Use request models with validation (for example, Pydantic models in FastAPI).
- Do not trust client input. Always validate type, length, and allowed values.
Example:
from pydantic import BaseModel, EmailStr, constr
class UserCreate(BaseModel):
email: EmailStr
password: constr(min_length=8, max_length=128)Least Privilege Principle
- Limit database user permissions.
- Limit API keys to minimal scopes.
- Restrict admin endpoints.
Rule: Assume all external input can be malicious. Always validate, sanitize, and authorize.
API Design and Error Responses
Design your REST API to be predictable.
Use Consistent URL Patterns
Examples:
/api/v1/users/api/v1/users/{user_id}/api/v1/orders/{order_id}/items
Keep nouns plural, avoid verbs in paths when possible.
Standardize Error Responses
Return structured errors:
{
"detail": "User not found",
"code": "user_not_found"
}For validation errors, use a predictable schema, for example:
{
"detail": [
{
"loc": ["body", "email"],
"msg": "value is not a valid email address",
"type": "value_error.email"
}
]
}This helps frontend and other clients handle errors reliably.
Documentation and Comments
Good documentation lowers the cost of onboarding and maintenance.
Write Docstrings for Public Functions
Example:
def create_user(email: str, password: str) -> User:
"""
Create a new user with the given email and password.
Raises:
EmailAlreadyUsedError: If a user with the same email already exists.
"""
...Keep Comments Focused
- Explain why, not what.
- Remove outdated comments.
Bad:
# Increase x by 1
x = x + 1Good:
# We add 1 to include the current page in the total count
x = x + 1Putting It All Together: Example Flow
A typical request path in a well-structured Python backend:
- Router receives HTTP request:
- Parses path parameters, query, and body.
- Validates request model.
- Service function:
- Applies business rules.
- Calls repositories for DB operations.
- Uses injected dependencies such as mailers or external APIs.
- Raises domain-specific exceptions on errors.
- Repository:
- Executes ORM or SQL queries.
- Maps rows to domain objects or models.
- Exception handlers:
- Translate domain exceptions into HTTP responses.
- Response model:
- Serializes data into JSON with correct schema.
Each step is small, testable, and uses:
- Type hints.
- Structured logging.
- Clear error handling.
- No hardcoded secrets.
- Appropriate configuration.
Checklist of Python Backend Best Practices
Use this as a quick reference when building backends in Python.
Backend Best Practices Checklist
- Project structure:
- Organized by responsibility, not huge files.
- Separate API, service, and repository layers.
- Code quality:
- Automatic formatter (Black).
- Linters (Ruff, Flake8) and type checker (mypy).
- Types:
- Type hints on public functions and models.
- Regular static type checking.
- Configuration:
- Environment variables for secrets and environment-specific values.
- No secrets in Git,
.env.examplecommitted. - Dependencies:
- Requirements or
pyproject.tomlwith pinned versions for production. - Error handling:
- Domain-specific exceptions, not bare
Exception. - No silent exception swallowing, always log or handle.
- Logging:
- Central logging configuration.
- Correct use of log levels.
- Persistence:
- One DB session per request, properly closed.
- Repositories for all DB access.
- Testing:
- Unit tests and integration tests.
- Dependencies injected, not hardcoded, for easy mocking.
- Performance:
- Async interfaces where useful, avoid blocking operations in async code.
- Measure before optimization.
- Security:
- Input validation on all external data.
- Least privilege for secrets and permissions.
- API:
- Consistent URL patterns.
- Structured, predictable error responses.
- Documentation:
- Docstrings and concise comments explaining why.
Following these practices will help you build Python backends that are robust, maintainable, and production ready.
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!