29.5. Validation
Table of Contents
Why Validation Matters in a Task Management API
In a Task Management API, almost every endpoint accepts data from clients: creating tasks, updating them, assigning users, setting due dates, and more. Validation is the process of checking that this incoming data is correct, safe, and complete before your application uses it.
Without validation:
- You may insert broken or incomplete data into the database.
- Your API may behave unpredictably.
- Attackers may exploit weak input checks.
With good validation:
- Your data stays consistent.
- Your API is easier to use and debug.
- Errors are caught early and reported clearly to clients.
In this chapter you will focus on validation that is specific to your Task Management API project, not general validation theory.
Typical Data to Validate in a Task App
Most Task Management APIs use data structures similar to:
- Task
- User (already mostly handled in the authentication project later, but can exist here too)
- Project or List (optional, depending on your design)
Let us assume a simple Task model for this project.
Example schema for a task:
| Field | Type | Required | Example |
|---|---|---|---|
| id | integer | no (auto) | 1 |
| title | string | yes | "Buy groceries" |
| description | string / null | no | "Milk, eggs, bread" |
| status | string | yes | "todo" |
| priority | integer | no | 1 |
| due_date | datetime/null | no | "2026-09-01T10:00:00Z" |
| created_at | datetime | no (auto) | "2026-08-01T12:00:00Z" |
| updated_at | datetime | no (auto) | "2026-08-01T12:10:00Z" |
| owner_id | integer | yes | 42 |
For each field you must decide:
- Is it required when creating a task?
- Can it be changed when updating a task?
- What constraints does it have?
Example decisions:
titlemust be a non-empty string, maximum 200 characters.statuscan only be one of:"todo","in_progress","done".prioritymust be an integer between 1 and 5.due_datecannot be a date in the past.owner_idmust refer to an existing user (business rule, often checked in the service / database layer).
Types of Validation You Will Use
You will typically use three layers of validation in this project:
- Request body schema validation
Use Pydantic models (in FastAPI) to ensure correct types and basic constraints. - Business rule validation
Custom checks that depend on your application logic, such as: - “A completed task cannot have a due date in the past changed to a future date.”
- “Only the owner can update a task.”
- Database-level validation
Constraints in the database to ensure that even if your API bug lets bad data pass, the database rejects it.
You will focus mainly on the first two in this project chapter, but be aware of the third.
Using Pydantic Models for Request Validation
In FastAPI, Pydantic models are the main tool for validating request bodies.
Example Pydantic models for tasks:
from datetime import datetime
from typing import Optional, Literal
from pydantic import BaseModel, Field
class TaskBase(BaseModel):
title: str = Field(..., min_length=1, max_length=200)
description: Optional[str] = Field(None, max_length=2000)
status: Literal["todo", "in_progress", "done"] = "todo"
priority: Optional[int] = Field(None, ge=1, le=5)
due_date: Optional[datetime] = None
class TaskCreate(TaskBase):
# For creation, all fields from TaskBase are allowed.
# You could also override or add required fields here.
pass
class TaskUpdate(BaseModel):
# All fields optional for partial updates
title: Optional[str] = Field(None, min_length=1, max_length=200)
description: Optional[str] = Field(None, max_length=2000)
status: Optional[Literal["todo", "in_progress", "done"]] = None
priority: Optional[int] = Field(None, ge=1, le=5)
due_date: Optional[datetime] = NoneKey things happening here:
Field(..., ...)means the field is required.min_length,max_length,ge(greater or equal),le(less or equal) add constraints.Literal["todo", "in_progress", "done"]restricts the allowed values.
Always define separate models for creation and update if your rules differ. Never assume that the same model fits both POST /tasks and PATCH /tasks/{id}.
Validating Task Creation
For creating tasks, you usually require the minimum necessary fields and apply stricter rules.
Example FastAPI endpoint:
from fastapi import APIRouter, Depends, status
from .schemas import TaskCreate, TaskRead
from .dependencies import get_current_user
from .services import task_service
router = APIRouter()
@router.post("/tasks", response_model=TaskRead, status_code=status.HTTP_201_CREATED)
async def create_task(
task_in: TaskCreate,
current_user = Depends(get_current_user),
):
task = await task_service.create_task(task_in, owner_id=current_user.id)
return taskSchema-level creation rules
Typical validation rules for task creation:
titleis required and cannot be empty.statustypically defaults to"todo"and may be optional.priorityis optional but must be in a specific range if provided.due_datecan be optional, but if provided it must not be in the past.
You can implement the “due date cannot be in the past” rule inside a Pydantic validator.
from pydantic import validator
from datetime import datetime, timezone
class TaskCreate(TaskBase):
@validator("due_date")
def due_date_cannot_be_past(cls, value):
if value is None:
return value
now = datetime.now(timezone.utc)
if value < now:
raise ValueError("due_date cannot be in the past")
return valueNow, if a client sends:
{
"title": "Finish report",
"due_date": "2020-01-01T10:00:00Z"
}
FastAPI automatically returns a 422 Unprocessable Entity response with details of the validation error, without your route function running.
Validating Task Updates
For updates, clients often send only fields they want to change. That is why the update model has all fields optional.
Example `PATCH /tasks/{id}` endpoint
from fastapi import HTTPException
@router.patch("/tasks/{task_id}", response_model=TaskRead)
async def update_task(
task_id: int,
task_in: TaskUpdate,
current_user = Depends(get_current_user),
):
task = await task_service.get_task(task_id)
if task is None:
raise HTTPException(status_code=404, detail="Task not found")
# Business rule: only the owner can update
if task.owner_id != current_user.id:
raise HTTPException(status_code=403, detail="Not allowed to update this task")
updated_task = await task_service.update_task(task, task_in)
return updated_taskHandling partial updates correctly
When you apply patch data, use .dict(exclude_unset=True) so that missing fields are not set to None by mistake.
async def update_task(task, task_in: TaskUpdate):
update_data = task_in.dict(exclude_unset=True)
for field, value in update_data.items():
setattr(task, field, value)
# Save task in database here
return task
For partial updates, always use exclude_unset=True or equivalent logic. Otherwise you may overwrite existing values with null for fields that the client did not intend to change.
Update-specific rules
Some rules only make sense on update:
- You might not allow changing
statusfrom"done"back to"todo". - You might require that
due_datebe later thancreated_at. - You might not allow changing
owner_idat all.
These rules are usually enforced in your service layer, not in the Pydantic model, because they depend on existing data in the database.
Example:
from fastapi import HTTPException
async def update_task(task, task_in: TaskUpdate):
data = task_in.dict(exclude_unset=True)
new_status = data.get("status")
if task.status == "done" and new_status and new_status != "done":
raise HTTPException(
status_code=400,
detail="Cannot move a completed task back to todo or in_progress",
)
# apply allowed changes
for field, value in data.items():
setattr(task, field, value)
# save and return
return taskValidating IDs and Path Parameters
Validation is not only for request bodies. Path parameters and query parameters also benefit from validation.
Validating `task_id`
from fastapi import Path
@router.get("/tasks/{task_id}")
async def get_task(
task_id: int = Path(..., ge=1)
):
# ...
...Here:
task_idmust be an integer.- It must be greater or equal to 1.
If the client calls /tasks/0 or /tasks/-5, FastAPI will return a validation error.
Consistent validation of identifiers
Use similar constraints for other identifiers:
user_id,project_id, etc. should usually be positive integers.- For UUID based IDs, use the
UUIDtype.
Example:
from uuid import UUID
@router.get("/tasks/{task_id}")
async def get_task(task_id: UUID):
...Business Rule Validation Inside Services
Schema validation checks the format and simple constraints of input, but it does not know your business rules. The service layer is a good place to enforce rules such as ownership, status transitions, or limits.
Typical business constraints for a task system:
| Rule | Where to enforce |
|---|---|
| A user cannot create more than 1000 active tasks | Service layer / database |
| Only the task owner can update or delete a task | Service layer |
| Status can only move in a certain order | Service layer |
| Due date cannot be before the creation date | Service layer |
Example: status transition validation
ALLOWED_TRANSITIONS = {
"todo": {"in_progress", "done"},
"in_progress": {"todo", "done"},
"done": set(), # done is final
}
def validate_status_transition(old_status: str, new_status: str):
allowed = ALLOWED_TRANSITIONS.get(old_status, set())
if new_status not in allowed:
raise HTTPException(
status_code=400,
detail=f"Cannot change status from {old_status} to {new_status}",
)
Then call validate_status_transition inside your update function when status is being changed.
Business rules usually depend on existing data, so they cannot live entirely inside Pydantic models. Keep them in your service / domain layer so that they can see the full context.
Preventing Invalid Data at the Database Level
In addition to API validation, add constraints in your database. This avoids data corruption if there is a bug or if someone writes directly to the database.
Common database constraints for tasks:
titlecannot be empty (check or not-null with minimum length).statusmust be in an enumerated set.prioritybetween 1 and 5.owner_idmust reference an existing user (FOREIGN KEY).
Example table definition in SQL (PostgreSQL style):
CREATE TABLE tasks (
id SERIAL PRIMARY KEY,
title VARCHAR(200) NOT NULL,
description TEXT,
status VARCHAR(20) NOT NULL DEFAULT 'todo',
priority INTEGER,
due_date TIMESTAMPTZ,
owner_id INTEGER NOT NULL REFERENCES users(id),
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CHECK (LENGTH(title) > 0),
CHECK (priority IS NULL OR (priority >= 1 AND priority <= 5)),
CHECK (status IN ('todo', 'in_progress', 'done'))
);If your API forgets to validate one of these rules, the database will still block invalid records.
Returning Helpful Validation Errors
When validation fails, clients need clear information. FastAPI returns a structured error format by default, but when you raise your own HTTPException you must choose helpful messages.
Example validation error structure
FastAPI typical 422 error body:
{
"detail": [
{
"loc": ["body", "title"],
"msg": "ensure this value has at least 1 characters",
"type": "value_error.any_str.min_length",
"ctx": {"limit_value": 1}
}
]
}
For your own business rule errors, return a clear detail message:
raise HTTPException(
status_code=400,
detail="Cannot change status from done to todo"
)Simple guidelines:
- Use
400 Bad Requestfor business rule violations. - Use
404 Not Foundwhen the resource does not exist. - Use
403 Forbiddenfor permission issues.
Example: Full Validation Flow for Creating a Task
Let us walk through what happens when a client calls POST /tasks with JSON:
{
"title": "Plan weekend trip",
"status": "finished",
"priority": 10,
"due_date": "2020-01-01T10:00:00Z"
}Assume your models and validators are set up as earlier.
- JSON parsing
FastAPI reads the JSON and tries to map it toTaskCreate. - Schema validation
Pydantic checks: titleis a string and at least 1 character ✅statusis aLiteral["todo", "in_progress", "done"]❌ here you passed"finished"prioritybetween 1 and 5 ❌ you passed10due_datenot in the past ❌ date is in the past- Error response
FastAPI never calls your route function. Instead it returns a422response listing all validation errors.
Example response body (simplified):
{
"detail": [
{
"loc": ["body", "status"],
"msg": "unexpected value; permitted: 'todo', 'in_progress', 'done'",
"type": "type_error.literal"
},
{
"loc": ["body", "priority"],
"msg": "ensure this value is less than or equal to 5",
"type": "value_error.number.not_le",
"ctx": {"limit_value": 5}
},
{
"loc": ["body", "due_date"],
"msg": "due_date cannot be in the past",
"type": "value_error"
}
]
}The client can now fix all problems and send a new request.
Practical Checklist for Validation in This Project
When implementing validation in your Task Management API, walk through this checklist:
Validation Checklist for the Task API
- Define Pydantic models for:
TaskCreate(required fields for creating)TaskUpdate(all fields optional for partial updates)TaskRead(response model, usually includesid, timestamps, and owner info)- Add constraints in models:
title: required, non-empty,max_lengthdescription: optional,max_lengthstatus: allowed values onlypriority: optional, numeric rangedue_date: custom validator to prevent past dates- Validate path and query parameters:
task_id: positive integer- pagination parameters: non-negative, with sensible maximum
- Enforce business rules in service layer:
- Ownership checks for update and delete
- Status transition rules
- Limits per user if needed
- Add database constraints:
NOT NULLfor required fieldsCHECKconstraints for ranges and statusFOREIGN KEYconstraints for owners and relations- Return clear error messages and HTTP status codes:
400for business rule violations403for permission errors404for missing resources- Default
422for schema validation errors
If you implement these steps consistently, your Task Management API will be much more robust, predictable, and safe to use.
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!