7.8. PUT Requests
Table of Contents
Understanding PUT Requests
In REST APIs, PUT is one of the core HTTP methods you will use to update data on the server. It has a very specific meaning and behavior that is different from POST, PATCH, and others. In this chapter, you will learn what makes PUT special and how to use it correctly when designing and consuming REST APIs.
What Is a PUT Request?
A PUT request is an HTTP request that tells the server:
“Store the resource I am sending at this exact URL. If it already exists, replace it. If it does not exist, you may create it.”
So, PUT is usually used to create or completely replace a resource at a known URL.
A typical PUT request looks like this:
PUT /users/123 HTTP/1.1
Host: api.example.com
Content-Type: application/json
{
"id": 123,
"name": "Alice",
"email": "alice@example.com",
"is_active": true
}
The client here is saying: “The user with ID 123 should now have exactly this data. Store it at /users/123.”
Compare that with POST to /users, which usually means “create a new user, you (the server) choose the ID and URL.”
PUT vs POST vs PATCH
Understanding where PUT fits requires comparing it with POST and PATCH.
Conceptual comparison
| Method | Typical Use | Target URL pattern | Body contains | Idempotent |
|---|---|---|---|---|
| POST | Create a new resource under a collection | /users | New resource data (often partial) | No |
| PUT | Create or fully replace a resource at a URL | /users/123 | Full resource representation | Yes |
| PATCH | Partially update part of a resource | /users/123 | Only fields to change | Not guaranteed |
Key ideas:
- POST is for “add something new” to a collection. The server often decides the new resource ID.
- PUT is for “the resource at this URL should now be exactly this.”
- PATCH is for “change only these fields of the resource.”
Important rule:
Use PUT when you want to fully replace the resource representation at a known URL, and the operation should be idempotent (same request repeated has the same final effect).
Use PATCH when you want to partially update fields.
Use POST to create new resources under a collection or to trigger non-idempotent actions.
Idempotency of PUT
Idempotent means:
Performing the same operation multiple times in a row results in the same final state as doing it once.
This does not mean the responses have to be exactly the same each time, but the resource on the server must end up in the same state.
Example of idempotent PUT
Imagine a user resource:
{
"id": 1,
"name": "Alice",
"email": "alice@old.com",
"is_active": true
}You send:
PUT /users/1
Content-Type: application/json
{
"id": 1,
"name": "Alice Wonderland",
"email": "alice@new.com",
"is_active": false
}- First time: user is updated.
- Second time with the same body: user is already in that state. Nothing changes.
- Third time: still same state.
The resource after each operation is:
{
"id": 1,
"name": "Alice Wonderland",
"email": "alice@new.com",
"is_active": false
}No matter how many times you repeat this PUT, the final state is the same, so the operation is idempotent.
Why idempotency matters
Idempotency is very useful for:
- Network retries: if a client or proxy resends a request because it is not sure if the previous one succeeded, it should be safe to repeat.
- Clients with poor connectivity: they can retry until the request goes through, knowing they will not accidentally double-update or double-create something.
Compare with POST:
- Sending the same POST to
/orderstwice might create two separate orders. - Because of this, POST is usually not idempotent.
Full Replacement vs Partial Updates
The usual interpretation of PUT is full replacement.
Full replacement semantics
With full replacement:
- The body you send is considered the entire representation of the resource.
- Any fields that are not present may be treated as deleted or reset to a default.
Example: current resource
{
"id": 10,
"name": "My Task",
"description": "Do something",
"is_done": false
}You send:
PUT /tasks/10
Content-Type: application/json
{
"id": 10,
"name": "My Task (updated)"
}Possible server interpretation with full replacement:
{
"id": 10,
"name": "My Task (updated)",
"description": null,
"is_done": null
}If you want to keep other fields unchanged, you would include them in the body:
PUT /tasks/10
Content-Type: application/json
{
"id": 10,
"name": "My Task (updated)",
"description": "Do something",
"is_done": false
}
Important rule:
With PUT, the request body should usually contain the full representation of the resource.
If you only want to modify some fields and keep others unchanged, use PATCH.
Some real APIs relax this rule and treat PUT more like PATCH, but that is confusing and not fully RESTful. For clean API design, keep the meanings different and clear.
Typical URL Design for PUT
PUT almost always targets a single, specific resource.
Common patterns
| Resource type | Collection URL | Single resource URL | Example PUT |
|---|---|---|---|
| Users | /users | /users/{user_id} | PUT /users/123 |
| Products | /products | /products/{sku} | PUT /products/ABC-123 |
| Tasks | /tasks | /tasks/{task_id} | PUT /tasks/42 |
In many APIs:
POST /users→ create a new user, ID assigned by server.PUT /users/123→ create or replace user with ID 123.PATCH /users/123→ partially update user 123.DELETE /users/123→ delete user 123.
The important part: PUT uses a URL that identifies exactly one resource. The client is responsible for knowing that URL and often even the ID.
Creating vs Updating with PUT
Should you use PUT only for updates, or also for creating resources?
Two valid interpretations
There are two common approaches:
- Update only
- If the resource does not exist, respond with 404 Not Found.
- PUT is only allowed when the resource already exists.
- Create or replace (upsert-like)
- If the resource exists, replace it with the provided representation.
- If the resource does not exist, create it at that URL.
Both patterns are seen in real APIs. You should decide and document the behavior in your API.
Example: PUT as “update only”
Request:
PUT /users/123
Content-Type: application/json
{
"id": 123,
"name": "Alice",
"email": "alice@example.com"
}- If user 123 exists: update it, return 200 OK with the updated resource.
- If user 123 does not exist: return 404 Not Found.
Example: PUT as “create or replace”
Same request:
PUT /users/123
Content-Type: application/json
{
"id": 123,
"name": "Alice",
"email": "alice@example.com"
}- If user 123 exists: update, return 200 OK or 204 No Content.
- If user 123 does not exist: create user 123, return 201 Created.
Server response for creation might be:
HTTP/1.1 201 Created
Location: /users/123
Content-Type: application/json
{
"id": 123,
"name": "Alice",
"email": "alice@example.com"
}
Important rule:
If you allow PUT to create resources, return 201 Created for new resources, and include a Location header with the resource URL.
If you use PUT only for updates and the resource does not exist, return 404 Not Found.
Common Response Codes for PUT
PUT typically uses a small set of HTTP status codes.
| Status code | When to use for PUT |
|---|---|
| 200 OK | Resource was updated or created and response body is returned |
| 201 Created | Resource was newly created at this URL |
| 204 No Content | Resource was updated and no body is returned |
| 400 Bad Request | Invalid data or malformed request body |
| 401 Unauthorized | Authentication required or invalid |
| 403 Forbidden | Authenticated but not allowed to update this resource |
| 404 Not Found | Resource to update does not exist |
| 409 Conflict | Conflicting state, such as version mismatch or duplicate |
| 422 Unprocessable Entity | Validation failed for request data |
Many APIs choose between 200 and 204 for successful updates:
- Return 200 OK when you want to send back the updated representation.
- Return 204 No Content when there is nothing useful to send back.
Example:
PUT /tasks/10
Content-Type: application/json
{
"id": 10,
"title": "Buy milk",
"is_done": true
}Response with updated resource:
HTTP/1.1 200 OK
Content-Type: application/json
{
"id": 10,
"title": "Buy milk",
"is_done": true
}Or minimal response:
HTTP/1.1 204 No ContentPUT Request Examples
Example 1: Updating a user profile
URL: /users/42
Current server data:
{
"id": 42,
"username": "jdoe",
"full_name": "John Doe",
"email": "john@example.com",
"bio": "Hello world"
}
Client wants to change the full_name and bio. Since this is PUT, the client sends full data:
PUT /users/42
Content-Type: application/json
{
"id": 42,
"username": "jdoe",
"full_name": "John M. Doe",
"email": "john@example.com",
"bio": "Backend developer"
}Possible response:
HTTP/1.1 200 OK
Content-Type: application/json
{
"id": 42,
"username": "jdoe",
"full_name": "John M. Doe",
"email": "john@example.com",
"bio": "Backend developer"
}Example 2: Creating or replacing a product
URL: /products/ABC-123
Client:
PUT /products/ABC-123
Content-Type: application/json
{
"sku": "ABC-123",
"name": "Blue T-Shirt",
"price": 19.99,
"in_stock": true
}If the product did not exist before:
HTTP/1.1 201 Created
Location: /products/ABC-123
Content-Type: application/json
{
"sku": "ABC-123",
"name": "Blue T-Shirt",
"price": 19.99,
"in_stock": true
}If it existed:
HTTP/1.1 200 OK
Content-Type: application/json
{
"sku": "ABC-123",
"name": "Blue T-Shirt",
"price": 19.99,
"in_stock": true
}Example 3: Handling invalid PUT data
Request:
PUT /users/50
Content-Type: application/json
{
"id": 50,
"email": "not-an-email",
"username": ""
}Server validation:
emailis invalid format.usernameis required and cannot be empty.
Response:
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/json
{
"detail": [
{"field": "email", "message": "Invalid email format"},
{"field": "username", "message": "Username is required"}
]
}Designing PUT in Your REST API
When you design your own API, decide and document how PUT works in your system.
Checklist for PUT design
- Define the URL pattern
- Usually:
/resources/{id}.
Example:/tasks/{task_id}. - Decide if PUT can create
- Update only (404 if not found), or
- Create or replace (201 when created, 200 or 204 when updated).
- Use full representation in the body
- Require all mandatory fields.
- Either set missing optional fields to null or keep the previous value, but be consistent and document it.
- Use consistent status codes
- 200 or 204 for success, 201 when created.
- 400/422 for validation errors.
- 404 when resource is not found.
- 401/403 when not authenticated or not authorized.
- Keep PUT idempotent
- Repeating the same PUT should not change the resource again.
- Avoid side effects like sending emails or creating new resources as part of PUT.
- Return updated resource when helpful
- Especially useful when the server modifies data (for example sets
updated_at, normalizes strings, adds links).
Example: Task API with PUT
Resource: Task
{
"id": 1,
"title": "Buy milk",
"is_done": false,
"due_date": "2026-09-01T10:00:00Z"
}API decisions:
- URL:
/tasks/{task_id} - PUT can only update existing tasks.
- PUT expects full task representation.
- If successful: return 200 OK with updated task.
- If not found: return 404 Not Found.
Client request:
PUT /tasks/1
Content-Type: application/json
{
"id": 1,
"title": "Buy oat milk",
"is_done": true,
"due_date": "2026-09-01T10:00:00Z"
}Server response:
HTTP/1.1 200 OK
Content-Type: application/json
{
"id": 1,
"title": "Buy oat milk",
"is_done": true,
"due_date": "2026-09-01T10:00:00Z",
"updated_at": "2026-08-27T12:34:56Z"
}If task 1 did not exist:
HTTP/1.1 404 Not Found
Content-Type: application/json
{
"detail": "Task not found"
}Practical Tips and Common Pitfalls
1. Do not mix PUT semantics with PATCH
Avoid using PUT for partial updates. Some APIs do this:
PUT /users/1
Content-Type: application/json
{
"full_name": "New Name"
}
and then only update full_name. This blurs the line between PUT and PATCH and can confuse clients.
Better:
- Use PATCH for partial updates.
- Use PUT when the client sends a complete representation.
2. Consider resource versioning for concurrent updates
Two clients might try to update the same resource at nearly the same time, for example:
- Client A reads user 1, then PUT with changes.
- Client B also reads user 1, then PUT with different changes slightly later.
Without protection, the last write overwrites previous changes. Many APIs use a version field or ETag and 409 Conflict to detect this, which is part of optimistic locking, but the details belong to more advanced topics.
3. Validate IDs in body vs URL
If your resource has an id field and the URL also includes {id}, you should ensure they match.
Example:
PUT /users/123
Content-Type: application/json
{
"id": 999,
"name": "Alice"
}You can:
- Ignore the body
idand always use the URLid, or - Validate that
idin body equalsidin URL and return 400 if not.
What you choose is up to your API design, but be consistent and document it.
4. Handling missing or optional fields
Decide what happens when a client omits optional fields in PUT:
- Do you keep the old value, or
- Do you set them to null / remove them?
For strict full replacement semantics, missing fields should usually be treated as removed. But this can surprise clients, so many APIs document clearly which fields must always be sent and which ones are optional and preserved.
Summary
- PUT is used to create or fully replace a resource at a known URL.
- It is idempotent: sending the same request multiple times results in the same final state.
- PUT typically expects a full representation of the resource, unlike PATCH which is partial.
- Common behavior:
PUT /resources/{id}updates an existing resource, or sometimes creates it.- 200 / 204 on success, 201 if a new resource is created, 404 if not found, 400 / 422 for invalid data.
- Good API design keeps a clear separation between POST, PUT, and PATCH, and uses consistent URLs and status codes.
Understanding and using PUT correctly is a key step toward building clean, predictable REST APIs.
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!