7.7. POST Requests
Table of Contents
Understanding POST Requests
POST requests are used to send data to the server to create or submit something new. In REST APIs, POST is one of the most common methods you will use.
This chapter focuses only on what is specific to POST in REST APIs. Concepts like general HTTP methods, status codes, and validation are covered in their own chapters, so we will only touch them when needed for context.
What POST Is Used For
In REST-style APIs, the usual meaning of a POST request is:
- Create a new resource under a collection
- Submit data for processing (for example, login, search, form submission)
- Trigger an action that does not fit well into other methods
Typical examples:
POST /usersto create a new userPOST /ordersto create a new orderPOST /loginto authenticate a userPOST /uploadto upload a file
Rule: In a REST API, POST is usually used on a collection URL (like /users) to create a new resource inside that collection.
Structure of a POST Request
A POST request has:
- A URL that identifies where you send data
- A method:
POST - Optional query parameters in the URL
- A body (the main content you send, often JSON)
- Headers that describe the body (for example,
Content-Type)
Example of a raw HTTP POST request:
POST /users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer <token>
{
"email": "alice@example.com",
"password": "Secret123!",
"name": "Alice"
}Key parts here:
| Part | Example | Meaning |
|---|---|---|
| Method | POST | We are sending data to the server |
| URL path | /users | Endpoint that receives new user data |
| Header | Content-Type: application/json | Body format is JSON |
| Header (optional) | Authorization: Bearer <token> | Who is making the request |
| Body | JSON object with user information | Data to create a new user |
Common Uses of POST in REST APIs
1. Creating Resources
Most commonly, POST is used to create a new item in a collection.
Example: Creating a blog post
- Request
POST /posts HTTP/1.1
Host: api.example.com
Content-Type: application/json
{
"title": "My first post",
"content": "Hello backend world!",
"tags": ["intro", "backend"]
}- Typical response
HTTP/1.1 201 Created
Location: /posts/123
Content-Type: application/json
{
"id": 123,
"title": "My first post",
"content": "Hello backend world!",
"tags": ["intro", "backend"],
"created_at": "2026-08-26T12:34:56Z"
}Points to notice:
- Status code
201 Createdindicates a new resource was created Locationheader tells where the new resource lives- Response body usually returns the full created resource, including the generated
id
Rule: When a POST successfully creates a resource, prefer status code 201 Created and include the new resource or at least its URI.
2. Submitting Forms
Some actions only submit data for processing and do not create a resource that you later fetch.
Example: Contact form
- Request
POST /contact HTTP/1.1
Content-Type: application/json
{
"name": "Alice",
"email": "alice@example.com",
"message": "Please contact me back."
}- Response
HTTP/1.1 200 OK
Content-Type: application/json
{
"status": "received",
"ticket_id": "T-9982"
}
Although this could be considered "creating a ticket", sometimes the client never needs a separate /tickets resource. The key idea is that POST is used to submit data, and the response can be anything meaningful.
3. Login and Other Actions
Example: User login
- Request
POST /login HTTP/1.1
Content-Type: application/json
{
"email": "alice@example.com",
"password": "Secret123!"
}- Response
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
"token_type": "bearer"
}This POST is not creating a user. It is creating a token or a session, or simply performing an authentication action.
POST vs GET, PUT, and PATCH
You will see POST mentioned a lot together with other HTTP methods. Here we only compare how POST is different, not fully define everything.
POST vs GET
| Aspect | GET | POST |
|---|---|---|
| Purpose | Retrieve data | Send data, usually to create or submit |
| Has a body? | Usually no body | Usually has a body |
| Side effects | Should not change state | Often changes state (creates or triggers) |
| Caching | Often cached | Usually not cached |
Rule: Do not use GET to change data. Use POST (or PUT/PATCH/DELETE) for actions that modify server state.
POST vs PUT
A very simple way to remember:
- POST: "Create something new under this URL"
- PUT: "Replace the resource at this URL"
For example:
POST /usersto create a new user with a new IDPUT /users/123to fully replace user 123
POST vs PATCH
- POST: usually for creating or triggering actions
- PATCH: for partially updating an existing resource
For example:
POST /poststo create a new postPATCH /posts/123to change just the title or tags of post 123
Idempotency and POST
An operation is idempotent if running it many times with the same input has the same effect as running it once.
- GET should be idempotent
- PUT and DELETE are defined to be idempotent
- POST is not required to be idempotent
Example of a non idempotent POST:
POST /orders
{
"product_id": 42,
"quantity": 1
}If the client accidentally sends this same request 3 times, you might create 3 identical orders.
Sometimes you want idempotent behavior with POST, for example when creating payments. One common solution is to use an idempotency key:
POST /payments
Idempotency-Key: 43e55b3f-9e7d-4bc8-9c48-7ac4c4a436ca
Content-Type: application/json
{
"amount": 1000,
"currency": "USD",
"customer_id": 7
}
If the server sees the same Idempotency-Key again, it returns the previous result instead of creating a new payment. Idempotency keys are covered more in the advanced idempotency chapter, but you should know that they are often used with POST.
Request Bodies in POST
The most important part of a POST is usually the request body.
Common Body Types
| Content-Type | Description | Example usage |
|---|---|---|
application/json | JSON object or array | Most modern APIs |
application/x-www-form-urlencoded | Key value fields, URL encoded | HTML forms |
multipart/form-data | Mixed data, for example text and files | File uploads |
text/plain | Plain text | Very simple webhooks |
A POST that creates a resource in a JSON API usually uses application/json.
Example: Create a comment
POST /posts/123/comments HTTP/1.1
Content-Type: application/json
{
"author": "Bob",
"text": "Nice article!"
}The server will parse that JSON body, validate it, and store it.
Validation and Error Responses with POST
When you accept data from clients, validation is critical. The details are in the validation and error response chapters, but we will look at how this typically appears with POST.
Example: Validation Failure
Request:
POST /users HTTP/1.1
Content-Type: application/json
{
"email": "not-an-email",
"password": "123",
"name": ""
}The server checks:
emailmust be a valid emailpasswordmust be at least 8 charactersnamecannot be empty
The response could look like this:
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"error": "Validation failed",
"details": {
"email": ["Invalid email address"],
"password": ["Password must be at least 8 characters"],
"name": ["Name is required"]
}
}Common status codes for POST errors:
| Status code | Meaning |
|---|---|
| 400 | Invalid data or malformed request |
| 401 | Not authenticated |
| 403 | Authenticated but not allowed |
| 404 | Parent resource not found (for example /posts/999/comments) |
| 409 | Conflict, for example duplicate email |
| 422 | Unprocessable Entity, often used for validation |
| 500 | Internal server error |
Typical Responses for POST
Different success scenarios usually use different status codes.
201 Created
Most common when a resource is created.
HTTP/1.1 201 Created
Location: /users/42
Content-Type: application/json
{
"id": 42,
"email": "alice@example.com",
"name": "Alice"
}200 OK
Used when the server returns some useful information, but not necessarily a new resource that fits a collection.
Examples:
- Login
- Contact form with confirmation
- Search result from a POST (less common, but possible)
HTTP/1.1 200 OK
Content-Type: application/json
{
"status": "success",
"message": "Your message was sent"
}204 No Content
Used when the server successfully processed the request but does not need to return a body.
Example: A POST that triggers an asynchronous job
POST /jobs/rebuild-search-index HTTP/1.1Response:
HTTP/1.1 204 No ContentExamples of POST Endpoints in a Simple API
Imagine a simple task management REST API.
1. Create a Task
Request
POST /tasks HTTP/1.1
Content-Type: application/json
{
"title": "Write chapter about POST",
"description": "Explain POST requests for beginners",
"due_date": "2026-08-30"
}Successful response
HTTP/1.1 201 Created
Location: /tasks/101
Content-Type: application/json
{
"id": 101,
"title": "Write chapter about POST",
"description": "Explain POST requests for beginners",
"due_date": "2026-08-30",
"completed": false,
"created_at": "2026-08-27T09:00:00Z"
}2. Mark a Task as Completed with a POST Action
Sometimes there is debate about whether to use POST or PATCH for actions like "complete task". One common pattern is to use a subresource or action URL with POST.
Request
POST /tasks/101/complete HTTP/1.1Response
HTTP/1.1 200 OK
Content-Type: application/json
{
"id": 101,
"title": "Write chapter about POST",
"completed": true
}Here POST is used to trigger an action: "complete this task".
3. Bulk Create with POST
You can also accept arrays in POST bodies.
Request
POST /tasks/bulk HTTP/1.1
Content-Type: application/json
[
{ "title": "Read REST chapter" },
{ "title": "Practice POST requests" },
{ "title": "Implement /tasks endpoint" }
]Response
HTTP/1.1 201 Created
Content-Type: application/json
[
{
"id": 201,
"title": "Read REST chapter",
"completed": false
},
{
"id": 202,
"title": "Practice POST requests",
"completed": false
},
{
"id": 203,
"title": "Implement /tasks endpoint",
"completed": false
}
]Security Considerations for POST
Even in a basic introduction, you should be aware of some security aspects:
- Never trust client input
- Always validate and sanitize POST bodies
- Check for required fields and correct formats
- Use HTTPS
- POST bodies often contain sensitive data like passwords or personal info
- Without HTTPS, this can be intercepted
- Limit request size
- Attackers can send huge request bodies to exhaust memory
- Most frameworks and servers let you set a maximum body size
- Authentication and authorization
- Some POST endpoints must be accessible only by logged in users
- For example,
POST /admin/usersshould be protected
You will see these topics in more detail in the security and authentication chapters, but they are heavily involved with POST requests since POST is used to change things.
Putting It All Together: A Full Example
Imagine we create a small REST API for notes.
Create a Note
Request
POST /notes HTTP/1.1
Content-Type: application/json
Authorization: Bearer <token>
{
"title": "Shopping list",
"content": "Milk, bread, eggs"
}Response success
HTTP/1.1 201 Created
Location: /notes/10
Content-Type: application/json
{
"id": 10,
"title": "Shopping list",
"content": "Milk, bread, eggs",
"owner_id": 3,
"created_at": "2026-08-27T10:00:00Z"
}Response validation error
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/json
{
"error": "Validation failed",
"details": {
"title": ["Title is required"]
}
}Response unauthorized
HTTP/1.1 401 Unauthorized
Content-Type: application/json
{
"error": "Not authenticated"
}From this one endpoint you can see:
- POST is used to create
/notes/10 - Body is JSON, declared with
Content-Type - Status codes and error structures communicate the result
- Authentication is done with a header, not POST body
Summary
- Use POST to send data to the server, usually to create resources or trigger actions.
- Typical pattern:
POST /collectionto create a new item in that collection. - POST requests usually have a body, often JSON, described by the
Content-Typeheader. - Successful POST that creates something should usually return 201 Created, sometimes with a
Locationheader pointing to the new resource. - POST is not idempotent by default, so repeated POSTs can create multiple resources or trigger actions multiple times.
- Validation, error handling, and security are critical with POST, because POST accepts data that can affect your system.
You will use POST requests constantly when building real REST APIs, especially for creation and submission endpoints.
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!