7.14. Error Responses
Table of Contents
Why Error Responses Matter
When something goes wrong in your API, the way you report the error is as important as the success responses. Good error responses make it:
- Easy for frontend developers to handle problems
- Easier to debug issues in development and production
- Possible for clients to recover automatically from some failures
Poor error responses lead to confused users, fragile clients, and hard to maintain systems.
In this chapter, you will learn how to design clear, consistent, and machine friendly error responses for REST APIs.
A good API must return:
- The correct HTTP status code, and
- A well structured error body with enough information to understand the problem.
We will focus on the response body here, since HTTP status codes are covered in the dedicated chapter.
Basic Structure of an Error Response
A typical JSON error response from a REST API has at least:
- A machine readable code
- A human readable message
For example:
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"error": "invalid_request",
"message": "The 'email' field is required."
}This is much better than returning plain text like:
HTTP/1.1 400 Bad Request
Content-Type: text/plain
Something went wrongThe plain text version is hard for a client to parse and act on.
Recommended Fields
Here is a practical and common structure:
{
"error": "validation_error",
"message": "Some fields are invalid.",
"details": [
{
"field": "email",
"message": "Email is required."
},
{
"field": "password",
"message": "Password must be at least 8 characters."
}
],
"request_id": "b4f79c90-6b63-4fd4-97ef-ef5d13a17c01"
}Field meanings:
| Field | Type | Description |
|---|---|---|
error | string | Short, machine readable error code, like validation_error. |
message | string | Short, human readable explanation. |
details | array | Optional list of specific issues (fields, constraints, etc.). |
request_id | string | Optional id for this request, useful to locate logs on the server side. |
Rule: Pick a single, consistent error response schema for your API and use it everywhere, for all endpoints and error codes.
Choosing Error Codes vs Messages
There are two layers of information:
- Error code: for machines
- Message: for humans
Machine Readable Error Codes
The error field should be something your client code can switch on:
invalid_credentialsemail_already_takenresource_not_foundrate_limit_exceededpermission_deniedvalidation_errorinternal_error
Example of how a frontend might use it:
if (response.status === 400 && responseBody.error === "validation_error") {
// highlight invalid fields in a form
}
if (response.status === 401 && responseBody.error === "invalid_credentials") {
// show "wrong email or password"
}Avoid using vague or unstable error codes like:
unknownerrorsomething_wrong
These are not helpful for clients.
Human Readable Messages
The message field is meant for developers or users. It should:
- Be short and clear
- Not expose sensitive data
- Not leak internal details, such as SQL queries or stack traces
Good examples:
"Invalid email or password.""User with given id was not found.""You are not allowed to access this resource."
Bad examples:
"NullPointerException in UserService at line 42""SELECT * FROM users WHERE id=... failed: connection reset by peer"
Internal details belong in logs, not in API responses.
Validation Error Responses
Validation errors are very common in REST APIs. You need a structure that can:
- Handle multiple fields at once
- Handle nested structures
- Be easy to display in a form
Simple Form Validation
Imagine a registration endpoint /api/users where the client sends:
{
"email": "",
"password": "123",
"age": -1
}A good error response might be:
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"error": "validation_error",
"message": "Some fields are invalid.",
"details": [
{
"field": "email",
"message": "Email is required."
},
{
"field": "password",
"message": "Password must be at least 8 characters."
},
{
"field": "age",
"message": "Age must be greater than or equal to 0."
}
]
}
The client can simply loop over details and highlight each invalid field.
Nested Field Paths
For nested JSON structures, use a dotted path or JSON pointer:
{
"profile": {
"first_name": "",
"address": {
"city": ""
}
}
}Validation errors might look like:
{
"error": "validation_error",
"message": "Some fields are invalid.",
"details": [
{
"field": "profile.first_name",
"message": "First name is required."
},
{
"field": "profile.address.city",
"message": "City is required."
}
]
}Alternative path formats:
"profile/address/city"["profile", "address", "city"]
Choose one format and use it everywhere.
Rule: For validation errors, always include:
- A top level error code such as
validation_error, and - A list of field errors with
fieldandmessage.
4xx vs 5xx Error Responses
Error responses usually fall into two big groups:
- Client errors (4xx)
- Server errors (5xx)
You already learn which HTTP codes to use in the HTTP Status Codes chapter. Here we focus on what to return in the body.
Client Error Responses (4xx)
Client errors mean the request is wrong or not allowed.
Typical examples:
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"error": "invalid_request",
"message": "Query parameter 'page' must be a positive integer."
}HTTP/1.1 401 Unauthorized
Content-Type: application/json
{
"error": "invalid_token",
"message": "Access token is missing or invalid."
}HTTP/1.1 403 Forbidden
Content-Type: application/json
{
"error": "permission_denied",
"message": "You are not allowed to delete this resource."
}HTTP/1.1 404 Not Found
Content-Type: application/json
{
"error": "resource_not_found",
"message": "User with id '1234' was not found."
}Server Error Responses (5xx)
Server errors mean the request was probably valid, but something failed on the server.
For security reasons:
- Use generic messages
- Do not include stack traces or SQL errors
- Always log internal details on the server
Example:
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
{
"error": "internal_error",
"message": "An unexpected error occurred. Please try again later.",
"request_id": "4ffdbd2d-4e93-4b3d-bd5d-7b73e3e7560f"
}
The request_id helps you find the exact error in your logs.
Handling Authentication and Authorization Errors
Authentication and authorization errors appear very often in APIs.
Missing or Invalid Credentials
When the user is not authenticated:
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer
Content-Type: application/json
{
"error": "invalid_token",
"message": "Access token is missing or invalid."
}Variations:
"error": "token_expired""error": "token_revoked""error": "authentication_required"
The message should not reveal if a user exists or not. For example, on login:
HTTP/1.1 401 Unauthorized
Content-Type: application/json
{
"error": "invalid_credentials",
"message": "Invalid email or password."
}Do not say:
"User not found""Password is incorrect"
This can help attackers guess valid accounts.
Forbidden Access
When the user is authenticated but not allowed to do something:
HTTP/1.1 403 Forbidden
Content-Type: application/json
{
"error": "permission_denied",
"message": "You do not have permission to access this resource."
}You might include extra safe information for debugging:
{
"error": "permission_denied",
"message": "You do not have permission to access this resource.",
"details": [
{
"required_role": "admin",
"user_role": "user"
}
]
}Return this only if you are comfortable exposing that level of detail.
Error Responses for Rate Limiting and Throttling
If you implement rate limiting, you should return consistent error responses so clients can back off correctly.
Typical response:
HTTP/1.1 429 Too Many Requests
Retry-After: 60
Content-Type: application/json
{
"error": "rate_limit_exceeded",
"message": "Too many requests. Please try again later.",
"details": [
{
"limit": 100,
"window": "60s",
"remaining": 0
}
]
}Here:
429tells the client they are sending too many requestsRetry-Afterindicates when to retry- The JSON body gives more detail for UI or logs
Some APIs also include headers like:
X-RateLimit-LimitX-RateLimit-RemainingX-RateLimit-Reset
These are covered in more detail in the Rate Limiting chapter.
Consistency Across the API
The most important characteristic of a good error design is consistency.
Clients should not have to guess:
- Different shapes for different endpoints
- Different fields for 4xx and 5xx
- Some errors as JSON, some as plain text, some as HTML
Define a Single Error Schema
Pick a single error schema and use it everywhere.
For example, you might define:
{
"error": "string", // required
"message": "string", // required
"details": "array", // optional
"request_id": "string" // optional
}And document it in your API docs, for example OpenAPI:
Error:
type: object
properties:
error:
type: string
description: Machine readable error code
message:
type: string
description: Human readable error message
details:
type: array
items:
type: object
description: Optional list of detailed error information
request_id:
type: string
description: Optional id used to trace the request in logs
required:
- error
- messageThen reuse it for all error responses:
- 400 Bad Request
- 401 Unauthorized
- 403 Forbidden
- 404 Not Found
- 409 Conflict
- 422 Unprocessable Entity
- 429 Too Many Requests
- 500 Internal Server Error
Rule: All your REST endpoints should, as much as possible, return errors with the same JSON format. Only the error, message, and details content should change.
Examples of Common Error Scenarios
To make these ideas concrete, here are several complete examples.
Example 1: Resource Not Found
Request:
GET /api/users/9999 HTTP/1.1
Accept: application/jsonResponse:
HTTP/1.1 404 Not Found
Content-Type: application/json
{
"error": "resource_not_found",
"message": "User with id '9999' was not found."
}Example 2: Unique Constraint Violation
Request:
POST /api/users HTTP/1.1
Content-Type: application/json
{
"email": "alice@example.com",
"password": "VeryStrongPassword123"
}If that email is already used:
HTTP/1.1 409 Conflict
Content-Type: application/json
{
"error": "email_already_taken",
"message": "A user with this email already exists."
}The server will log the actual database error internally.
Example 3: Invalid JSON Body
Request:
POST /api/users HTTP/1.1
Content-Type: application/json
{
"email": "alice@example.com",
"password": "abc" // missing quotes, invalid JSON
}Response:
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"error": "invalid_json",
"message": "Request body is not valid JSON."
}You can also include line/column info if you want, but be careful not to break the JSON.
Example 4: Business Rule Violation
Request:
POST /api/orders HTTP/1.1
Content-Type: application/json
{
"user_id": 123,
"items": [
{ "product_id": "p1", "quantity": 1000 }
]
}If your business rule is "max 100 units per item":
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"error": "business_rule_violation",
"message": "Order could not be created due to business rule violation.",
"details": [
{
"code": "max_quantity_exceeded",
"field": "items[0].quantity",
"message": "Maximum quantity for a single item is 100."
}
]
}Clients can then show a friendly message and adjust the quantity.
Security Considerations for Error Responses
Error responses can unintentionally reveal sensitive information to attackers.
Here are some important guidelines.
Do Not Leak Internals
Avoid:
- Database names or table names
- SQL queries
- Stack traces with file paths
- Internal IPs or hostnames
- Exact reasons why authentication failed
Example of a bad response:
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
{
"error": "SQLException",
"message": "SQLSTATE[42S22]: Column not found: 1054 Unknown column 'pasword' in 'field list'",
"stack_trace": "...long stack trace..."
}This leaks:
- The database type
- The actual SQL query structure
- Code structure of your application
Instead, log this on the server, and respond with a generic message.
Avoid Overly Detailed Auth Errors
During login, return a generic message such as:
{
"error": "invalid_credentials",
"message": "Invalid email or password."
}Do not send:
"No user found with this email.""Password incorrect."
This makes it easier to enumerate valid accounts.
Do Not Echo Untrusted Data Without Sanitization
Even in error messages, do not blindly include user input without escaping or filtering. For example:
{
"error": "invalid_request",
"message": "Invalid value: <script>alert(1)</script>"
}
If your client directly injects message into HTML without escaping, this can introduce XSS issues.
Rule: Error responses should be:
- Helpful, but not overly detailed
- Safe to display to end users
- Free from internal technical details and raw user input
Logging vs Error Responses
Your error response is for the client. Your logs are for the server operators. They should contain different levels of detail.
- Error responses
- Clear, but high level
- No secrets
- No internal implementation details
- Logs
- Full stack trace
- Database errors
- Context information
- Sensitive data only when strictly necessary and protected
Common pattern:
- Generate a unique
request_idfor each request - Attach it to logs for that request
- Return
request_idin all error responses
Example:
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
{
"error": "internal_error",
"message": "An unexpected error occurred. Please try again later.",
"request_id": "7b6c884b-9c7e-4bd1-8acb-8a8cb6f0bc4b"
}In your logs:
[request_id=7b6c884b-9c7e-4bd1-8acb-8a8cb6f0bc4b] ERROR: Null pointer in OrderService at line 123...This helps support teams investigate user issues.
Testing Error Responses
Testing your error responses is just as important as testing success responses.
You want to ensure that:
- Correct status codes are returned
- Error bodies follow your schema
errorfields use the documented codesdetailsare present for validation errors
Example Test Cases
For a registration endpoint /api/users:
| Scenario | Expected status | Expected error code |
|---|---|---|
Missing email | 400 | validation_error |
| Password too short | 400 | validation_error |
| Email already exists | 409 | email_already_taken |
| Invalid JSON body | 400 | invalid_json |
| Database down | 500 | internal_error |
Unauthorized access to /api/admin/users | 403 | permission_denied |
You can write automated tests that:
- Send invalid requests
- Check status codes
- Validate that the JSON has
errorandmessagefields - Verify that validation errors have a
detailsarray
This ensures your API behaves consistently, and does not accidentally leak sensitive information.
Summary
You have seen how to design effective error responses for REST APIs.
Key ideas:
- Use the right HTTP status code plus a JSON body
- Include a machine readable error code and a human readable message
- For validation, always provide field specific details
- Keep a consistent schema for all errors across your API
- Be careful not to leak internal details or secrets
- Use
request_idto link error responses to server logs - Test your error responses just like your success responses
A well designed REST API:
- Uses consistent JSON error structures,
- Returns correct status codes,
- And gives clients enough information to understand and recover from errors, without exposing internal details.
These principles apply regardless of which framework or language you use. In later chapters, you will see how to implement such error responses concretely with tools like FastAPI.
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!