29.1. Project Requirements
Table of Contents
Understanding the Project
You are going to build a Task Management API. This is a backend-only project, so there is no user interface. Other applications, such as a web frontend, mobile app, or CLI tool, will talk to your API using HTTP.
The goal of this chapter is to define what the system should do, not how you will implement it. Think of this as the contract between you and anyone who wants to use your API.
Throughout this chapter, imagine you are building something similar to a simple version of Trello or Todoist, but focused on learning backend concepts, not on every real-world feature.
High-Level Overview
At a high level, the Task Management API will let users:
- Register and log in.
- Create, read, update, and delete tasks.
- Organize tasks with attributes such as status and priority.
- Filter and sort their tasks.
- Work with due dates.
- See basic metadata like when a task was created or last updated.
The API will be RESTful and will use JSON for requests and responses.
Most endpoints will be authenticated. Each user will only be able to manage their own tasks.
Core Entities and Data Model
You will focus mainly on two entities:
- User
- Task
You might later add more (for example projects or labels), but they are not required for this first project.
User
A user represents a person using the application.
Typical fields:
| Field | Type | Example | Notes |
|---|---|---|---|
id | integer / UUID | 1 or "67e..." | Unique identifier |
email | string | "alice@example.com" | Unique, used for login |
password_hash | string | "$2b$12$..." | Hashed password, not plain text |
created_at | datetime | "2026-01-01T10:23:45Z" | When the user registered |
updated_at | datetime | "2026-01-05T08:30:01Z" | Last profile update |
The API will never return the raw password or password hash to the client.
Task
A task is an item that the user wants to track and complete.
Typical fields:
| Field | Type | Example | Notes |
|---|---|---|---|
id | integer / UUID | 42 | Unique per task |
user_id | integer / UUID | 1 | Owner of the task |
title | string | "Buy groceries" | Short name, required |
description | string / null | "Milk, eggs, bread" | Optional details |
status | enum/string | "todo", "in_progress", "done" | Controls state of task |
priority | enum/string | "low", "medium", "high" | Simple priority system |
due_date | date / null | "2026-02-01" | Deadline if any |
created_at | datetime | "2026-01-10T14:21:30Z" | When the task was created |
updated_at | datetime | "2026-01-11T09:00:00Z" | Last time the task changed |
You will define allowed values for status and priority explicitly. For example:
Status values: todo, in_progress, done
Priority values: low, medium, high
Example task in JSON:
{
"id": 42,
"title": "Buy groceries",
"description": "Milk, eggs, bread",
"status": "todo",
"priority": "medium",
"due_date": "2026-02-01",
"created_at": "2026-01-10T14:21:30Z",
"updated_at": "2026-01-10T14:21:30Z"
}Functional Requirements
Functional requirements describe what the API must do.
User Registration
Users must be able to create an account.
- Endpoint (example):
POST /auth/register - Request body (JSON):
{
"email": "alice@example.com",
"password": "StrongPassword123"
}- Rules:
emailmust be valid and unique.passwordmust meet basic strength rules (you can define minimal ones).- The password must never be stored in plain text.
- Response:
- On success, return the created user data (without password) and maybe an access token.
- On failure, return clear error messages, for example if email is already used.
Example success response:
{
"id": 1,
"email": "alice@example.com",
"created_at": "2026-01-01T10:23:45Z"
}User Login
Users must be able to log in and receive an access token.
- Endpoint:
POST /auth/login - Request body:
{
"email": "alice@example.com",
"password": "StrongPassword123"
}- Behavior:
- Verify email exists.
- Verify password matches.
- Return an authentication token (for example a JWT) that the user will use when calling other endpoints.
Example response:
{
"access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI...",
"token_type": "bearer"
}Create Task
Authenticated users can create new tasks.
- Endpoint:
POST /tasks - Authentication: required
- Request body:
{
"title": "Buy groceries",
"description": "Milk, eggs, bread",
"status": "todo",
"priority": "medium",
"due_date": "2026-02-01"
}- Rules:
titleis required, non-empty.statusdefaults to"todo"if not specified.prioritydefaults to"medium"if not specified.due_dateis optional.- The task belongs to the authenticated user, not to a random
user_idfrom input.
Example success response:
{
"id": 42,
"title": "Buy groceries",
"description": "Milk, eggs, bread",
"status": "todo",
"priority": "medium",
"due_date": "2026-02-01",
"created_at": "2026-01-10T14:21:30Z",
"updated_at": "2026-01-10T14:21:30Z"
}List Tasks
Users can list their own tasks.
- Endpoint:
GET /tasks - Authentication: required
Basic behavior:
- Return a paginated list of tasks owned by the authenticated user.
- Allow optional filtering and sorting (detailed later).
Example response:
{
"items": [
{
"id": 42,
"title": "Buy groceries",
"status": "todo",
"priority": "medium",
"due_date": "2026-02-01",
"created_at": "2026-01-10T14:21:30Z",
"updated_at": "2026-01-10T14:21:30Z"
},
{
"id": 43,
"title": "Finish report",
"status": "in_progress",
"priority": "high",
"due_date": "2026-01-15",
"created_at": "2026-01-10T16:00:00Z",
"updated_at": "2026-01-11T09:00:00Z"
}
],
"total": 2,
"page": 1,
"page_size": 20
}Get Single Task
Users can retrieve details of a single task that they own.
- Endpoint:
GET /tasks/{task_id} - Authentication: required
Example successful response:
{
"id": 43,
"title": "Finish report",
"description": "Finish the financial report for Q1",
"status": "in_progress",
"priority": "high",
"due_date": "2026-01-15",
"created_at": "2026-01-10T16:00:00Z",
"updated_at": "2026-01-11T09:00:00Z"
}If the task does not exist or belongs to another user, return an appropriate error (for example 404).
Update Task
Users can update their tasks.
You will support:
- Full update with
PUT(client sends all fields). - Partial update with
PATCH(client sends only changed fields).
Example PATCH /tasks/43 request:
{
"status": "done",
"priority": "medium"
}Rules:
- Validate enum fields.
- Do not allow users to change
idoruser_id. - Update
updated_attimestamp.
Example response:
{
"id": 43,
"title": "Finish report",
"description": "Finish the financial report for Q1",
"status": "done",
"priority": "medium",
"due_date": "2026-01-15",
"created_at": "2026-01-10T16:00:00Z",
"updated_at": "2026-01-12T12:30:00Z"
}Delete Task
Users can delete tasks that they own.
- Endpoint:
DELETE /tasks/{task_id} - Authentication: required
Behavior:
- If task exists and belongs to user, delete it.
- Return either:
- HTTP 204 with no content, or
- A simple JSON confirmation like
{ "detail": "Task deleted" }.
Non-Functional Requirements
Non-functional requirements describe how well the system should perform its functions.
Reliability and Consistency
- When an API call returns success, the change must really be stored in the database.
- A task that is created must appear in subsequent list and get endpoints.
- Use transactions for operations that modify data to avoid partial updates.
Security (High Level)
- All state-changing endpoints must be authenticated.
- Users must not be able to access or modify other users' tasks.
- Passwords must be stored securely using proper hashing.
- Do not leak internal errors or stack traces in responses in production-like settings.
Performance
This is a learning project, so performance is not the main goal, but:
- The API should respond in a reasonable time for a small number of users.
- Basic indexes on primary keys should be used in the database.
- Pagination is required to avoid returning unbounded lists of tasks.
Maintainability
- The project structure must be clear, with separation between routes, models, and database logic.
- Code should follow consistent style and naming.
- Error handling should be centralized as much as possible.
API Design Overview
Here is a possible overview of the main endpoints. You will refine these in later chapters.
| Method | Path | Description | Auth required |
|---|---|---|---|
| POST | /auth/register | Register a new user | No |
| POST | /auth/login | Log in and get access token | No |
| GET | /tasks | List current user's tasks | Yes |
| POST | /tasks | Create a new task | Yes |
| GET | /tasks/{id} | Get a specific task | Yes |
| PUT | /tasks/{id} | Fully update a task | Yes |
| PATCH | /tasks/{id} | Partially update a task | Yes |
| DELETE | /tasks/{id} | Delete a task | Yes |
You may later add endpoints for user profile, health checks, or admin tasks, but they are optional for this project.
Authentication and Authorization Requirements
You will implement a simple token-based authentication flow.
- After login, clients receive an access token.
- Clients send this token with each protected request, usually in the
Authorizationheader, for example:
Authorization: Bearer <access_token>- The backend validates the token and identifies the user.
- All task endpoints use this identity to:
- Link new tasks to the correct user.
- Filter tasks by owner.
- Prevent access to other users' tasks.
Important: Every data access for tasks must be restricted to the authenticated user. Never let a user read, update, or delete tasks that do not belong to them.
You do not need extremely advanced security features for this first project, but you should:
- Validate tokens.
- Expire tokens after a certain time, or at least design your system with that in mind.
- Handle unauthenticated requests with a proper 401 status.
Validation and Error Handling Requirements
Requests must be validated so that the server never writes invalid data to the database.
Input Validation
Examples of validation rules:
title:- Required for task creation.
- Minimum length, for example 1 character.
- Maximum length, for example 200 characters.
status:- Must be one of
todo,in_progress,done. priority:- Must be one of
low,medium,high. due_date:- Must be a valid date in ISO 8601 format, for example
"2026-02-01". email:- Must look like a valid email address.
- Must be unique.
password:- Minimum length, for example 8 characters.
If validation fails, the API must return:
- An appropriate HTTP status code, usually 400.
- A clear error body.
Example error response:
{
"detail": [
{
"field": "title",
"message": "Title must not be empty"
},
{
"field": "priority",
"message": "Invalid priority, allowed: low, medium, high"
}
]
}Authentication and Authorization Errors
- If the
Authorizationheader is missing or invalid: - Return HTTP 401.
- If the user is authenticated but tries to access someone else's resource:
- Return HTTP 403 or 404, depending on your design.
Example 401 response:
{
"detail": "Not authenticated"
}Example 403/404 response:
{
"detail": "Task not found"
}Other Errors
- If a task ID does not exist: return 404.
- If the method is not allowed on a route: return 405.
- For unexpected server errors: return 500 with a generic message, not internal details.
Pagination, Filtering, and Sorting
The list endpoint for tasks must support basic pagination. Filtering and sorting are strongly recommended to make the API more practical.
Pagination
Use query parameters, for example:
GET /tasks?page=1&page_size=20
Rules:
pagedefaults to 1.page_sizedefaults to a reasonable number, for example 20.page_sizehas a maximum limit, for example 100.
Response should contain:
- The items for that page.
- Metadata:
total,page,page_size.
Example:
{
"items": [ /* tasks */ ],
"total": 57,
"page": 2,
"page_size": 20
}Filtering
Allow users to filter tasks by attributes using query parameters, for example:
GET /tasks?status=todoGET /tasks?priority=highGET /tasks?status=done&priority=low
You might also allow filtering by due date, for example:
GET /tasks?due_before=2026-02-01GET /tasks?due_after=2026-01-01
Sorting
Allow sorting by some fields, for example:
GET /tasks?sort_by=due_date&sort_order=ascGET /tasks?sort_by=created_at&sort_order=desc
Rules:
sort_byallowed values:due_date,created_at,priority, etc.sort_orderallowed values:asc,desc.
Example:
GET /tasks?status=todo&sort_by=due_date&sort_order=asc&page=1&page_size=10Example Usage Scenario
To make all requirements concrete, imagine the following scenario and how your API would be used.
- Alice registers
Request:
POST /auth/register
Content-Type: application/json
{
"email": "alice@example.com",
"password": "StrongPassword123"
}Response: user info.
- Alice logs in
POST /auth/login
Content-Type: application/json
{
"email": "alice@example.com",
"password": "StrongPassword123"
}Response:
{
"access_token": "eyJhbGciOiJIUzI1NiIs...",
"token_type": "bearer"
}- Alice creates a task
POST /tasks
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
Content-Type: application/json
{
"title": "Buy groceries",
"description": "Milk, eggs, bread",
"priority": "medium",
"due_date": "2026-02-01"
}- Alice lists her tasks
GET /tasks?status=todo&sort_by=due_date&sort_order=asc
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...- Alice marks the task as done
PATCH /tasks/42
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
Content-Type: application/json
{
"status": "done"
}- Alice deletes the task
DELETE /tasks/42
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...If Bob tries to access task 42 that belongs to Alice, he must receive an error and never see the task data.
Acceptance Criteria Checklist
Use this checklist to verify that your implementation meets the requirements:
Functional checklist
- [ ] Users can register with a unique email and password.
- [ ] Users can log in and receive an access token.
- [ ] Authenticated users can create tasks.
- [ ] Authenticated users can list only their tasks.
- [ ] Authenticated users can get, update, and delete their own tasks.
- [ ] Users cannot access other users' tasks.
- [ ] Task list endpoint supports pagination.
- [ ] Task list endpoint supports basic filtering and sorting.
- [ ] All input is validated and invalid data is rejected with clear errors.
You will implement these requirements step by step in the following chapters, where you will design the project structure, the database, and the actual CRUD operations.
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!