12.8. Deleting Records
Table of Contents
Understanding Deleting Records with an ORM
When you work with an ORM, deleting data is not just about removing rows from a table. You need to think about object state, transactions, constraints, relationships, and safety. In this chapter, you will see how deleting records works conceptually with an ORM, with many examples inspired by SQLAlchemy, but the ideas apply to most ORMs.
Basic Ways to Delete a Record
There are two common ways to delete data with an ORM:
- Delete a loaded object instance.
- Issue a bulk delete using a query.
Deleting a single loaded instance
This is the most explicit and usually the safest way. You first load an object from the database, then ask the ORM to delete it:
user = session.get(User, 1) # load user with primary key 1
if user is not None:
session.delete(user)
session.commit()What happens here:
session.getloads theUserrow withid = 1.session.delete(user)marks this instance as "deleted" in the session.session.commit()actually sends aDELETE FROM users WHERE id = 1to the database.
Until you call commit, no row is actually removed in the database.
You can also roll back:
user = session.get(User, 1)
session.delete(user)
session.rollback() # delete is cancelled
After rollback, the user row still exists in the database.
Bulk delete via query
Bulk deletes act directly in the database. You do not need to load each record as an object.
from sqlalchemy import delete
stmt = delete(User).where(User.is_inactive == True)
result = session.execute(stmt)
session.commit()
print(result.rowcount) # number of deleted rowsIn many ORMs the syntax differs, but the pattern is similar:
- Build a query that selects a group of rows.
- Call a special
deletemethod on that query. - Commit the transaction.
Bulk deletes usually do not trigger normal ORM object lifecycle hooks or relationship behavior in the same way as deleting individual objects. Use them carefully.
Object States During Deletion
ORMs track the "state" of objects:
| State | Meaning |
|---|---|
| Transient | Not in session, not in database |
| Pending | In session, not yet in database (will be inserted) |
| Persistent | In session and present in database |
| Deleted | In session, marked for deletion, not yet committed |
| Detached | No longer associated with a session |
Deleting works only on persistent instances.
Life cycle example
user = User(name="Alice") # transient
session.add(user) # pending
session.commit() # persistent (row exists in DB)
session.delete(user) # deleted (marked)
session.commit() # row removed from DB, user becomes detached
After the final commit, attempts to use user.id are fine, but reloading data from the DB for that user will fail because the row is gone.
Deleting by Primary Key
A very common pattern is delete-by-id.
Load then delete
def delete_user_by_id(session, user_id: int) -> bool:
user = session.get(User, user_id)
if user is None:
return False
session.delete(user)
session.commit()
return TrueYou can return a boolean, raise an exception, or silently ignore missing rows, depending on your API design.
Delete directly with a filter
from sqlalchemy import delete
def delete_user_by_id(session, user_id: int) -> int:
stmt = delete(User).where(User.id == user_id)
result = session.execute(stmt)
session.commit()
return result.rowcount- If
rowcount == 0, the user did not exist. - This does not require loading a
Userobject.
Conditional Deletes
You often need to delete only some rows that match a condition.
Delete inactive users older than a date
from datetime import datetime, timedelta
from sqlalchemy import delete
cutoff = datetime.utcnow() - timedelta(days=365)
stmt = delete(User).where(
User.is_active == False,
User.last_login < cutoff,
)
result = session.execute(stmt)
session.commit()
print(f"Deleted {result.rowcount} users")Delete all tasks of a user
from sqlalchemy import delete
def delete_tasks_for_user(session, user_id: int) -> int:
stmt = delete(Task).where(Task.user_id == user_id)
result = session.execute(stmt)
session.commit()
return result.rowcount
Use conditions to avoid deleting too much. For safety, many teams avoid DELETE without a WHERE clause.
Cascading Deletes and Relationships
When you delete a record that has related rows, what happens to those rows?
You must actively decide this behavior in your schema and ORM configuration.
Types of cascading behavior
On the database side, typical options are:
| Behavior | Description |
|---|---|
RESTRICT / none | Prevent delete if children exist |
CASCADE | Delete children automatically |
SET NULL | Set foreign key to NULL in child rows |
In an ORM, you often see similar options as relationship parameters, for example in SQLAlchemy:
cascade="all, delete-orphan"passive_deletes=True
Example: User and Posts
Imagine:
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
name = Column(String)
posts = relationship(
"Post",
back_populates="author",
cascade="all, delete-orphan",
)
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("users.id"))
title = Column(String)
author = relationship("User", back_populates="posts")Deleting a user
user = session.get(User, 1)
session.delete(user)
session.commit()
Because of cascade="all, delete-orphan":
- The ORM also deletes all
Postobjects related to this user in the same transaction. - You do not need to delete posts manually.
If you remove the cascade option, the database may prevent deleting the user if there are related posts, depending on the foreign key constraint.
Always understand your delete cascade rules. A single session.delete(user) can remove a long chain of related records if cascades are configured.
ORM vs Database Cascades
You can configure cascade at two levels:
- In the ORM relationship.
- In the database foreign key.
ORM-level cascade
The ORM loads and deletes child objects in memory according to the relationship settings. This works even if the database foreign key does not have ON DELETE CASCADE.
Example behavior:
- You load
userwith itsposts. - You call
session.delete(user). - The ORM issues individual DELETE statements for posts and user.
Database-level cascade
The database itself handles cascade deletes using ON DELETE CASCADE in the foreign key definition.
For example, in SQL:
ALTER TABLE posts
ADD CONSTRAINT posts_user_id_fkey
FOREIGN KEY (user_id)
REFERENCES users(id)
ON DELETE CASCADE;Now, when a user row is deleted, the database removes posts that reference it, even if you used a bulk delete that the ORM does not fully track.
In SQLAlchemy-style ORM, you can hint this with:
user_id = Column(
Integer,
ForeignKey("users.id", ondelete="CASCADE"),
)Combined approaches are common. For example:
- Use database
ON DELETE CASCADEfor safety and consistency. - Use
passive_deletes=Trueon ORM relationships to let the database handle deletes, and reduce ORM work.
Safe Deletion Patterns
Completely removing data is risky if you make a mistake. Many applications use "soft deletes" for safety.
Hard delete vs soft delete
| Type | What happens | Pros | Cons |
|---|---|---|---|
| Hard delete | Row is removed from the table | Saves space, simpler queries | Data cannot be recovered |
| Soft delete | Row is marked as deleted but not removed | Recoverable, good for audits | Queries must filter out deleted rows |
Implementing soft delete
Add a deleted_at or is_deleted column.
from datetime import datetime
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
name = Column(String)
deleted_at = Column(DateTime, nullable=True)Instead of:
session.delete(user)
session.commit()You do:
def soft_delete_user(user: User):
user.deleted_at = datetime.utcnow()
# ORM will issue UPDATE, not DELETEThen, change your queries to ignore deleted users:
active_users = (
session.query(User)
.filter(User.deleted_at.is_(None))
.all()
)If you implement soft delete, every query that should ignore deleted records must filter by the soft delete flag. Forgetting this leaks "deleted" data back into your application.
Some ORMs support "query filters" or "scopes" that automatically apply deleted_at IS NULL to every query. These are very helpful.
Transactions When Deleting
Deletes should almost always be part of a transaction. Transactions ensure that either:
- All related deletes succeed, or
- None are applied.
Delete with try / except / rollback
def delete_user_and_posts(session, user_id: int):
try:
user = session.get(User, user_id)
if user is None:
return False
session.delete(user) # cascade may delete posts
session.commit()
return True
except Exception:
session.rollback()
raiseThis pattern:
- Prevents your database from ending up in a partially deleted state if something fails.
- Is essential when multiple related rows must be consistent.
Bulk delete inside a transaction
from sqlalchemy import delete
def cleanup_old_logs(session):
try:
stmt = delete(Log).where(Log.created_at < some_date)
session.execute(stmt)
session.commit()
except Exception:
session.rollback()
raiseHandling Missing Records
Deleting something that is not there should be clearly defined in your API.
Options:
- Return
Falseor0if nothing was deleted. - Raise a "Not Found" error.
- Silently do nothing.
Example: Raise an exception if not found
class NotFoundError(Exception):
pass
def delete_task(session, task_id: int):
task = session.get(Task, task_id)
if task is None:
raise NotFoundError(f"Task {task_id} not found")
session.delete(task)
session.commit()In a REST API, you might translate this to an HTTP 404 response.
Deleting With a Repository Pattern
In many codebases, direct session access is hidden behind repositories. A repository isolates data access logic.
Simple repository example
class UserRepository:
def __init__(self, session):
self.session = session
def get(self, user_id: int) -> User | None:
return self.session.get(User, user_id)
def delete(self, user: User) -> None:
self.session.delete(user)
def delete_by_id(self, user_id: int) -> bool:
user = self.get(user_id)
if user is None:
return False
self.delete(user)
return TrueThen your service layer can manage transactions:
def delete_user_service(session, user_id: int) -> bool:
repo = UserRepository(session)
try:
deleted = repo.delete_by_id(user_id)
session.commit()
return deleted
except Exception:
session.rollback()
raiseThis keeps session and transaction logic in one place and makes it easier to test.
Bulk Deletes vs Per-Object Deletes
Choosing between bulk delete and per-object delete involves trade-offs.
Per-object delete
users = session.query(User).filter(User.is_inactive == True).all()
for user in users:
session.delete(user)
session.commit()Pros:
- Triggers normal ORM cascade and events.
- Lets you run logic per object (for example, sending notifications, logging, etc).
Cons:
- Loads all objects into memory.
- Can be slow for large numbers of rows.
Bulk delete
from sqlalchemy import delete
stmt = delete(User).where(User.is_inactive == True)
session.execute(stmt)
session.commit()Pros:
- Very fast for large sets.
- Uses a single SQL statement.
Cons:
- Does not usually load objects or trigger all ORM-level behaviors.
- You cannot easily hook per-object logic unless you do it yourself.
Do not use bulk deletes when you rely on ORM cascades or per-object validation logic. Use them for pure data cleanup tasks where you fully understand the consequences.
Example: Deleting a Record in a REST API
Imagine a FastAPI endpoint that deletes a task. At this point, you already have routing and response handling in other chapters, so we only focus on the deletion behavior.
from fastapi import APIRouter, HTTPException, status, Depends
from sqlalchemy.orm import Session
router = APIRouter()
@router.delete(
"/tasks/{task_id}",
status_code=status.HTTP_204_NO_CONTENT,
)
def delete_task_endpoint(
task_id: int,
session: Session = Depends(get_session),
):
task = session.get(Task, task_id)
if task is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Task not found",
)
session.delete(task)
session.commit()
# 204 No Content, so no body is returnedKey points:
- Load the record by primary key.
- If not found, return 404.
- Use
session.delete, thencommit. - Rely on cascade rules to remove related data if necessary.
Summary
Deleting records with an ORM is more than just DELETE FROM table:
- Use
session.delete(obj)for per-object, safe, cascade-aware deletions. - Use bulk delete statements for efficient cleanup, but know that they bypass some ORM behaviors.
- Configure and understand cascade rules for relationships so you do not accidentally orphan or over-delete data.
- Prefer soft deletes when you need auditability or recovery.
- Always perform deletes inside transactions with proper error handling.
- In higher layers like services or API endpoints, treat "not found" as a first-class case.
With these patterns, you can remove data safely and predictably in your 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!