7.5. HTTP Methods in REST
Table of Contents
Why HTTP Methods Matter in REST
In a REST API, the URL (path) identifies what you are working with, and the HTTP method tells the server what you want to do with it.
For example, these two requests mean very different things, even though they use the same URL:
GET /users/123
DELETE /users/123GET /users/123asks to read user 123.DELETE /users/123asks to delete user 123.
In REST, methods carry meaning. If you use them correctly, your API becomes predictable and easy to understand.
Key rule: In REST, you should use HTTP methods according to their standard semantics:
GETto read.POSTto create or perform a non-idempotent action.PUTto fully replace a resource.PATCHto partially update a resource.DELETEto remove a resource.
You already have separate chapters for each method, so this chapter focuses on:
- How methods map to CRUD operations.
- Important properties such as idempotency and safety.
- How to choose the right method in real API design.
CRUD and HTTP Methods
Backend systems often think in terms of CRUD:
| CRUD action | Description | Typical HTTP methods |
|---|---|---|
| Create | Add a new resource | POST, sometimes PUT |
| Read | Retrieve existing resource(s) | GET, sometimes HEAD |
| Update | Change existing resource | PUT, PATCH |
| Delete | Remove resource | DELETE |
A common REST pattern for a resource called users looks like this:
| Operation | HTTP method | URL |
|---|---|---|
| List users | GET | /users |
| Get a single user | GET | /users/{id} |
| Create a new user | POST | /users |
| Replace a user | PUT | /users/{id} |
| Partially update a user | PATCH | /users/{id} |
| Delete a user | DELETE | /users/{id} |
You will see this table repeatedly in real APIs such as GitHub, Stripe, or many internal company APIs.
Safety and Idempotency
Two important concepts help you choose the right method: safety and idempotency.
Safety
A method is safe if it is not supposed to change server state.
- Safe methods:
GET,HEAD,OPTIONS - Unsafe methods:
POST,PUT,PATCH,DELETE
Safe methods should only read data, not create, update, or delete.
Examples:
GET /postsmust not create new posts.GET /posts/10/likethat creates a like is a bad design, becauseGETis supposed to be safe. A better design isPOST /posts/10/likes.
Rule: GET must not have side effects like creating, updating, or deleting data.
Idempotency
A method is idempotent if making the same request multiple times in a row has the same effect as making it once.
Examples:
- If you call
DELETE /users/123once or 10 times, the result is the same: user 123 is gone. - If you call
PUT /users/123with the same body multiple times, the user ends up with the same data.
This does not mean the response is always the same, only that the final state of the resource does not change after the first successful call.
Common methods and idempotency:
| Method | Safe | Idempotent | Typical use |
|---|---|---|---|
GET | Yes | Yes | Read data |
HEAD | Yes | Yes | Read metadata (headers only) |
OPTIONS | Yes | Yes | Discover capabilities |
POST | No | No | Create resources, non-idempotent actions |
PUT | No | Yes | Replace a resource |
PATCH | No | Not guaranteed | Partially modify a resource |
DELETE | No | Yes | Delete a resource |
Rule: POST is not idempotent, PUT and DELETE should be idempotent, GET should be both safe and idempotent.
Why this matters:
- Idempotent methods are easier to retry safely on network failures.
- Many HTTP clients, proxies, and load balancers rely on these semantics.
Overview of Key HTTP Methods in REST
You have separate chapters for each of these, so here we will focus on how they fit together and how to choose between them.
GET
Used to retrieve data.
Examples:
GET /users
GET /users/42
GET /posts?author_id=42&page=2- Must not change server data.
- Can use caching, because it is safe and idempotent.
Common misuse:
GET /users/createthat creates a user is wrong. UsePOST /usersinstead.
POST
Used to create a resource or start an action that is not idempotent.
Examples:
POST /users
POST /orders
POST /orders/123/cancel
POST /reports/generateTypical behavior:
- When
POST /userscreates a user, the server often returns: 201 Createdstatus.- The new resource in the body.
- A
Locationheader pointing to/users/{new_id}.
POST is flexible:
- It can create child resources under a collection, such as
/users. - It can also represent actions, such as
/users/123/reset-password.
PUT
Used to fully replace a resource at a known URL.
Examples:
PUT /users/123
PUT /settings/global
In PUT /users/123, the body contains the entire representation of the user, not just the fields you want to change.
Key properties:
- Idempotent: sending the same full user data again does not change the state after the first request.
- Can be used to create a resource if the client already knows the ID and the server allows it.
Example: client chooses the ID:
PUT /users/alice
Content-Type: application/json
{
"id": "alice",
"name": "Alice Smith",
"email": "alice@example.com"
}
If /users/alice does not exist, the server may create it. If it exists, the server replaces its data.
PATCH
Used to partially update an existing resource.
Examples:
PATCH /users/123
Content-Type: application/json
{
"email": "new-email@example.com"
}- Typically used when you want to update only 1 or 2 fields.
- Often not idempotent by default, but you can design it to be idempotent if each patch is a deterministic description of the final state.
Comparison:
PUT /users/123expects the full user data.PATCH /users/123expects only the fields that change.
DELETE
Used to remove a resource.
Examples:
DELETE /users/123
DELETE /posts/99/comments/5- Idempotent: after the first successful deletion, further
DELETEcalls should not change the server state. - The server can return
204 No Contentto indicate success without a body.
Designing REST APIs with Methods
Picking the correct method for each endpoint is part of designing a RESTful API.
Common Resource Patterns
Imagine you design an API for a simple blogging system with:
- Users
- Posts
- Comments
Users
| Action | Method | URL | Notes |
|---|---|---|---|
| List users | GET | /users | Optional filters as query params |
| Create user | POST | /users | Body contains user data |
| Get single user | GET | /users/{id} | |
| Replace user | PUT | /users/{id} | Full user body |
| Partially update user | PATCH | /users/{id} | Only changed fields |
| Delete user | DELETE | /users/{id} |
Posts
| Action | Method | URL |
|---|---|---|
| List posts | GET | /posts |
| Create post | POST | /posts |
| Get single post | GET | /posts/{id} |
| Update post fully | PUT | /posts/{id} |
| Update post partially | PATCH | /posts/{id} |
| Delete post | DELETE | /posts/{id} |
| List comments of a post | GET | /posts/{id}/comments |
| Add comment to a post | POST | /posts/{id}/comments |
Custom actions
Sometimes you need an action that does not fit simple CRUD, for example liking a post.
Bad design:
GET /posts/123/likethat likes the post.
Better designs:
- Treat likes as a resource:
POST /posts/123/likesto like.DELETE /posts/123/likesto unlike (if user is implied from auth).- Or use an action endpoint with
POST: POST /posts/123/likePOST /posts/123/unlike
Both approaches use methods in a way that respects their semantics: an action that changes state should not be GET.
Choosing Between POST, PUT, and PATCH
These three methods are often confusing. Here are some practical guidelines.
When to Use POST
Use POST when:
- The server generates the resource ID.
- You are adding something to a collection.
Examples:
POST /users # Server decides user id
POST /orders # Server decides order id
POST /posts/123/comments # Server decides comment id
Also use POST for:
- Actions that do not simply fit CRUD.
Examples:
POST /auth/login
POST /payments/123/refund
POST /reports/generateWhen to Use PUT
Use PUT when:
- The client knows the resource URL.
- You are replacing the entire resource representation.
Examples:
PUT /users/123
PUT /profiles/john-doe
PUT /settings/globalDecide on a rule:
- Either you allow
PUTto also create if the resource does not exist. - Or you require the resource to exist and return
404 Not Foundif it does not.
Be consistent in your API.
When to Use PATCH
Use PATCH when:
- You want to update only some fields.
- The client does not want to send the full resource.
Examples:
PATCH /users/123
{
"name": "New Name"
}
PATCH /users/123
{
"is_active": false
}You will define how the server interprets the payload. A common rule is:
- Only the fields present in the request body are modified.
- Other fields keep their previous values.
Idempotency in Real Scenarios
Idempotency is very important for retries. For example, a client might send a request, get a timeout, and try again. If the method is idempotent, this is safer.
Idempotent Example: PUT
Imagine you have:
PUT /accounts/123/balance
Content-Type: application/json
{ "balance": 1000 }Whether this is called once or five times, the final balance is 1000.
Non Idempotent Example: POST
Imagine:
POST /orders
Content-Type: application/json
{ "item_id": 42, "quantity": 1 }
If this is called twice because of a timeout, the user might receive two orders. This is correct behavior, because POST is non idempotent.
To protect from this in real systems, APIs sometimes use:
- Idempotency keys in headers, to ensure a repeated
POSTwith the same key does not create multiple resources. - This is an advanced topic, but it shows why understanding method semantics matters.
Common Design Mistakes and How to Avoid Them
Misusing GET for state changes
Bad:
GET /users/123/activate
This changes the user from inactive to active, which violates the safety of GET.
Better:
POST /users/123/activateor a more RESTful resource-oriented design:
POST /users/123/activation # create an activation
DELETE /users/123/activation # remove activation (deactivate)Using POST for everything
Some APIs use only POST and GET, for example:
POST /updateUser
POST /deleteUser
POST /getUserThis might work, but the API:
- Ignores HTTP semantics.
- Is harder to understand for other developers.
- Does not play well with caches and standard tools.
Instead, use:
GET /users/123
PUT /users/123
DELETE /users/123Confusing PUT and PATCH
If you design PUT /users/123 to accept partial updates, then you blur the line:
- Clients cannot be sure if missing fields are left untouched or cleared.
- It becomes unclear why
PATCHexists.
Better:
- Decide that
PUTalways expects a full representation. - Decide that
PATCHis for partial, minimal updates.
Practical Examples
Here are some complete request and response examples to see methods in context.
Creating a resource with POST
POST /users
Content-Type: application/json
{
"name": "Alice",
"email": "alice@example.com"
}Possible response:
HTTP/1.1 201 Created
Location: /users/123
Content-Type: application/json
{
"id": 123,
"name": "Alice",
"email": "alice@example.com",
"created_at": "2026-08-27T10:00:00Z"
}Reading the created resource with GET
GET /users/123
Accept: application/jsonResponse:
HTTP/1.1 200 OK
Content-Type: application/json
{
"id": 123,
"name": "Alice",
"email": "alice@example.com",
"created_at": "2026-08-27T10:00:00Z"
}Fully replacing the user with PUT
PUT /users/123
Content-Type: application/json
{
"id": 123,
"name": "Alice Smith",
"email": "alice.smith@example.com"
}This request overwrites the user. Any fields not sent might be set to default or removed, depending on your API design.
Partially updating the user with PATCH
PATCH /users/123
Content-Type: application/json
{
"name": "Alice Johnson"
}
Only the name changes. Other fields remain unchanged.
Deleting the user with DELETE
DELETE /users/123Response:
HTTP/1.1 204 No Content
If the client sends DELETE /users/123 again, the server may return:
HTTP/1.1 404 Not FoundThe state of the system is still the same as after the first delete, so the method remains idempotent.
Summary
- REST uses HTTP methods to express what action you want to perform on a resource.
- Key methods:
GETfor reading, safe and idempotent.POSTfor creating and non idempotent actions.PUTfor full replacement, idempotent.PATCHfor partial updates.DELETEfor deletions, idempotent.- Safety and idempotency are important properties that influence:
- How clients can retry requests.
- How intermediaries like caches and proxies behave.
- Good REST design uses the methods according to their standard meaning, which makes your API more intuitive and robust.
In the following chapters, you will dive into each method in detail and see how to implement and use them in real backend code.
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!