2.11. HTTP Status Codes
Table of Contents
Why HTTP Status Codes Matter
When a client sends an HTTP request to a server, the server always replies with an HTTP response that starts with a status line. Part of that status line is a status code, such as 200, 404, or 500.
The status code tells the client what happened:
- Did the request work?
- Was something wrong with what the client sent?
- Did something break on the server?
As a backend developer you must always pick the correct status code. It affects:
- How browsers behave, for example when to redirect.
- How API clients handle errors or retries.
- How monitoring and alerts detect problems.
An HTTP response must have exactly one status code.
Clients rely on accurate status codes to understand the result of a request.
Structure of an HTTP Status Code
A status code has:
- A 3 digit number, for example
200 - A reason phrase, for example
OK
Example status line:
HTTP/1.1 200 OKThe number is what really matters to machines. The reason phrase is mostly for humans and logging.
Status Code Classes
The first digit groups codes into classes:
| Class | Range | Meaning | Typical use example |
|---|---|---|---|
| 1xx | 100–199 | Informational, request still in progress | Rare in basic APIs |
| 2xx | 200–299 | Success | Request worked |
| 3xx | 300–399 | Redirection | Use another URL or location |
| 4xx | 400–499 | Client error | Client sent something invalid |
| 5xx | 500–599 | Server error | Server failed while handling a valid request |
Rule:
- If the client did something wrong, use 4xx.
- If the server failed or crashed, use 5xx.
- If all is fine, use 2xx.
Common 2xx Success Codes
200 OK
Used when a request is successfully processed and:
- There is a response body, and
- Nothing special like creation or deletion needs to be indicated.
Examples:
GET /users/123 HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
{"id": 123, "name": "Alice"}PUT /users/123 HTTP/1.1
Content-Type: application/json
{"name": "New Name"}
HTTP/1.1 200 OK
Content-Type: application/json
{"id": 123, "name": "New Name"}
When building APIs, 200 OK is the "default success" for many operations.
201 Created
Use 201 Created when the server created a new resource as a result of the request, typically with POST.
Key points:
- A new resource was created.
- The response should usually include:
- A
Locationheader with the URL of the new resource. - Optionally, the representation of the created resource in the body.
Example:
POST /users HTTP/1.1
Content-Type: application/json
{"name": "Alice"}
HTTP/1.1 201 Created
Location: /users/123
Content-Type: application/json
{"id": 123, "name": "Alice"}204 No Content
Use 204 No Content when the request was successful but there is no response body.
Typical for:
- Successful
DELETE - Some
PUTorPATCHwhere you do not need to send updated data back
Example:
DELETE /users/123 HTTP/1.1
HTTP/1.1 204 No Content
If you send a body with 204, most clients will ignore it. Avoid sending a body with this code.
Common 3xx Redirection Codes
3xx responses tell the client that the resource is available somewhere else or has changed location.
Redirection responses usually include a Location header.
301 Moved Permanently
Resource has permanently moved to a new URL.
Use cases:
- URL structure changed, and you want browsers and search engines to use the new URL.
- For example, you moved
/old-pathto/new-path.
Example:
GET /old-path HTTP/1.1
HTTP/1.1 301 Moved Permanently
Location: /new-path
Browsers may cache this and always go to /new-path next time.
302 Found and 307 Temporary Redirect
Both indicate a temporary redirect, but they differ in method handling.
302 Found(historic) may change the HTTP method, for example fromPOSTtoGET.307 Temporary Redirectpreserves the HTTP method and body.
For modern APIs, prefer 307 when you want to keep the method.
Example with 307:
POST /upload HTTP/1.1
HTTP/1.1 307 Temporary Redirect
Location: /upload-server-2
The client should repeat the POST to /upload-server-2 with the same body.
304 Not Modified
Used with caching. It says:
You already have the latest version, you can reuse your cached copy.
There is no response body. The client uses its own cached body.
Example:
GET /image.png HTTP/1.1
If-None-Match: "abc123"
HTTP/1.1 304 Not Modified
You will learn more about caching later, but remember that 304 is part of HTTP caching.
Common 4xx Client Error Codes
4xx means the client did something wrong. The request is invalid in some way.
400 Bad Request
The server cannot understand the request. Often used when:
- JSON body is invalid or cannot be parsed.
- Request syntax is broken.
- Body is missing when it is required.
Example:
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 JSON body"}401 Unauthorized
Despite the name, 401 Unauthorized means "not authenticated".
Use 401 when:
- The request requires authentication and the user is not logged in, or
- The access token or credentials are missing or invalid.
Typical for protected APIs:
GET /profile HTTP/1.1
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer
{"error": "Authentication required"}
Note the WWW-Authenticate header. It tells the client what kind of authentication is needed.
403 Forbidden
The client is authenticated but not allowed to perform this action.
Use 403 when:
- The user is logged in but does not have permission to access the resource.
Example:
DELETE /users/123 HTTP/1.1
Authorization: Bearer valid-but-normal-user-token
HTTP/1.1 403 Forbidden
Content-Type: application/json
{"error": "You do not have permission to delete this user"}Rule:
- Not logged in or invalid token → 401 Unauthorized
- Logged in but not allowed → 403 Forbidden
404 Not Found
The resource does not exist, or you do not want to reveal that it exists.
Typical when:
- A user requested a non existing URL.
- A record with a given ID does not exist.
Example:
GET /users/99999 HTTP/1.1
HTTP/1.1 404 Not Found
Content-Type: application/json
{"error": "User not found"}
Many APIs also use 404 for security reasons when the user tries to access someone else's data, even if the resource exists, to avoid information leaks.
405 Method Not Allowed
The URL exists, but the HTTP method is not allowed on it.
Example:
POST /users/123 HTTP/1.1
HTTP/1.1 405 Method Not Allowed
Allow: GET, PUT, DELETE
The Allow header lists valid methods for that endpoint.
This often happens by accident when you forget to implement a method route in your backend.
409 Conflict
There is a conflict with the current state of the resource.
Common cases:
- Trying to create a user with an email that already exists.
- Version conflicts in optimistic locking.
Example:
POST /users HTTP/1.1
Content-Type: application/json
{"email": "alice@example.com"}
HTTP/1.1 409 Conflict
Content-Type: application/json
{"error": "Email already exists"}422 Unprocessable Entity
The request is syntactically correct, but the data is semantically invalid.
Often used for:
- Validation errors, for example required fields missing or wrong formats.
- This is very common in modern JSON APIs.
Example:
POST /users HTTP/1.1
Content-Type: application/json
{"name": "", "email": "not-an-email"}
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/json
{
"errors": [
{"field": "name", "message": "Name cannot be empty"},
{"field": "email", "message": "Invalid email address"}
]
}
Some frameworks use 400 for validation errors, others prefer 422. Be consistent inside one API.
Common 5xx Server Error Codes
5xx codes mean the server failed to handle a valid request. The problem is on the server side.
500 Internal Server Error
A general error for unexpected failures.
Use 500 when:
- An unhandled exception occurred.
- Something broke and you do not have a more specific error code.
Example:
GET /users HTTP/1.1
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
{"error": "Something went wrong"}In production, you should log full details on the server, but send a simple message to the client.
502 Bad Gateway
This appears when there is a reverse proxy or gateway (like Nginx) in front of your app and the proxy gets an invalid response from the upstream server.
Example scenario:
- Client → Nginx → Your FastAPI app.
- Your app crashes or returns a malformed response.
- Nginx returns
502 Bad Gatewayto the client.
As a backend developer you often see 502 in logs when your application container is down.
503 Service Unavailable
The server is temporarily unavailable.
Use for:
- Maintenance windows.
- Overloaded server that cannot handle more requests.
Example:
GET /api HTTP/1.1
HTTP/1.1 503 Service Unavailable
Retry-After: 120
Content-Type: application/json
{"error": "Service temporarily unavailable"}
Retry-After tells the client how long to wait before retrying, in seconds or as a date.
504 Gateway Timeout
The gateway or proxy timed out waiting for a response from the upstream server.
Example scenario:
- Your app tries to call a slow database or external API and takes too long.
- The reverse proxy has a timeout, for example 30 seconds.
- It returns
504 Gateway Timeoutto the client.
Typical Status Codes for CRUD APIs
In backend development, you often build REST style APIs with CRUD operations:
- Create
- Read
- Update
- Delete
Here is a typical mapping:
| Operation | HTTP Method | Usual Status Code(s) |
|---|---|---|
| List resources | GET | 200 OK |
| Get single resource | GET | 200 OK, 404 Not Found |
| Create resource | POST | 201 Created, sometimes 400, 422 |
| Replace resource | PUT | 200 OK or 204 No Content, 404 |
| Partial update | PATCH | 200 OK or 204 No Content, 404 |
| Delete resource | DELETE | 204 No Content, 404 Not Found |
Example mini API:
- Create:
POST /tasks HTTP/1.1
Content-Type: application/json
{"title": "Write chapter"}
HTTP/1.1 201 Created
Location: /tasks/1
Content-Type: application/json
{"id": 1, "title": "Write chapter", "completed": false}- Get:
GET /tasks/1 HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
{"id": 1, "title": "Write chapter", "completed": false}- Update:
PATCH /tasks/1 HTTP/1.1
Content-Type: application/json
{"completed": true}
HTTP/1.1 200 OK
Content-Type: application/json
{"id": 1, "title": "Write chapter", "completed": true}- Delete:
DELETE /tasks/1 HTTP/1.1
HTTP/1.1 204 No Content- Get deleted resource:
GET /tasks/1 HTTP/1.1
HTTP/1.1 404 Not Found
Content-Type: application/json
{"error": "Task not found"}Choosing the Right Status Code
A simple way to decide on a code:
- Did the request succeed?
- Yes → 2xx
- No → continue
- Should the client use another URL?
- Yes → 3xx
- Was the request itself invalid or not allowed?
- Yes → 4xx
- Did something unexpected go wrong on the server?
- Yes → 5xx
Some practical examples:
| Situation | Good code |
|---|---|
| JSON body missing required field | 400 or 422 |
User not logged in, trying to access /me | 401 |
| Logged in user without admin rights tries to delete another user | 403 or 404 |
| Resource with given ID does not exist | 404 |
| Duplicate email on registration | 409 |
| Unhandled exception in your code | 500 |
| Your database is down | 500 or 503 |
Rule:
Use the most specific code that matches what happened.
Avoid returning 200 OK for failures.
Summary
- HTTP status codes are 3 digit numbers that tell the client what happened.
- They are grouped into classes: informational, success, redirection, client error, server error.
- As a backend developer, you must:
- Return 2xx on success, especially
200,201,204. - Use 4xx when the client sent something wrong (
400,401,403,404,409,422). - Use 5xx when the server failed (
500,502,503,504). - Choosing correct codes makes your APIs easier to use, debug, and monitor.
You will use these codes constantly when you implement real backend endpoints in later chapters.
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!