12.11. Transactions
Table of Contents
Why Transactions Matter in Backend Applications
In real backend applications, you often need several database operations to succeed or fail as one unit. For example:
- Create an order.
- Reserve items in inventory.
- Charge the customer.
If any step fails, you do not want a half-created order. This is exactly what database transactions solve.
A transaction is a group of database operations that the database treats as a single logical unit of work.
Key rule: A transaction is all or nothing. Either all the operations in the transaction succeed and are committed, or any failure causes all changes to be rolled back.
When using an ORM like SQLAlchemy, you will rarely write BEGIN or COMMIT SQL manually, but you must understand what they mean and how to control them.
Basic Transaction Lifecycle
Most database systems, and ORMs that talk to them, follow the same basic cycle:
- Start a transaction.
- Run one or more SQL statements (through ORM methods).
- If everything is OK, commit.
- If something goes wrong, roll back.
In SQL the pattern looks like this:
BEGIN;
INSERT INTO users (email) VALUES ('alice@example.com');
UPDATE accounts SET balance = balance - 100 WHERE user_id = 1;
COMMIT;If anything fails:
ROLLBACK;With an ORM, the code is more like:
from sqlalchemy.orm import Session
def create_user_and_charge(session: Session):
new_user = User(email="alice@example.com")
session.add(new_user)
account = session.get(Account, 1)
account.balance -= 100
# If we reach here with no errors:
session.commit()
# If an error happened, we want session.rollback()Commit and Rollback with an ORM
Explicit control
Most ORMs support explicit methods for transaction control. Using SQLAlchemy as an example:
def transfer_money(session: Session, from_id: int, to_id: int, amount: int):
try:
# 1. Read accounts
from_account = session.get(Account, from_id)
to_account = session.get(Account, to_id)
if from_account.balance < amount:
raise ValueError("Insufficient funds")
# 2. Update balances
from_account.balance -= amount
to_account.balance += amount
# 3. Try to commit
session.commit()
except Exception:
# 4. If any error occurs, undo all changes
session.rollback()
raiseImportant notes:
- All changes to
from_accountandto_accounthappen inside one transaction. - If a failure happens at any point before
session.commit(), the transaction is rolled back, and the database state stays unchanged.
Using context managers
Context managers are a safer and cleaner pattern:
from sqlalchemy.orm import Session
def transfer_money(engine, from_id: int, to_id: int, amount: int):
with Session(engine) as session:
try:
from_account = session.get(Account, from_id)
to_account = session.get(Account, to_id)
if from_account.balance < amount:
raise ValueError("Insufficient funds")
from_account.balance -= amount
to_account.balance += amount
session.commit()
except Exception:
session.rollback()
raise
Even better, SQLAlchemy offers session.begin():
def transfer_money(session: Session, from_id: int, to_id: int, amount: int):
with session.begin(): # starts a transaction
from_account = session.get(Account, from_id)
to_account = session.get(Account, to_id)
if from_account.balance < amount:
raise ValueError("Insufficient funds")
from_account.balance -= amount
to_account.balance += amount
# If no errors, `with` automatically commits.
# If there is an error, it automatically rolls back.Grouping Multiple Operations in One Transaction
A transaction is most useful when it groups multiple related operations.
Example: Creating an order
Suppose you have these models:
class Order(Base):
__tablename__ = "orders"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("users.id"))
status = Column(String) # "pending", "paid", "failed"
class OrderItem(Base):
__tablename__ = "order_items"
id = Column(Integer, primary_key=True)
order_id = Column(Integer, ForeignKey("orders.id"))
product_id = Column(Integer, ForeignKey("products.id"))
quantity = Column(Integer)
class Product(Base):
__tablename__ = "products"
id = Column(Integer, primary_key=True)
name = Column(String)
stock = Column(Integer)When a user places an order, you want to:
- Create an
Order. - Insert
OrderItemrows. - Reduce
Product.stockfor each product. - If any step fails, do not create a partial order.
With transactions:
def place_order(session: Session, user_id: int, items: list[dict]):
"""
items example: [{"product_id": 1, "quantity": 2}, {"product_id": 5, "quantity": 1}]
"""
with session.begin():
# 1. Create order
order = Order(user_id=user_id, status="pending")
session.add(order)
session.flush() # ensure order.id is assigned
# 2. Add items and update stock
for item in items:
product = session.get(Product, item["product_id"])
if product.stock < item["quantity"]:
raise ValueError("Not enough stock for product " + str(product.id))
# Create order item
order_item = OrderItem(
order_id=order.id,
product_id=product.id,
quantity=item["quantity"],
)
session.add(order_item)
# Reduce stock
product.stock -= item["quantity"]
# 3. If we get here without Raises, transaction will commit
order.status = "paid"
# Any exception inside `with session.begin()` will roll back everythingKey points:
- All inserts and updates are part of one transaction.
- If stock is insufficient for any product, the
ValueErrortriggers a rollback. - The database sees either a full order with proper stock updates or nothing.
Nested Transactions and Savepoints
Sometimes you want to treat a part of your work as "optional" inside a larger transaction. For example:
- Create an order.
- Try to create a shipping label.
- If label creation fails, you still want the order, but you want to record that shipping failed.
You can handle some of this with application logic, or with savepoints and nested transactions.
Savepoints concept
A savepoint is like a bookmark inside a transaction. You can roll back to the savepoint without canceling the entire transaction.
In SQL:
BEGIN;
INSERT INTO orders (...) VALUES (...);
SAVEPOINT maybe_shipping;
INSERT INTO shipping_labels (...) VALUES (...); -- might fail
-- If the insert fails:
ROLLBACK TO SAVEPOINT maybe_shipping;
COMMIT;With SQLAlchemy:
def create_order_with_optional_label(session: Session, order_data, label_data):
with session.begin(): # outer transaction
order = Order(**order_data)
session.add(order)
session.flush()
# Create a savepoint
nested = session.begin_nested()
try:
label = ShippingLabel(order_id=order.id, **label_data)
session.add(label)
nested.commit() # commit subtransaction
except Exception:
nested.rollback()
# mark order for manual shipping
order.status = "needs_manual_shipping"Notes:
session.begin_nested()uses a savepoint under the hood.- Rolling back
nesteddoes not cancel the creation oforder. - The outer
with session.begin()still commits, so the order is saved.
Transaction Boundaries per Request
In web backends, a very common pattern is:
- One transaction per incoming HTTP request.
This is often called "unit of work per request".
Pattern:
- A request arrives.
- The framework creates a database session.
- All database operations are executed inside that session and one transaction.
- If the request handler finishes successfully, the transaction commits.
- If an exception happens, the transaction rolls back.
Example using a dependency in FastAPI style:
from sqlalchemy.orm import Session
def get_db_session():
session = Session(engine)
try:
yield session
session.commit() # commit if no exception
except Exception:
session.rollback() # rollback on error
raise
finally:
session.close()Then in your route:
@app.post("/orders")
def create_order(order_input: OrderCreate, db: Session = Depends(get_db_session)):
# Everything here is inside one transaction
order = Order(user_id=order_input.user_id, status="pending")
db.add(order)
# ...
return {"id": order.id}Benefits:
- Simple mental model: each request changes the database in one atomic unit.
- Errors do not leave the database in a half-updated state.
Concurrency, Isolation, and Common Pitfalls
Transactions become more interesting when multiple clients use the database at the same time.
Imagine two requests that both try to transfer money from the same account:
- Request A reads balance = 100, subtracts 80, sets 20.
- At the same time,
- Request B reads balance = 100, subtracts 70, sets 30.
Depending on how you write your code and what isolation level the database uses, you might end with a lost update.
You do not need full ACID details here, but you must understand some practical issues.
Example: Lost updates
Bad pattern:
def withdraw(session: Session, account_id: int, amount: int):
account = session.get(Account, account_id) # SELECT
account.balance -= amount # in memory
session.commit() # UPDATEIf two withdrawals run at the same time:
- Both read balance 100.
- One subtracts 70, sets 30.
- The other subtracts 50, sets 50.
- Final balance is 50 instead of 100 - 70 - 50 = -20 or some conflict.
To avoid this, you can:
- Use database constraints.
- Use explicit locking (discussed next).
- Use "check and update" patterns.
Locking rows for update
Many ORMs let you use SELECT ... FOR UPDATE to lock rows within a transaction.
With SQLAlchemy:
from sqlalchemy import select
def safe_withdraw(session: Session, account_id: int, amount: int):
with session.begin():
stmt = (
select(Account)
.where(Account.id == account_id)
.with_for_update()
)
account = session.execute(stmt).scalar_one()
if account.balance < amount:
raise ValueError("Insufficient funds")
account.balance -= amountHere:
with_for_update()locks the account row in the database for this transaction.- If another transaction tries the same, it will wait until the lock is released, so you do not get conflicting writes.
Important: When you modify shared data from multiple requests or workers, you must think about concurrency. Use:
- proper transaction boundaries,
- row-level locks when needed,
- and database constraints to enforce rules.
Idempotency and Retries with Transactions
In distributed systems, sometimes operations are retried. For example:
- A payment webhook is sent twice.
- A client times out and resends a request.
If your transaction is not careful, a retry might duplicate work. Transactions help keep things atomic, but they do not automatically make operations idempotent.
Simple pattern for idempotent writes:
- Use a unique key for the operation, for example
idempotency_key. - Insert a row with that key inside a transaction.
- If another request with the same key arrives, the unique constraint prevents duplication.
Example:
class Payment(Base):
__tablename__ = "payments"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("users.id"))
amount = Column(Integer)
idempotency_key = Column(String, unique=True)Handler:
from sqlalchemy.exc import IntegrityError
def process_payment(session: Session, user_id: int, amount: int, idem_key: str):
with session.begin():
payment = Payment(
user_id=user_id,
amount=amount,
idempotency_key=idem_key,
)
session.add(payment)
try:
session.flush() # attempts INSERT, may raise IntegrityError
except IntegrityError:
# Payment with this key already exists.
# You can fetch it and return the same result.
existing = (
session.query(Payment)
.filter_by(idempotency_key=idem_key)
.one()
)
return existing
# Continue with work that depends on the new payment
return paymentHere, the combination of:
- a unique constraint, and
- a transaction,
guarantees that either the new payment is created once, or an existing one is used.
Practical Tips and Common Mistakes
Tips
- Use context managers (
with session.begin():) to automatically handle commit and rollback. - Keep transactions short. Do not do long CPU work or network calls while a transaction is open.
- Use one transaction per request as a default pattern.
- Let database constraints help you keep data valid. Transactions and constraints work together.
Common mistakes
| Mistake | Problem | Better approach |
|---|---|---|
Forgetting to call commit() | Changes stay uncommitted and may be lost | Always commit at the end of a successful unit of work |
| Doing long external calls inside a transaction | Holds locks longer, increases contention | Fetch data first, then open a short transaction only for the database changes |
| Mixing many unrelated operations in one transaction | Hard to reason about and debug | Keep each transaction focused on a single logical operation |
| Using global session without clear boundaries | Hidden open transactions and stale state | Use scoped or per-request sessions and clear open/close rules |
Transactions are a fundamental part of safe backend development with an ORM. Once you understand how to group operations, commit, roll back, and think about concurrency, you can build reliable data workflows in your 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!