15.10. Input Validation
Table of Contents
Why Input Validation Matters
Input validation is checking that any data coming into your backend is what you expect, before you use it.
Every external input is potentially dangerous:
- HTTP request body
- Query parameters
- Path parameters
- Headers
- Cookies
- Uploaded files
- Environment variables (in some contexts)
- Data from other services or queues
If you do not validate, attackers can:
- Trigger bugs and crashes
- Bypass business rules
- Exploit vulnerabilities such as SQL injection or XSS
- Cause performance issues with huge or complex inputs
Rule: Treat all external input as untrusted and validate it before using it.
Throughout this chapter, examples use Python-like pseudocode and JSON, but the same ideas apply to any backend language or framework.
Types of Input Validation
There are several ways to validate input. You usually combine them.
Whitelisting vs Blacklisting
- Whitelisting: define what is allowed, reject everything else.
- Example: "username can only contain letters, digits, and underscores, length 3 to 20".
- Blacklisting: define what is forbidden, allow everything else.
- Example: "reject input containing
<script>".
Whitelisting is much safer.
Rule: Prefer whitelisting (allow known good patterns) over blacklisting (forbid known bad patterns).
Simple Example
Whitelisting username:
import re
USERNAME_RE = re.compile(r"^[A-Za-z0-9_]{3,20}$")
def validate_username(username: str) -> bool:
return bool(USERNAME_RE.match(username))Blacklisting dangerous substring:
def is_safe_comment(comment: str) -> bool:
return "<script>" not in comment.lower()
The second example is weak. Attackers can use variations like <ScRiPt> or other ways to execute scripts.
Syntactic vs Semantic Validation
- Syntactic validation checks the shape of input.
- Example: "email must contain
@", "age must be an integer". - Semantic validation checks the meaning relative to your rules.
- Example: "age must be 18 or older", "booking date must be in the future".
You need both.
Examples
Syntactic:
def validate_age(value: str) -> int:
try:
age = int(value)
except ValueError:
raise ValueError("age must be an integer")
return ageSemantic:
def check_age(age: int) -> None:
if age < 18:
raise ValueError("age must be at least 18")Use syntactic validation first, then semantic.
Client-Side vs Server-Side Validation
- Client-side validation happens in the browser or mobile app.
- Server-side validation happens in your backend.
Client-side validation improves user experience, but cannot be trusted. Users can bypass it with:
- Developer tools
- Custom scripts
- Automated tools like curl or Postman
Rule: Never rely on client-side validation alone. Always validate again on the server.
Example:
- Browser form uses HTML
requiredandtype="email". - Backend still checks:
- Field is present.
- It is a string.
- It matches email pattern.
- It meets business rules.
Validation by Input Type
Different types of input need different checks.
Numbers
Typical checks:
- Is it really a number?
- Is it within expected range?
- Is it integer or float?
- Is sign allowed (positive only, etc.)?
Example: price field.
def validate_price(value: str) -> float:
try:
price = float(value)
except ValueError:
raise ValueError("price must be a number")
if price < 0:
raise ValueError("price cannot be negative")
if price > 1_000_000:
raise ValueError("price too large")
return priceFor counts or IDs, use integers and disallow negatives:
def validate_quantity(value: str) -> int:
try:
quantity = int(value)
except ValueError:
raise ValueError("quantity must be an integer")
if quantity < 1:
raise ValueError("quantity must be at least 1")
if quantity > 1000:
raise ValueError("quantity too large")
return quantityStrings
For string fields:
- Define min and max length.
- Define allowed characters or patterns.
- Decide if whitespace is allowed or should be trimmed.
- Be careful with extremely large strings.
Example: username.
import re
USERNAME_RE = re.compile(r"^[A-Za-z0-9_]{3,20}$")
def validate_username(username: str) -> str:
username = username.strip()
if not USERNAME_RE.match(username):
raise ValueError("username must be 3-20 characters, letters, numbers, underscore only")
return usernameExample: free text comment, where you allow almost anything but limit size:
def validate_comment(comment: str) -> str:
comment = comment.strip()
if len(comment) == 0:
raise ValueError("comment cannot be empty")
if len(comment) > 5000:
raise ValueError("comment too long")
return commentEnums and Controlled Values
Some fields should only allow a small set of values.
Examples:
- User role:
["user", "admin", "moderator"] - Order status:
["pending", "paid", "shipped", "cancelled"] - Sort direction:
["asc", "desc"]
Rule: For fields with limited options, use enums or explicit lists, not free text.
Example:
ALLOWED_ROLES = {"user", "admin", "moderator"}
def validate_role(role: str) -> str:
role = role.strip().lower()
if role not in ALLOWED_ROLES:
raise ValueError("invalid role")
return roleThis also helps prevent logical bugs and privilege escalation.
Dates and Times
For dates and times:
- Parse using a strict format.
- Check semantic rules.
- Consider timezone handling.
Example: parse ISO 8601 date and ensure it is not in the past.
from datetime import datetime, date
def validate_booking_date(value: str) -> date:
try:
parsed = datetime.fromisoformat(value)
except ValueError:
raise ValueError("invalid date format, expected ISO 8601")
today = date.today()
if parsed.date() < today:
raise ValueError("booking date cannot be in the past")
return parsed.date()Also consider:
- Maximum future date (for example, not more than 1 year ahead).
- Consistent timezone (store everything in UTC where possible).
Emails, URLs, and Other Structured Text
Emails, URLs, phone numbers, etc. have structure.
For security purposes, a simple pattern is often enough. Do not try to implement the full email standard.
import re
EMAIL_RE = re.compile(r"^[^@]+@[^@]+\.[^@]+$")
def validate_email(email: str) -> str:
email = email.strip().lower()
if not EMAIL_RE.match(email):
raise ValueError("invalid email address")
if len(email) > 254:
raise ValueError("email too long")
return emailYou still need to verify emails via a confirmation link when needed.
URL
Use a parser instead of complex regex.
from urllib.parse import urlparse
def validate_url(url: str) -> str:
url = url.strip()
parsed = urlparse(url)
if parsed.scheme not in ("http", "https"):
raise ValueError("invalid scheme")
if not parsed.netloc:
raise ValueError("invalid URL, missing host")
return urlFor security, you may also restrict:
- Hostnames (for example, disallow internal IPs like
127.0.0.1or private networks). - Maximum length.
Validating HTTP Inputs
Path and Query Parameters
These come as strings and must be converted and checked.
Example: /users/{user_id} where user_id is an integer:
def validate_user_id(value: str) -> int:
try:
user_id = int(value)
except ValueError:
raise ValueError("user_id must be an integer")
if user_id <= 0:
raise ValueError("user_id must be positive")
return user_id
Example: pagination query params page and page_size:
def validate_pagination(page: str | None, page_size: str | None) -> tuple[int, int]:
page = int(page) if page is not None else 1
page_size = int(page_size) if page_size is not None else 20
if page < 1:
raise ValueError("page must be >= 1")
if not 1 <= page_size <= 100:
raise ValueError("page_size must be between 1 and 100")
return page, page_sizeJSON Request Bodies
For JSON, define a schema: what fields are required, their types, and constraints.
Example: registration request:
{
"email": "user@example.com",
"password": "abc12345",
"name": "John Doe"
}Validation steps:
- Check body is valid JSON.
- Check that required fields exist.
- Check types (string, number, object, etc.).
- Apply rules per field (lengths, formats).
- Reject unknown fields if your API requires strictness.
In Python-like pseudocode:
def validate_registration(body: dict) -> dict:
# required fields
for field in ("email", "password", "name"):
if field not in body:
raise ValueError(f"missing field: {field}")
email = validate_email(body["email"])
password = validate_password(body["password"])
name = validate_name(body["name"])
return {"email": email, "password": password, "name": name}Using frameworks like FastAPI with Pydantic, you will typically express this as a model and let the framework run validation for you. The principle is the same.
Form Data
Form data often comes from HTML forms, usually as strings.
Common pitfalls:
- Missing required fields.
- Multiple values for the same field.
- Encoding issues.
- Hidden fields that attackers can modify.
Treat form fields exactly like any other external input: parse, normalize, validate.
Example: login form:
def validate_login_form(form: dict) -> dict:
username = form.get("username", "").strip()
password = form.get("password", "")
if not username:
raise ValueError("username required")
if not password:
raise ValueError("password required")
if len(username) > 50:
raise ValueError("username too long")
return {"username": username, "password": password}File Uploads
Files are especially risky. Validation involves:
- Type checks:
- Check MIME type from the request header.
- Check file extension.
- Optionally inspect "magic bytes" at the beginning of the file.
- Size limits:
- Per file.
- Total request size.
- Content checks:
- For images, try to open with an image library.
- Reject files with mixed or suspicious content.
Rule: Never trust only the file extension or the client-provided MIME type.
Example of size check:
MAX_AVATAR_SIZE = 2 * 1024 * 1024 # 2 MB
def validate_avatar(file_bytes: bytes, filename: str, content_type: str) -> None:
if len(file_bytes) > MAX_AVATAR_SIZE:
raise ValueError("file too large")
if content_type not in ("image/jpeg", "image/png"):
raise ValueError("unsupported file type")
# Optional: inspect magic bytes or use an image library to verifyAlso consider:
- Normalizing filenames.
- Storing files outside the web root.
- Scanning with antivirus if needed.
Preventing Injection with Validation
Input validation reduces the chance of injection attacks. It is not enough by itself, but it is a strong first layer.
SQL Injection
You already know from the SQL Injection chapter that you must use parameterized queries or ORM features. Validation strengthens this:
- If
user_idmust be an integer, validation rejects"1; DROP TABLE users"before it even reaches the database. - If search queries have length limits, it is harder to send large payloads that trigger parser vulnerabilities.
Example of safe and validated query:
def get_user(db, raw_user_id: str):
user_id = validate_user_id(raw_user_id)
# safe parameterized query
return db.execute("SELECT * FROM users WHERE id = %s", (user_id,))Rule: Always combine validation with parameterized queries or ORM. Do not rely on validation alone.
Cross-Site Scripting (XSS)
Input validation helps reduce XSS but does not replace output encoding.
Typical strategies:
- For fields that should not contain HTML (username, title), restrict allowed characters.
- For free text fields (comments), you may:
- Strip or encode HTML characters, or
- Sanitize HTML with a trusted library if you want to allow some tags.
Examples:
- Username: only letters, numbers, underscore.
- Blog title: letters, numbers, punctuation, limited length.
- Comment: limit length, then ensure proper HTML escaping on output.
Remember, output encoding (for example, HTML escaping) is the main defense against XSS. Validation is an additional barrier.
Safe Defaults and Limits
Validation is also about setting safe boundaries.
Length and Size Limits
Set length limits everywhere you can:
- Path parameters and query parameters.
- Headers.
- JSON fields.
- Form fields.
- Files.
This helps:
- Prevent denial of service from huge payloads.
- Avoid unexpected behavior in downstream systems.
Example policies (these are examples, not universal rules):
| Item | Example limit |
|---|---|
| Username | 3 to 30 chars |
| Password | 8 to 128 chars |
| up to 254 chars | |
| Comment body | up to 5,000 chars |
| JSON body size | up to 1 MB |
| Uploaded image | up to 5 MB |
Apply limits close to the entry point if possible, for example:
- Web server or reverse proxy can limit total request size.
- Application can limit per field.
Default Values vs Required Fields
For optional fields you can:
- Provide a safe default value.
- Or treat them as truly optional and handle
null/ missing values explicitly.
Examples:
pagedefault to1if not provided.page_sizedefault to20.- Missing
middle_nameisNone.
Be explicit in your API documentation about what is required and what has defaults.
Error Messages and Security
Validation errors become part of your API responses. They should help legitimate users, but not leak sensitive information.
What to Include
Good error messages:
- Say which field is invalid.
- Say what rule was violated.
- Do not reveal internal details.
Example of a good error for a public API:
{
"error": "validation_error",
"details": [
{"field": "email", "message": "invalid email address"},
{"field": "password", "message": "must be at least 8 characters"},
{"field": "age", "message": "must be an integer >= 18"}
]
}Bad examples:
"Database error: null value in column 'email'"leaks schema info."Traceback (most recent call last): ..."leaks stack traces.
Rule: Validation errors should be clear but generic, and must not expose stack traces, SQL queries, or secrets.
Differentiate validation errors (client errors, status 400) from server errors (status 500).
Centralizing Validation
Instead of scattering manual checks everywhere, centralize validation:
- Use request schemas or models (for example, Pydantic models in FastAPI).
- Use middleware or decorators to validate repeated patterns (pagination, sorting).
- Reuse validators across endpoints.
Benefits:
- Less code duplication.
- Consistent rules.
- Easier audits and updates.
Example Concept with Models
Imagine a user registration model:
from pydantic import BaseModel, EmailStr, constr
class RegisterUser(BaseModel):
email: EmailStr
password: constr(min_length=8, max_length=128)
name: constr(min_length=1, max_length=100)Your framework then:
- Parses JSON into this model.
- Automatically checks types and constraints.
- Returns clear validation errors.
Even if you do not use Pydantic, aim for a similar pattern in your framework of choice.
Practical Checklist for Input Validation
You can apply this quick checklist to each new endpoint:
- Identify all inputs:
- Path params
- Query params
- Headers
- Cookies
- Body (JSON / form)
- Files
- Define schema:
- Required fields and types.
- Min / max length or value.
- Allowed values (enums).
- Exact format (for example, ISO date).
- Add syntactic checks:
- Type conversion.
- Patterns and formats.
- Add semantic checks:
- Business rules (ranges, dates, uniqueness constraints where appropriate).
- Set limits:
- Field-level size limits.
- Total request size limit.
- File size limit.
- Use safe defaults:
- For optional fields like pagination, sorting.
- Return safe errors:
- Explain what is wrong with input.
- Do not leak internals.
- Combine with other defenses:
- Parameterized SQL.
- Output encoding.
- Authentication and authorization checks.
If you apply this consistently, you will prevent a large class of bugs and vulnerabilities before they appear.
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!