7.9. PATCH Requests
Table of Contents
Understanding PATCH Requests
PATCH is an HTTP method used to make partial updates to a resource. Where PUT usually replaces a whole resource, PATCH is used when you only want to change specific fields.
In backend development, this is very common for user profile updates, settings pages, or any situation where the client edits only part of an object.
Key idea:
Use PATCH when updating only some fields of a resource, not the entire representation.
To keep this chapter focused, we will only talk about what is specific to PATCH compared to other HTTP methods like GET or POST, and how to design and handle PATCH endpoints in REST APIs.
When to Use PATCH
Partial vs Full Updates
The most important distinction is between PUT and PATCH.
- PUT: The client sends the entire resource representation.
If some fields are omitted, the server often treats them as default or null, or rejects the request. - PATCH: The client sends only the fields that need to be changed.
Fields that are not sent remain unchanged.
Example resource, a user profile in JSON:
{
"id": 123,
"email": "user@example.com",
"full_name": "Alice Smith",
"bio": "Backend developer",
"is_active": true
}Example: Using PUT vs PATCH
Using PUT to change the bio might look like:
PUT /users/123
Content-Type: application/json
{
"id": 123,
"email": "user@example.com",
"full_name": "Alice Smith",
"bio": "New bio",
"is_active": true
}The client must send all fields, not just the changed one.
Using PATCH to change only the bio:
PATCH /users/123
Content-Type: application/json
{
"bio": "New bio"
}
The server updates only the bio field and keeps other fields as they are.
Rule:
If you are replacing a resource, use PUT.
If you are modifying part of a resource, use PATCH.
Designing PATCH Endpoints
Typical PATCH URL Design
PATCH endpoints usually follow the same URL pattern as other operations on a single resource, for example:
| Operation | HTTP Method | Example URL |
|---|---|---|
| Get a user | GET | /users/123 |
| Replace a user | PUT | /users/123 |
| Partially update a user | PATCH | /users/123 |
| Delete a user | DELETE | /users/123 |
You do not create a separate URL just because you use PATCH. The method changes, not the path.
What Should the PATCH Body Look Like?
There are two common strategies:
- Partial resource representation (most common and simple)
- Patch document formats like JSON Patch or JSON Merge Patch
1. Simple Partial Representation
In many REST APIs, a PATCH request body is simply a subset of the resource fields. Every field that appears is updated, others are left alone.
Example: Update a user’s full_name and is_active:
PATCH /users/123
Content-Type: application/json
{
"full_name": "Alice B. Smith",
"is_active": false
}Server behavior:
- Change
full_nameto"Alice B. Smith" - Change
is_activetofalse - Leave
emailandbiounchanged
This is straightforward, readable, and works well in many APIs.
2. JSON Patch and JSON Merge Patch (Overview)
These are more advanced, standardized formats. You do not need to fully implement them when starting, but you should know they exist:
| Format | Content-Type | Idea |
|---|---|---|
| JSON Patch | application/json-patch+json | A list of operations (add, remove, replace) |
| JSON Merge Patch | application/merge-patch+json | Partial document that is merged |
Example JSON Patch to change bio:
PATCH /users/123
Content-Type: application/json-patch+json
[
{ "op": "replace", "path": "/bio", "value": "Updated bio" }
]In beginner-level projects, the simple partial representation approach is usually enough.
Typical Use Cases for PATCH
Updating User Profiles
Common PATCH endpoint:
PATCH /users/me
Content-Type: application/json
{
"full_name": "New Name",
"bio": "New bio"
}- The user might leave out fields like
emailthat they do not want to change. - The server updates only the provided fields.
Updating Resource Status or Flags
Often you only modify one or two flags, such as is_active, status, or is_published.
Example, deactivate a post:
PATCH /posts/42
Content-Type: application/json
{
"is_published": false
}Example, change an order status:
PATCH /orders/1001
Content-Type: application/json
{
"status": "shipped"
}Incremental Changes to Settings
You may want to update app settings where not all values are known at once.
PATCH /settings/notifications
Content-Type: application/json
{
"email_notifications": true
}Other notification settings stay the same because they are not included.
Behavior and Semantics of PATCH
Idempotency
Idempotency means:
Performing the same operation multiple times has the same effect as performing it once.
GETis idempotent.PUTis supposed to be idempotent.- PATCH is not guaranteed to be idempotent, but you can design it to be.
Example of a non-idempotent PATCH:
PATCH /accounts/10
Content-Type: application/json
{
"increment_balance": 100
}If the server interprets this as "add 100 to balance", then sending the same request twice adds 200. That is not idempotent.
Example of an idempotent PATCH:
PATCH /accounts/10
Content-Type: application/json
{
"balance": 500
}
If this sets balance to 500, then sending this request multiple times leaves the final balance at 500.
Recommendation:
Try to design PATCH operations as idempotent when possible.
Update specific field values, not "add", "toggle", or "increment" actions.
How to Handle Missing Fields
You must decide:
- If a field is not present in the PATCH body, do you:
- leave it unchanged, or
- set it to null or a default?
For partial updates, the usual behavior is:
- If a field is omitted, leave it unchanged.
- If a field is included with null, set it to
nullif allowed.
Example:
Current user:
{
"id": 1,
"full_name": "Alice",
"bio": "Hello",
"is_active": true
}PATCH request:
PATCH /users/1
Content-Type: application/json
{
"bio": null
}
Result (assuming bio can be null):
{
"id": 1,
"full_name": "Alice",
"bio": null,
"is_active": true
}Handling Unknown or Forbidden Fields
If the client sends a field that does not exist or is not allowed to be modified, you must decide what to do:
- Ignore unknown fields, or
- Return a client error, for example
400 Bad Request.
Example of an invalid PATCH body:
PATCH /users/1
Content-Type: application/json
{
"id": 99,
"created_at": "2020-01-01T00:00:00Z"
}
You probably do not want the client to modify id or created_at. A common approach is:
- Reject the request with
400 Bad Request - Explain that these fields cannot be modified
Validation and Error Handling with PATCH
Validating Partial Inputs
With PATCH, some fields may be missing. Your backend must:
- Accept that some fields are not present at all.
- Validate only the fields that are present.
- Combine them with existing resource values when needed.
Example rules for /users/{id}:
full_name: string length 1 to 100bio: string length 0 to 500 or nullemail: must be valid format and unique
PATCH request:
PATCH /users/1
Content-Type: application/json
{
"full_name": "",
"email": "not-an-email"
}full_namefails length validation (0 characters)emailfails email format validation
Response:
HTTP/1.1 400 Bad Request
Content-Type: application/json
{
"detail": [
{ "field": "full_name", "message": "Must not be empty." },
{ "field": "email", "message": "Invalid email address." }
]
}Only the fields provided are validated.
Common Status Codes for PATCH
| Status Code | When to Use for PATCH |
|---|---|
| 200 OK | Successful update, returns the updated resource |
| 204 No Content | Successful update, returns no body |
| 400 Bad Request | Invalid data, unknown fields, validation errors |
| 401 Unauthorized | Caller not authenticated |
| 403 Forbidden | Caller authenticated but not allowed to modify resource |
| 404 Not Found | Resource does not exist |
| 409 Conflict | Update conflicts with existing state (e.g. unique email) |
Example success response with updated resource:
HTTP/1.1 200 OK
Content-Type: application/json
{
"id": 1,
"email": "user@example.com",
"full_name": "New Name",
"bio": "New bio",
"is_active": true
}Example success response with no content:
HTTP/1.1 204 No ContentExamples of PATCH in a REST API
Example 1: Update a Todo Item
Imagine a todo resource:
{
"id": 10,
"title": "Buy groceries",
"description": "Milk, eggs, bread",
"completed": false,
"priority": "medium"
}Change only the `completed` field
PATCH /todos/10
Content-Type: application/json
{
"completed": true
}Result:
{
"id": 10,
"title": "Buy groceries",
"description": "Milk, eggs, bread",
"completed": true,
"priority": "medium"
}Change `title` and `priority` together
PATCH /todos/10
Content-Type: application/json
{
"title": "Buy groceries and snacks",
"priority": "high"
}Example 2: Partially Updating an Order
Order resource:
{
"id": 1001,
"status": "pending",
"shipping_address": "123 Main St",
"billing_address": "123 Main St",
"items": [
{ "product_id": 5, "quantity": 2 },
{ "product_id": 8, "quantity": 1 }
]
}Change only status
PATCH /orders/1001
Content-Type: application/json
{
"status": "shipped"
}Change shipping address and status
PATCH /orders/1001
Content-Type: application/json
{
"status": "processing",
"shipping_address": "456 New Address"
}
You do not need to send items or other fields.
Example 3: Clearing a Field
Suppose a user has an optional bio that can be removed.
Current:
{
"id": 1,
"full_name": "Alice",
"bio": "Hello",
"is_active": true
}
Client wants to delete the bio text:
PATCH /users/1
Content-Type: application/json
{
"bio": null
}
If your API allows bio = null, this is a clear way to say "remove the bio". You must document this behavior so clients know how to clear fields.
Practical Design Tips for PATCH
Keep the Model Simple
For beginners, use this approach:
- Accept a JSON object with any subset of resource fields.
- For each field:
- If present, validate and update the field.
- If absent, leave the field unchanged.
- Return
200 OKwith the updated resource.
Example for a blog post resource:
{
"id": 5,
"title": "Original title",
"content": "Original content",
"tags": ["python"],
"is_published": false
}PATCH request:
PATCH /posts/5
Content-Type: application/json
{
"title": "Updated title",
"tags": ["python", "backend"]
}Updated resource:
{
"id": 5,
"title": "Updated title",
"content": "Original content",
"tags": ["python", "backend"],
"is_published": false
}Avoid Mixing Behavior and Data
Try not to overload PATCH with procedural commands like:
{
"action": "publish"
}It is usually clearer to update the state directly:
{
"is_published": true
}Using state fields makes your API easier to reason about.
Document How PATCH Works in Your API
Your API documentation should explain:
- Which fields are updatable with PATCH
- Which fields are read-only
- What happens if a field is omitted
- How to remove or clear optional fields (for example,
null) - Validation rules for each field
This helps clients avoid surprises when using partial updates.
Summary
- PATCH is used for partial updates of a resource.
- Use the same resource URL as GET or PUT, for example
/users/{id}. - Request body usually contains only the fields that should be changed.
- Fields not included are typically left unchanged.
- PATCH is not guaranteed to be idempotent, but you should try to design it that way by setting field values instead of performing "increment" or "toggle" actions.
- Validate only the fields that appear in the request, and return appropriate HTTP status codes.
- For most beginner REST APIs, a simple "partial representation" PATCH is enough and easy to implement.
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!