12.7. Updating Records
Table of Contents
Understanding Record Updates with an ORM
Updating records is one of the four core database operations, often grouped under CRUD, which stands for Create, Read, Update, Delete. In this chapter, you will learn how to update data when you use an ORM, with a focus on the mental model and typical patterns rather than on one specific framework.
You already know what an ORM is and how to create and read records from earlier chapters. Here we focus on what is unique about updating.
The Basic Update Flow
Although ORMs differ in syntax, most follow the same logical steps when you want to update something:
- Load the record from the database into an object.
- Modify attributes on that object.
- Mark changes for saving by telling the ORM you want to persist them.
- Commit the transaction so the changes are actually written to the database.
In pseudo code, a typical update looks like this:
# 1. Read the record
user = session.get(User, user_id)
# 2. Change some fields
user.email = "new_email@example.com"
user.is_active = True
# 3. Tell the ORM to save changes (often implicit)
session.add(user)
# 4. Commit
session.commit()In many ORMs, step 3 is optional once the object is attached to the session. The important idea is that the ORM tracks changes on loaded objects and writes them to the database when you commit.
Updating a Single Record
Updating a single record usually looks like updating a normal object in memory.
Step 1: Load the record
First get the record you want to change:
user = session.get(User, 42) # 42 is the primary keyIf the record might not exist, you must handle that case:
user = session.get(User, 42)
if user is None:
# handle "not found", for example:
raise ValueError("User not found")Step 2: Modify fields
You change attributes just like normal Python attributes:
user.name = "Alice Updated"
user.email = "alice.updated@example.com"
You can also use setattr if you want to update fields programmatically:
for field, value in {"name": "Alice Updated", "email": "alice.updated@example.com"}.items():
setattr(user, field, value)Step 3: Commit the changes
Once you are done changing attributes:
session.commit()
The ORM generates an UPDATE statement similar to:
UPDATE users
SET name = 'Alice Updated',
email = 'alice.updated@example.com'
WHERE id = 42;
The ORM only does this when you call commit (or sometimes flush).
Partial Updates
You do not need to set every field on the record. You can update just one or two attributes.
Examples:
# Update only the email
user.email = "new@example.com"
session.commit()
# Update only a boolean flag
user.is_active = False
session.commit()The ORM tracks which fields actually changed. Good ORMs generate SQL that updates only the modified fields. This improves performance and avoids accidental overwrites.
Sometimes you receive only some fields from an API request. A common pattern is:
def update_user_from_payload(user, data: dict):
# data might look like {"name": "Alice", "is_active": True}
for key, value in data.items():
if hasattr(user, key):
setattr(user, key, value)Then:
user = session.get(User, user_id)
if user is None:
raise ValueError("User not found")
update_user_from_payload(user, payload_dict)
session.commit()This maps naturally to HTTP PATCH semantics in REST APIs.
Bulk Updates
Sometimes you need to update many rows at once, for example when you deactivate all users who have not logged in for a year.
With an ORM you have two main strategies:
1. Load every record and update in Python
old_users = (
session.query(User)
.filter(User.last_login < one_year_ago)
.all()
)
for user in old_users:
user.is_active = False
session.commit()Pros:
- The ORM enforces validation and triggers any hooks / events on the Python objects.
- You can perform complex logic inside Python.
Cons:
- Loads all matching records into memory. This can be slow and heavy for large datasets.
2. Use a bulk update query
Many ORMs support a method that directly translates to a SQL UPDATE query without loading each record:
session.query(User).filter(User.last_login < one_year_ago).update(
{User.is_active: False}
)
session.commit()This generates one SQL statement:
UPDATE users
SET is_active = FALSE
WHERE last_login < :one_year_ago;Pros:
- Very fast and memory efficient for large numbers of rows.
Cons:
- Bypasses Python side logic on individual objects.
- The in memory objects for those rows, if they exist in the session, might be out of date until refreshed.
Important rule: Use bulk updates for performance, but remember they usually skip per object validation and events. Only use them when you are sure about the effect of the raw SQL.
Handling Not Found and Optional Updates
When you try to update something that may not exist, you must handle the missing case gracefully.
Example: Update or create error
user = session.get(User, user_id)
if user is None:
# Decide what to do: error or create new
raise ValueError(f"User with id {user_id} not found")
user.email = new_email
session.commit()In a web API, you usually convert this to an HTTP 404 response.
Optional field updates
Sometimes the input contains None for fields. You must decide what None means:
- It might mean "do not change this field".
- It might mean "set this field to NULL in the database".
One common pattern is to distinguish between "field is missing from the input" and "field is present with value null". For example:
def update_user(user, data):
if "name" in data:
user.name = data["name"] # even if None
if "email" in data:
user.email = data["email"]
If "name" is absent from data, you leave user.name as it is.
Concurrency and Lost Updates
Imagine two requests update the same user at nearly the same time.
- Request A loads the user.
- Request B loads the same user.
- Request A sets
email = "a@example.com"and commits. - Request B sets
name = "New Name"and commits.
If request B updates all fields from its in memory object, it might overwrite the email change from request A. This is called a lost update.
There are two common strategies to protect against this.
1. Let the database handle it with transactions
You can use transactions and isolation levels so that updates are serialized. Some ORMs also support "select for update" queries:
user = (
session.query(User)
.filter(User.id == user_id)
.with_for_update()
.one()
)This locks the row until the transaction commits.
2. Optimistic locking with a version field
You can add a version column that increments on every update.
Example table:
| Column | Type |
|---|---|
| id | integer |
| name | text |
| text | |
| version | integer |
Workflow:
- Load the user, including
version. - When updating, send
versionback. - The ORM generates an update that checks the version:
UPDATE users
SET name = :name,
email = :email,
version = version + 1
WHERE id = :id AND version = :version;- If no row is updated (row count is 0), it means someone else already changed it. You can then raise a concurrency error.
Many ORMs have built in support for this pattern.
Important rule: In concurrent systems, always think about lost updates. Use transactions, locks, or version columns to protect critical data.
Updates and Transactions
Every update should be part of a transaction. In most ORMs, one session.commit() corresponds to committing a transaction.
You can combine several operations:
# Start transaction
user = session.get(User, user_id)
order = session.get(Order, order_id)
user.last_order_id = order.id
order.status = "processed"
# Both updates are committed together
session.commit()
If anything fails before the commit, you call session.rollback() and the database discards all partial changes.
This is important for maintaining consistent data.
Updating Related Records
When you have relationships, you can update related records through the object graph. This uses the ORM features you learned in the relationships chapter.
Example: Update a one to many relationship
Suppose a User has many Address entries:
user = session.get(User, user_id)
# Update the first address line
addr = user.addresses[0]
addr.line1 = "New Street 123"
session.commit()
The ORM notices that an Address object changed and generates an UPDATE for the addresses table.
Replacing an entire collection
To replace all existing addresses with a new list:
user.addresses = [
Address(line1="Street 1", city="Paris"),
Address(line1="Street 2", city="Berlin"),
]
session.commit()Depending on configuration, the ORM might:
- Insert new rows and delete old ones, or
- Try to update existing ones.
You must understand the relationship settings in your ORM so you know what exactly happens when you reassign collections.
Avoiding Common Mistakes
1. Forgetting to commit
If you change attributes but do not call commit, nothing is persisted.
user = session.get(User, user_id)
user.email = "new@example.com"
# No commit, so no SQL UPDATE is sentIn a request handling function, make sure you either:
- Commit explicitly, or
- Use a helper that commits automatically at the end if everything succeeds.
2. Updating detached objects
Sometimes you create or load an object outside the current session. Then you try to commit:
user = User(id=42, email="new@example.com") # not loaded from session
session.add(user)
session.commit()
If the ORM thinks this is a new object, it might try to INSERT instead of UPDATE. To update an existing row without loading it, many ORMs have a special method, for example "merge", or you use a query based update.
Better, load the object from the session first, then modify:
user = session.get(User, 42)
user.email = "new@example.com"
session.commit()3. Accidentally overwriting data
If you convert an entire request body to a model and assign it directly, you may overwrite fields that were not part of the request or that the user should not control.
Instead, explicitly choose which fields can be updated:
allowed_fields = ["name", "email"]
for field in allowed_fields:
if field in data:
setattr(user, field, data[field])This is called a whitelist approach and is safer.
When to Use ORM Updates vs Raw SQL
Most of the time, ORM based updates are enough and make your code clearer. However, sometimes raw SQL is better.
Use ORM style updates when:
- You update a few records.
- You want to reuse model validations or business logic.
- You want to work with rich objects, not rows.
Use raw SQL or bulk operations when:
- You update very large sets of rows.
- You need very specific or complex SQL behavior.
- Performance is critical and you know exactly what you are doing.
You can always mix approaches in one application. The key is to be consistent within a given use case and to document when you bypass the ORM.
Summary
- Updating with an ORM follows the same pattern: load, modify, commit.
- You can do partial updates by changing only selected attributes.
- Bulk updates are efficient for many rows, but often skip per object logic.
- Always handle the "not found" case when loading records to update.
- Think about concurrency to avoid lost updates, especially in multi user systems.
- Wrap updates in transactions so that related changes succeed or fail together.
- When updating relationships, treat them like normal attributes, but know how your ORM handles cascades and collection changes.
- Avoid common errors such as forgetting to commit, updating detached objects incorrectly, or overwriting fields you did not intend to change.
With these patterns, you can safely and predictably change data through your ORM, which is essential for building reliable backend applications.
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!