7.13. HTTP Status Codes
Table of Contents
Understanding HTTP Status Codes
HTTP status codes are short numeric codes that tell the client what happened with its request. Every HTTP response has a status line, which includes:
- The HTTP version
- The status code (like
200) - A short reason phrase (like
OK)
Example raw response start:
HTTP/1.1 200 OK
Content-Type: application/jsonAs a backend developer, returning the correct status code is critical. It affects:
- How browsers behave
- How API clients handle errors and retries
- How other developers understand your API
In this chapter we will focus on how to use status codes correctly in REST APIs, not the full protocol theory behind them.
Important rule:
Always return a status code that matches what actually happened on the server.
Never use 200 OK for everything.
Status Code Categories
All status codes are 3 digits. The first digit describes the category:
| Range | Category | Typical Meaning |
|---|---|---|
| 1xx | Informational | Request received, processing continues |
| 2xx | Success | Request was successfully received and handled |
| 3xx | Redirection | Client must take additional action |
| 4xx | Client error | Problem with the request |
| 5xx | Server error | Server failed to process a valid request |
For REST APIs, you will mostly use:
- 2xx codes for successful operations
- 4xx codes for invalid input or unauthorized access
- 5xx codes when something goes wrong on your server
Common 2xx Success Codes
2xx codes mean "the request was successfully received, understood, and accepted."
200 OK
Use when the request succeeded and you return a response body.
Typical cases:
- Successful GET request
- Successful PUT or PATCH where you return the updated resource
- Successful POST where you choose to return a full response body
Example: GET a list of users
GET /users HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
[
{"id": 1, "name": "Alice"},
{"id": 2, "name": "Bob"}
]201 Created
Use when a new resource has been created as a result of the request, usually with POST.
You should also include a Location header with the URL of the new resource.
Example: Create a new user
POST /users HTTP/1.1
Content-Type: application/json
{"name": "Alice"}
HTTP/1.1 201 Created
Location: /users/1
Content-Type: application/json
{"id": 1, "name": "Alice"}
In REST APIs, 201 Created is preferred over 200 OK for successful creation.
202 Accepted
Use when the request has been accepted for processing, but the processing is not complete yet.
Typical for:
- Long-running operations
- Background jobs
Example: Start a report generation job
POST /reports HTTP/1.1
Content-Type: application/json
{"type": "monthly"}
HTTP/1.1 202 Accepted
Content-Type: application/json
{"job_id": "abc123", "status": "pending"}The actual report will be generated later. The client might poll another endpoint to check status.
204 No Content
Use when the request succeeded but there is no response body.
Typical cases:
- Successful DELETE
- Successful PUT or PATCH when you choose not to return content
- Some POST actions that do not return data
Example: Delete a user
DELETE /users/1 HTTP/1.1
HTTP/1.1 204 No Content
Do not include a response body with 204. Many HTTP clients will ignore it.
Common 3xx Redirection Codes
In pure APIs, 3xx codes are less common but still important.
301 Moved Permanently
Use when a resource has permanently moved to a new URL. Helpful when you reorganize your API.
Example:
GET /v1/users HTTP/1.1
HTTP/1.1 301 Moved Permanently
Location: /v2/usersClients should update their URLs.
302 Found
Traditional web redirect, often used after form submissions in browser apps.
In pure JSON APIs, you usually avoid 302, and instead return 200/201 with JSON that tells the client what to do.
304 Not Modified
Used with caching. Means the resource has not changed since the last request, so the client can use its cached version.
Example flow:
- Client sends
If-None-Matchheader with an ETag - Server responds with 304 if nothing changed
GET /users/1 HTTP/1.1
If-None-Match: "v1"
HTTP/1.1 304 Not ModifiedNo response body is sent.
Common 4xx Client Error Codes
4xx codes mean "the client did something wrong" or "the client must change something."
400 Bad Request
Use when the request is malformed or invalid, and no more specific 4xx code fits.
Typical cases:
- Invalid JSON
- Missing required fields
- Invalid field formats (if you choose not to use 422)
Example: Invalid JSON
POST /users HTTP/1.1
Content-Type: application/json
{"name": "Alice" // missing closing brace
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"error": "invalid_request",
"message": "Body contains invalid JSON"
}401 Unauthorized
Despite the name, 401 actually means "unauthenticated." Use when the request has no valid authentication credentials.
Typical cases:
- Missing token
- Expired token
- Invalid token
Example: Missing token
GET /me HTTP/1.1
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer
Content-Type: application/json
{
"error": "unauthorized",
"message": "Authentication credentials were not provided"
}403 Forbidden
Use when the user is authenticated, but does not have permission to perform the action.
Comparison:
| Code | Meaning | Example |
|---|---|---|
| 401 | Not authenticated | Not logged in |
| 403 | Authenticated, but not allowed | Logged in as user, trying to access admin page |
Example: Normal user trying to access admin data
GET /admin/users HTTP/1.1
Authorization: Bearer user-token
HTTP/1.1 403 Forbidden
Content-Type: application/json
{
"error": "forbidden",
"message": "You do not have permission to access this resource"
}404 Not Found
Use when a resource cannot be found, or you do not want to reveal it exists.
Typical cases:
- GET, PUT, PATCH, DELETE on non-existing resource
- Intentionally hide whether resource exists (for security or privacy)
Example: User does not exist
GET /users/9999 HTTP/1.1
HTTP/1.1 404 Not Found
Content-Type: application/json
{
"error": "not_found",
"message": "User not found"
}Security example: Hiding whether an email exists in the system:
POST /password-reset HTTP/1.1
Content-Type: application/json
{"email": "unknown@example.com"}
HTTP/1.1 200 OK
Content-Type: application/json
{"message": "If an account with this email exists, a reset link has been sent"}You might still log internally that the email was not found, but you do not reveal it to the client.
405 Method Not Allowed
Use when the HTTP method is not allowed for the requested resource.
Example: You support GET on /users/1, but not POST.
POST /users/1 HTTP/1.1
HTTP/1.1 405 Method Not Allowed
Allow: GET, PUT, DELETE
Content-Type: application/json
{
"error": "method_not_allowed",
"message": "Method POST is not allowed for this resource"
}409 Conflict
Use when the request conflicts with the current state of the resource.
Typical cases:
- Creating a resource that already exists (e.g. username taken)
- Version conflicts with optimistic locking
Example: Username already taken
POST /users HTTP/1.1
Content-Type: application/json
{"username": "alice"}
HTTP/1.1 409 Conflict
Content-Type: application/json
{
"error": "conflict",
"message": "Username already exists"
}410 Gone
Use when a resource used to exist, but has been permanently removed and will not return.
Less common, but useful when you want to explicitly say a resource is gone, not just unknown.
415 Unsupported Media Type
Use when the server cannot handle the format of the body.
Example: API expects JSON, but client sends XML.
POST /users HTTP/1.1
Content-Type: application/xml
<user><name>Alice</name></user>
HTTP/1.1 415 Unsupported Media Type
Content-Type: application/json
{
"error": "unsupported_media_type",
"message": "Content type application/xml is not supported. Use application/json"
}422 Unprocessable Entity
Common in modern APIs for semantic validation errors. The request body is well-formed, but the data is invalid.
Typical cases:
- Field too short or too long
- Email not a valid email
- Missing required field in a JSON body
Many frameworks, such as FastAPI, use 422 by default for validation errors.
Example: Invalid data
POST /users HTTP/1.1
Content-Type: application/json
{"email": "not-an-email", "age": 10}
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/json
{
"error": "validation_error",
"details": [
{"field": "email", "message": "Invalid email address"},
{"field": "age", "message": "Must be at least 13"}
]
}429 Too Many Requests
Use when a client has sent too many requests in a given period, for rate limiting.
Example:
GET /search?q=test HTTP/1.1
HTTP/1.1 429 Too Many Requests
Retry-After: 60
Content-Type: application/json
{
"error": "too_many_requests",
"message": "Rate limit exceeded. Try again in 60 seconds"
}
The Retry-After header tells the client when to try again.
Common 5xx Server Error Codes
5xx codes mean something went wrong on the server side.
Important rule:
Use 5xx codes only when the server is at fault, not the client.
If the client sent a bad request, use a 4xx code, even if your code crashed while handling it.
500 Internal Server Error
Generic server error when something unexpected happens and no specific 5xx code applies.
Typical cases:
- Unhandled exceptions
- Programming errors
- Misconfigurations
Example:
GET /users HTTP/1.1
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
{
"error": "internal_server_error",
"message": "An unexpected error occurred"
}In production, do not return stack traces or sensitive details to the client. Log them on the server instead.
502 Bad Gateway
Use when your server is a gateway or proxy and receives an invalid response from an upstream server.
Example scenarios:
- Your API server behind Nginx, and Nginx cannot reach your app
- API gateway cannot talk to a microservice
In many setups, the reverse proxy (like Nginx) or load balancer will return 502, not your application code.
503 Service Unavailable
Use when the service is temporarily unavailable, for example:
- Maintenance windows
- Overloaded server
- Database down
You can include a Retry-After header to tell clients how long to wait.
Example:
GET /users HTTP/1.1
HTTP/1.1 503 Service Unavailable
Retry-After: 120
Content-Type: application/json
{
"error": "service_unavailable",
"message": "Service is temporarily down for maintenance"
}504 Gateway Timeout
Use when acting as a gateway or proxy and an upstream server takes too long to respond.
Example:
- API gateway calls a microservice that does not respond within the timeout
Again, often returned by infrastructure rather than your own application code.
Choosing the Right Status Code in REST APIs
You will often need to decide which code to use. Here are common REST actions and typical codes.
Typical Status Codes by HTTP Method
| Operation | Method | Typical Status Codes |
|---|---|---|
| Get a list of resources | GET | 200 |
| Get a single resource | GET | 200, 404 |
| Create a new resource | POST | 201, 400, 401, 403, 409, 422 |
| Update a resource fully | PUT | 200, 204, 400, 401, 403, 404, 409, 422 |
| Update a resource partially | PATCH | 200, 204, 400, 401, 403, 404, 409, 422 |
| Delete a resource | DELETE | 204, 404, 401, 403 |
| Non-idempotent action (e.g. login) | POST | 200, 400, 401, 422 |
Example: User Registration Endpoint
Requirements:
- Create user: return 201 and user data
- Validation errors: return 422 with details
- Username already exists: return 409
Possible responses:
POST /users HTTP/1.1
Content-Type: application/json
{"username": "alice", "email": "alice@example.com", "password": "short"}
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/json
{
"error": "validation_error",
"details": [
{"field": "password", "message": "Password must be at least 8 characters"}
]
}POST /users HTTP/1.1
Content-Type: application/json
{"username": "alice", "email": "alice@example.com", "password": "longpassword"}
HTTP/1.1 201 Created
Location: /users/1
Content-Type: application/json
{"id": 1, "username": "alice", "email": "alice@example.com"}POST /users HTTP/1.1
Content-Type: application/json
{"username": "alice", "email": "another@example.com", "password": "longpassword"}
HTTP/1.1 409 Conflict
Content-Type: application/json
{
"error": "conflict",
"message": "Username already exists"
}Example: Login Endpoint
Requirements:
- Wrong credentials: 401
- Missing fields: 400 or 422
- Successful login: 200, return token
POST /login HTTP/1.1
Content-Type: application/json
{"username": "alice", "password": "wrong"}
HTTP/1.1 401 Unauthorized
Content-Type: application/json
{
"error": "invalid_credentials",
"message": "Username or password is incorrect"
}POST /login HTTP/1.1
Content-Type: application/json
{"username": "alice", "password": "correct-password"}
HTTP/1.1 200 OK
Content-Type: application/json
{"access_token": "jwt-token-here", "token_type": "bearer"}Status Codes and Idempotency
Idempotent methods, such as GET, PUT, DELETE, should have consistent results if called multiple times.
Status codes help communicate this:
- Repeated DELETE of the same resource:
- First time:
204 No Content - Second time: often
404 Not Found - Repeated POST to create the same resource:
- Could be
201 Createdthen409 Conflictif you enforce uniqueness
Example:
DELETE /users/1 HTTP/1.1
HTTP/1.1 204 No ContentSecond attempt:
DELETE /users/1 HTTP/1.1
HTTP/1.1 404 Not Found
Content-Type: application/json
{"error": "not_found", "message": "User not found"}
Some APIs choose to return 204 both times for "delete if exists" semantics, but you must document this behavior clearly.
Designing Error Responses
Status codes are numeric and short. API clients also need structured error information.
A common pattern is to combine:
- A proper HTTP status code
- A JSON body with machine readable fields and human messages
Example standard structure:
{
"error": "validation_error",
"message": "There were validation errors",
"details": [
{"field": "email", "message": "Invalid email address"}
]
}Or for a simple not found:
{
"error": "not_found",
"message": "User not found"
}
Important rule:
Use HTTP status codes for the high level result,
and use JSON body fields for detailed error information.
Summary Cheat Sheet
| Code | Phrase | Typical Use in REST APIs |
|---|---|---|
| 200 | OK | Successful GET, PUT, PATCH, POST with body |
| 201 | Created | Successful creation of a new resource |
| 202 | Accepted | Accepted for async processing |
| 204 | No Content | Successful delete or update without body |
| 301 | Moved Permanently | Resource permanently moved |
| 304 | Not Modified | Caching, resource unchanged |
| 400 | Bad Request | Malformed request, invalid syntax |
| 401 | Unauthorized | Authentication required or invalid |
| 403 | Forbidden | Authenticated but not allowed |
| 404 | Not Found | Resource does not exist |
| 405 | Method Not Allowed | Method not supported for this endpoint |
| 409 | Conflict | State conflict, duplicate resource, etc. |
| 410 | Gone | Resource permanently removed |
| 415 | Unsupported Media Type | Wrong Content-Type |
| 422 | Unprocessable Entity | Semantic validation errors |
| 429 | Too Many Requests | Rate limit reached |
| 500 | Internal Server Error | Unexpected server error |
| 502 | Bad Gateway | Invalid response from upstream |
| 503 | Service Unavailable | Temporary overload or maintenance |
| 504 | Gateway Timeout | Upstream service timeout |
As you build APIs, get into the habit of consciously choosing the status code. This small detail makes your backend more predictable, easier to integrate with, and easier to debug.
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!