9.14. ACID Properties
Table of Contents
Why ACID Properties Matter
When you build backend applications, your data must stay correct, even when:
- Many users write to the database at the same time
- Servers crash
- Network connections fail
- A request stops in the middle of its work
Relational databases like PostgreSQL rely on transactions and ACID properties to keep data safe and consistent in all these situations.
ACID is a set of guarantees that describe how transactional databases behave:
- Atomicity
- Consistency
- Isolation
- Durability
You do not usually configure ACID directly. Instead, you use transactions, and the database uses ACID rules to make your transactions safe.
In this chapter, you will learn what each letter means, with practical backend examples.
A for Atomicity
What Atomicity Means
Atomicity says: a transaction is all or nothing.
A transaction can contain many SQL statements. With atomicity, either:
- All statements succeed, and the database saves them, or
- Any statement fails, and the database discards all of them
Nothing is left half-applied.
Atomicity rule
A transaction is indivisible: it cannot be partially committed.
If any part of a transaction fails, the entire transaction must roll back.
Real-World Example: Money Transfer
Imagine a bank transfer between two accounts:
- Alice sends $50 to Bob
In SQL, this might be:
BEGIN;
UPDATE accounts
SET balance = balance - 50
WHERE id = 1; -- Alice
UPDATE accounts
SET balance = balance + 50
WHERE id = 2; -- Bob
COMMIT;Atomicity ensures that both updates happen together:
- If the first update succeeds but the second fails, the database must roll back the first one
- You must never end in a state where Alice lost $50 but Bob did not receive it
If something goes wrong between BEGIN and COMMIT, the whole transaction is undone with ROLLBACK:
BEGIN;
UPDATE accounts
SET balance = balance - 50
WHERE id = 1;
-- Something fails here, for example:
-- UPDATE accounts SET balance = balance + 50 WHERE id = 2;
-- raises an error
ROLLBACK; -- undo the change to Alice's balanceAtomicity is critical anywhere you need changes to move together:
- Creating an order and subtracting inventory
- Creating a user and inserting initial profile records
- Logging an action and updating a related counter
Grouping Operations into One Transaction
In your backend code, you usually do not write BEGIN and COMMIT by hand. Your database driver or ORM provides a transaction API.
Pseudo code example:
with db.transaction(): # start transaction
db.execute("UPDATE accounts SET balance = balance - 50 WHERE id = 1")
db.execute("UPDATE accounts SET balance = balance + 50 WHERE id = 2")
# leaving the 'with' block commits on success, or rolls back on error
If any execute call fails, the context manager rolls back automatically. Atomicity is then enforced by the database.
C for Consistency
What Consistency Means
Consistency says: a transaction must move the database from one valid state to another valid state.
A valid state is defined by:
- Data types
- Constraints
- Rules and business logic
Examples of constraints:
- A column
emailisUNIQUE agemust be>= 0- A foreign key must point to an existing row
- An
orders.total_pricemust equal the sum of its items
Consistency rule
Every committed transaction must preserve all defined constraints and rules.
The database must never commit a state that violates its own invariants.
Consistency has two parts:
- Database-level constraints that the database enforces automatically
- Application-level rules that only your backend code can enforce
Database-Level Consistency: Constraints
Examples of SQL constraints:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
age INT CHECK (age >= 0),
account_id INT REFERENCES accounts(id)
);If you try to insert invalid data, the database will reject it:
INSERT INTO users (email, age, account_id)
VALUES ('john@example.com', -5, 123); -- age < 0
-- ERROR: new row for relation "users" violates check constraint "users_age_check"Atomicity and consistency work together:
- The invalid statement fails
- The transaction that contained it rolls back
- The database stays in a consistent state
Application-Level Consistency: Business Rules
Not all rules can be expressed as SQL constraints. For example:
- A user cannot order more items than available stock
- A coupon can only be used 3 times
- A subscription must not overlap with another active subscription for the same user
These rules live in your backend code. You use checks before running SQL.
Example:
def create_order(user_id, product_id, quantity):
product = db.fetch_one("SELECT stock FROM products WHERE id = %s", (product_id,))
if product["stock"] < quantity:
raise ValueError("Not enough stock")
with db.transaction():
db.execute(
"INSERT INTO orders (user_id, product_id, quantity) VALUES (%s, %s, %s)",
(user_id, product_id, quantity),
)
db.execute(
"UPDATE products SET stock = stock - %s WHERE id = %s",
(quantity, product_id),
)Here, consistency depends on both:
- The application logic that checks the stock
- The database constraints that might also enforce extra rules, such as
stock >= 0
I for Isolation
What Isolation Means
Isolation says: transactions should not see each other's partial work.
When several transactions run at the same time, each one should behave as if it is the only one running, at least from its own point of view.
In practice, databases offer different isolation levels, which balance:
- Safety
- Performance
You will learn detailed isolation levels in a separate chapter. Here we focus on intuition and typical problems.
Isolation rule
Concurrent transactions must not interfere in a way that produces incorrect or inconsistent results.
Each transaction should see a controlled view of data, independent from other unfinished transactions.
Typical Concurrency Problems
When isolation is weak, you can get strange behaviors.
| Problem type | Description in simple words |
|---|---|
| Dirty read | A transaction reads data that another transaction has not committed yet |
| Non-repeatable read | A transaction reads the same row twice and sees different values |
| Phantom read | A transaction runs the same query twice and sees different sets of rows |
| Lost update | Two transactions update the same row, and one update overwrites the other |
Lost Update Example
Imagine two HTTP requests at the same time:
- User A opens a page to update their profile name
- User B also opens the same profile page
- Both change the name and click "Save" within a short time
Sequence:
- Transaction T1 (User A) reads:
name = 'John' - Transaction T2 (User B) reads:
name = 'John' - T1 updates:
name = 'John A' - T2 updates:
name = 'John B'
If nothing prevents it, the final value is John B. T1's update is lost.
With proper isolation and sometimes extra logic, you can detect or prevent this.
One common technique is optimistic locking:
ALTER TABLE users ADD COLUMN version INT NOT NULL DEFAULT 0;Then you update with a condition:
UPDATE users
SET name = 'John A', version = version + 1
WHERE id = 1 AND version = 3;
If another transaction already changed version, this update affects 0 rows. Your backend notices and retries or shows a conflict to the user.
Isolation Levels Overview
Most relational databases support these isolation levels:
| Isolation level | Typical problems allowed |
|---|---|
| Read Uncommitted | Dirty reads, non-repeatable reads, phantoms |
| Read Committed | No dirty reads, but non-repeatable and phantoms allowed |
| Repeatable Read | No dirty or non-repeatable reads, some phantoms may appear depending on DB |
| Serializable | Prevents all of the above, behaves as if transactions run one by one |
Isolating more strongly usually reduces concurrency or requires more internal work, such as locking or retrying transactions.
As a backend developer, you must:
- Know the default isolation level of your database
- Understand how it affects your application
- Increase or decrease isolation when needed
Example in PostgreSQL:
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
BEGIN;
-- transactional queries here
COMMIT;D for Durability
What Durability Means
Durability says: once a transaction is committed, its changes must not be lost, even if:
- The database process crashes
- The operating system crashes
- The power goes off
When the database comes back up, committed data must still be there.
Durability rule
After a transaction commits, the database must guarantee
that its changes will persist, even in the face of crashes.
How Databases Implement Durability
Implementation details vary, but common techniques include:
- Write-ahead logging (WAL)
The database writes all changes to a log on disk before applying them to the main data files.
If a crash happens, it can replay the log. - Flushing to disk
OnCOMMIT, the database ensures that data is written to non-volatile storage. - Recovery procedures
On startup after a crash, the database reads the log and: - Reapplies committed transactions that were not fully written
- Removes partial changes from incomplete transactions
As a backend developer, you do not implement these. But you must be aware that:
- Durability can have a performance cost
- Databases sometimes allow you to choose less strict durability for speed, but then you accept the risk of losing some last writes on a crash
Durability and Acknowledging Requests
In backend development, durability affects when you tell the user "success".
Example:
- Your API receives a POST
/ordersrequest - You insert a new row into
orderstable - The transaction commits
- You return HTTP 201 Created
If the database says "transaction committed", you can assume the order is safely stored. Even if the server crashes right after sending the response, the order is still in the database.
If you ever use features that relax durability, you must be careful about when you send a "success" response, because some writes might still be only in memory and not safe on disk.
How ACID Properties Work Together
ACID in One Transfer Example
Return to the money transfer example and see how ACID works as a whole.
Transaction:
BEGIN;
UPDATE accounts
SET balance = balance - 50
WHERE id = 1; -- Alice
UPDATE accounts
SET balance = balance + 50
WHERE id = 2; -- Bob
COMMIT;ACID guarantees:
- Atomicity
Both balances are updated together, or none are. - Consistency
Constraints, such asCHECK (balance >= 0), stay valid after the transaction. If they would be broken, the transaction fails and rolls back. - Isolation
Another transfer that reads the balance of Alice or Bob does not see a half-finished state of this transaction. - Durability
AfterCOMMIT, the new balances survive crashes.
Without any one of these, your data could become corrupted or surprising:
- Without atomicity, only one account might change
- Without consistency, negative balances might appear
- Without isolation, concurrent transfers might interfere
- Without durability, transfers might simply disappear after you send "success"
ACID and Backend Code
In practice, you usually call:
- BEGIN / COMMIT / ROLLBACK implicitly via your ORM
- Constraints via migrations and schema definitions
- Isolation level via configuration or per-transaction settings
Example pattern in a backend service:
def transfer(db, from_id, to_id, amount):
with db.transaction(): # atomic, durable unit
# checks for consistency
from_account = db.fetch_one("SELECT balance FROM accounts WHERE id = %s FOR UPDATE", (from_id,))
if from_account["balance"] < amount:
raise ValueError("Insufficient funds")
# changes
db.execute(
"UPDATE accounts SET balance = balance - %s WHERE id = %s",
(amount, from_id),
)
db.execute(
"UPDATE accounts SET balance = balance + %s WHERE id = %s",
(amount, to_id),
)
# on exit, commit is called. If anything fails, rollback happens.In this example:
- The
transaction()context manager gives you atomicity and durability - The code and database constraints together give you consistency
- The
FOR UPDATEclause helps with isolation, by locking the row while you change it
Common Misunderstandings About ACID
Misunderstanding 1: ACID Means Everything Is Always Perfect
ACID does not mean:
- You cannot have bugs in your logic
- All integrity rules are enforced automatically
- You never lose data due to disk failure or misconfiguration
ACID only describes behavior inside the database, with its own constraints and configuration.
You still must:
- Write correct business logic
- Use proper backups
- Configure replication and hardware
Misunderstanding 2: ACID Is Only for Banks
Banking is a classic example, but ACID is useful in many areas:
- E-commerce orders and payments
- Inventory updates
- Reservation systems (tickets, rooms, seats)
- Any multi-step operation that must not be partially applied
Any time you think "these operations must happen together", you are thinking about atomic transactions and ACID properties.
Misunderstanding 3: NoSQL Databases Are Always Non-ACID
Some NoSQL databases offer ACID properties, at least at the document level. Others offer limited forms or tunable consistency.
Relational databases are traditionally the strongest in ACID guarantees, but modern systems vary. When choosing a database, always check:
- Does it support transactions?
- What does ACID mean in its documentation?
- At what scope (single row, single document, multiple tables)?
Summary
- ACID describes four key properties of reliable transactions: Atomicity, Consistency, Isolation, Durability.
- Atomicity ensures that a transaction is all or nothing.
- Consistency keeps the database valid by enforcing constraints and rules.
- Isolation controls how concurrent transactions interact so they do not corrupt each other.
- Durability guarantees that committed data survives crashes.
As a backend developer, you make use of ACID by:
- Designing proper transactions around groups of related operations
- Defining constraints in your database schema
- Being aware of isolation levels and concurrency issues
- Trusting the database for durable writes, while still creating backups and disaster recovery plans
Understanding ACID is a foundation for every other database topic you will encounter, from schema design to performance and scalability.
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!