10.11. JOINs
Table of Contents
Why JOINs Matter
Relational databases split data into multiple tables. JOINs let you combine rows from those tables in a single query.
Without JOINs you would:
- Run multiple queries.
- Fetch data separately.
- Combine it in your application code.
With JOINs the database does the combination for you, which is:
- Faster, because the database is optimized for this.
- Simpler, because your SQL directly describes what you want.
Throughout this chapter we will use a simple example schema.
Example Tables
Imagine a basic shop:
CREATE TABLE customers (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
email TEXT UNIQUE NOT NULL
);
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
customer_id INTEGER NOT NULL,
order_date DATE NOT NULL,
total NUMERIC(10, 2) NOT NULL,
FOREIGN KEY (customer_id) REFERENCES customers(id)
);
CREATE TABLE order_items (
id SERIAL PRIMARY KEY,
order_id INTEGER NOT NULL,
product_id INTEGER NOT NULL,
quantity INTEGER NOT NULL,
price NUMERIC(10, 2) NOT NULL,
FOREIGN KEY (order_id) REFERENCES orders(id)
);
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
price NUMERIC(10, 2) NOT NULL
);Some sample data:
INSERT INTO customers (id, name, email) VALUES
(1, 'Alice', 'alice@example.com'),
(2, 'Bob', 'bob@example.com'),
(3, 'Cara', 'cara@example.com');
INSERT INTO orders (id, customer_id, order_date, total) VALUES
(1, 1, '2024-08-01', 120.00), -- Alice
(2, 1, '2024-08-05', 50.00), -- Alice
(3, 2, '2024-08-03', 75.00); -- Bob
INSERT INTO products (id, name, price) VALUES
(1, 'Keyboard', 40.00),
(2, 'Mouse', 20.00),
(3, 'Monitor', 200.00);
INSERT INTO order_items (id, order_id, product_id, quantity, price) VALUES
(1, 1, 1, 1, 40.00), -- order 1, keyboard
(2, 1, 2, 2, 20.00), -- order 1, two mice
(3, 2, 2, 1, 20.00), -- order 2, one mouse
(4, 3, 1, 1, 40.00); -- order 3, keyboardWe will use these tables in JOIN examples.
Important rule: A JOIN always operates on two tables (or subqueries) at a time, and combines rows based on a condition, usually linking primary keys and foreign keys.
JOIN Syntax Basics
The general pattern:
SELECT
columns
FROM
table1
<JOIN TYPE> JOIN table2
ON join_condition;Key parts:
JOIN TYPEdefines how rows are matched and which rows are kept.ONdefines the matching rule, oftentable1.id = table2.some_foreign_key.
You can assign aliases to tables to keep queries short:
SELECT
c.name,
o.id AS order_id
FROM customers AS c
JOIN orders AS o
ON c.id = o.customer_id;Using aliases is very common in real projects.
INNER JOIN
An INNER JOIN returns only rows where the join condition matches in both tables.
Think of it as:
"Give me only the pairs where both sides exist and match."
Simple INNER JOIN example
List all orders with their customer name:
SELECT
o.id AS order_id,
o.order_date,
o.total,
c.name AS customer_name
FROM orders AS o
INNER JOIN customers AS c
ON o.customer_id = c.id;Result:
| order_id | order_date | total | customer_name |
|---|---|---|---|
| 1 | 2024-08-01 | 120.0 | Alice |
| 2 | 2024-08-05 | 50.0 | Alice |
| 3 | 2024-08-03 | 75.0 | Bob |
If a customer had no orders, that customer would not appear, because INNER JOIN only shows matches.
You can omit INNER:
SELECT ...
FROM orders o
JOIN customers c
ON o.customer_id = c.id;
By default, JOIN is INNER JOIN.
INNER JOIN across multiple tables
You can chain JOINs:
SELECT
c.name AS customer_name,
o.id AS order_id,
p.name AS product_name,
oi.quantity,
oi.price
FROM customers c
JOIN orders o
ON c.id = o.customer_id
JOIN order_items oi
ON o.id = oi.order_id
JOIN products p
ON oi.product_id = p.id;This returns every order item, with customer and product information.
LEFT JOIN
A LEFT JOIN returns all rows from the left table, and the matching rows from the right table. If there is no match, the right side columns are NULL.
Think of it as:
"Give me everything on the left, and what matches on the right, or NULL if there is no match."
LEFT JOIN example
List all customers and their orders, even if some customers have no orders:
SELECT
c.name AS customer_name,
o.id AS order_id,
o.total
FROM customers c
LEFT JOIN orders o
ON c.id = o.customer_id
ORDER BY c.id, o.id;Result (with our sample data):
| customer_name | order_id | total |
|---|---|---|
| Alice | 1 | 120.0 |
| Alice | 2 | 50.0 |
| Bob | 3 | 75.0 |
| Cara | NULL | NULL |
Cara has no orders, but still appears. The order columns are NULL.
This is very useful when you want to:
- See entries that might not have children (like customers without orders).
- Start from a main table and show related data only if it exists.
LEFT JOIN with filtering
A common trap is filtering away your left-joined rows. For example, if you want customers who have no orders, you might write:
SELECT
c.name,
o.id AS order_id
FROM customers c
LEFT JOIN orders o
ON c.id = o.customer_id
WHERE o.id IS NULL;Result:
| name |
|---|
| Cara |
The logic:
- LEFT JOIN returns all customers.
- Customers without orders get
o.id = NULL. WHERE o.id IS NULLkeeps only those.
Important rule: With LEFT JOIN, to find rows that have no match in the right table, filter with WHERE right_table.column IS NULL.
If you mistakenly put conditions in the WHERE clause that require non-NULL right table columns, you might unintentionally turn a LEFT JOIN into something that behaves like an INNER JOIN. A safer pattern is to put such conditions inside the ON clause when you want to keep non-matching left rows.
Example of a subtle difference:
-- Condition in WHERE: removes non-matching rows
SELECT c.name, o.id
FROM customers c
LEFT JOIN orders o
ON c.id = o.customer_id
WHERE o.total > 50;
-- Condition in ON: preserves non-matching rows
SELECT c.name, o.id
FROM customers c
LEFT JOIN orders o
ON c.id = o.customer_id AND o.total > 50;In the second query, customers with no orders still appear, because the LEFT JOIN keeps them and the condition is part of the join, not a filter afterward.
RIGHT JOIN
A RIGHT JOIN is the mirror of a LEFT JOIN.
It returns:
- All rows from the right table.
- Matching rows from the left.
- NULLs for the left table when there is no match.
Many developers almost never use RIGHT JOIN, and instead simply switch the order of tables and use LEFT JOIN.
RIGHT JOIN example
List all customers and their orders using RIGHT JOIN:
SELECT
c.name AS customer_name,
o.id AS order_id,
o.total
FROM orders o
RIGHT JOIN customers c
ON o.customer_id = c.id
ORDER BY c.id, o.id;This gives the same result as the previous LEFT JOIN example.
In practice, you can choose either:
LEFT JOINwithcustomerson the left.RIGHT JOINwithcustomerson the right.
Most codebases prefer LEFT JOIN only, because it is more common and easier to read.
FULL OUTER JOIN
A FULL OUTER JOIN returns:
- All rows that appear in the left table.
- All rows that appear in the right table.
- Matching rows merged.
- Non-matching rows filled with NULLs on the missing side.
Think of it as:
"Give me everything from both tables. If there is a match, combine them. If not, still show the row with NULLs on the other side."
Not all databases support FULL OUTER JOIN, but PostgreSQL does. Some systems emulate it with UNION.
FULL OUTER JOIN example
Imagine this scenario. We track:
- customers who placed orders in our system.
- marketing signups in a separate table.
CREATE TABLE marketing_signups (
email TEXT PRIMARY KEY,
signup_date DATE NOT NULL
);
INSERT INTO marketing_signups (email, signup_date) VALUES
('alice@example.com', '2024-07-15'),
('dave@example.com', '2024-08-02'); -- never orderedNow we want:
- People who ordered, even if they never signed up.
- People who signed up, even if they never ordered.
SELECT
c.email AS customer_email,
m.email AS marketing_email,
c.name,
m.signup_date
FROM customers c
FULL OUTER JOIN marketing_signups m
ON c.email = m.email;Result:
| customer_email | marketing_email | name | signup_date |
|---|---|---|---|
| alice@example.com | alice@example.com | Alice | 2024-07-15 |
| bob@example.com | NULL | Bob | NULL |
| cara@example.com | NULL | Cara | NULL |
| NULL | dave@example.com | NULL | 2024-08-02 |
Uses:
- Comparing two datasets.
- Finding differences between tables.
- Data migration / reconciliation tasks.
FULL OUTER JOIN is less common in backend application code, but very handy for analytics and maintenance scripts.
CROSS JOIN
A CROSS JOIN returns the Cartesian product of the two tables, which means every row from the first table combined with every row from the second.
If table A has $m$ rows and table B has $n$ rows, the result has $m \times n$ rows.
Important rule: CROSS JOIN multiplies row counts. Use it carefully, especially with large tables, to avoid huge result sets.
CROSS JOIN example
Generate all combinations of customers and products, for example to create a price list or recommendation seeds.
SELECT
c.name AS customer_name,
p.name AS product_name
FROM customers c
CROSS JOIN products p
ORDER BY c.name, p.name;Result:
| customer_name | product_name |
|---|---|
| Alice | Keyboard |
| Alice | Monitor |
| Alice | Mouse |
| Bob | Keyboard |
| Bob | Monitor |
| Bob | Mouse |
| Cara | Keyboard |
| Cara | Monitor |
| Cara | Mouse |
CROSS JOIN is rarely used in normal CRUD queries, but it is useful when:
- You need to generate combinations.
- You create test data.
- You do specific analytical tasks.
Note: In some dialects, you can also get the same effect with:
FROM customers c, products p
but this style is discouraged in modern SQL in favor of explicit CROSS JOIN.
JOIN Conditions and ON vs USING
The most common join condition links:
- A primary key in one table.
- A foreign key in another.
General form:
... JOIN table2
ON table1.id = table2.table1_id;Typical PK / FK example
Orders to customers:
SELECT
o.id,
c.name
FROM orders o
JOIN customers c
ON o.customer_id = c.id;Multiple conditions
You can have multiple conditions:
SELECT
...
FROM table1 t1
JOIN table2 t2
ON t1.a = t2.a
AND t1.b = t2.b;USING clause
Some databases (such as PostgreSQL) support USING when the column names are the same in both tables:
SELECT
...
FROM table1
JOIN table2 USING (id);This is equivalent to:
... JOIN table2
ON table1.id = table2.id;
And the column id appears only once in the result.
For beginners, using ON explicitly is clearer, because it shows exactly which columns you match.
Self JOIN
A self join is a join of a table with itself.
Use it when:
- Rows in a table reference other rows in the same table.
- You want to compare rows within the same table.
Example: employees and managers
Consider:
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
manager_id INTEGER REFERENCES employees(id)
);
INSERT INTO employees (id, name, manager_id) VALUES
(1, 'CEO', NULL),
(2, 'Alice', 1),
(3, 'Bob', 1),
(4, 'Cara', 2);We want each employee with their manager name:
SELECT
e.name AS employee,
m.name AS manager
FROM employees e
LEFT JOIN employees m
ON e.manager_id = m.id
ORDER BY e.id;Result:
| employee | manager |
|---|---|
| CEO | NULL |
| Alice | CEO |
| Bob | CEO |
| Cara | Alice |
The aliases e and m are essential, since both references point to the same table.
Self joins will appear when you model:
- Organization structures.
- Hierarchies.
- Parent / child relationships in one table.
Joining More Than Two Tables
In real backend applications, queries often join several tables at once.
You can chain multiple JOINs:
SELECT
c.name AS customer_name,
o.id AS order_id,
o.order_date,
SUM(oi.quantity) AS total_items
FROM customers c
JOIN orders o
ON c.id = o.customer_id
JOIN order_items oi
ON o.id = oi.order_id
GROUP BY
c.name, o.id, o.order_date
ORDER BY
c.name, o.order_date;Result:
| customer_name | order_id | order_date | total_items |
|---|---|---|---|
| Alice | 1 | 2024-08-01 | 3 |
| Alice | 2 | 2024-08-05 | 1 |
| Bob | 3 | 2024-08-03 | 1 |
You can mix join types:
SELECT
c.name,
o.id AS order_id,
SUM(oi.quantity) AS items
FROM customers c
LEFT JOIN orders o
ON c.id = o.customer_id
LEFT JOIN order_items oi
ON o.id = oi.order_id
GROUP BY c.name, o.id
ORDER BY c.name, o.id;This keeps customers even if they have no orders or items.
Practical JOIN Patterns for Backends
Here are some very common patterns you will use when writing backend code.
1. Loading related entity details
You need order details and customer info in a single API response:
SELECT
o.id,
o.order_date,
o.total,
c.id AS customer_id,
c.name AS customer_name
FROM orders o
JOIN customers c
ON o.customer_id = c.id
WHERE o.id = 1;Your backend then converts this row into a JSON response.
2. Paginated list with search
List orders, filter by customer name, support pagination:
SELECT
o.id,
o.order_date,
o.total,
c.name AS customer_name
FROM orders o
JOIN customers c
ON o.customer_id = c.id
WHERE c.name ILIKE '%ali%' -- search
ORDER BY o.order_date DESC
LIMIT 10 OFFSET 0; -- pagination3. Checking ownership
For authorization, you confirm that a resource belongs to a user:
SELECT 1
FROM orders o
JOIN customers c
ON o.customer_id = c.id
WHERE o.id = $1
AND c.id = $2;If this returns a row, the order belongs to the customer.
4. Aggregations with JOINs
Total spend per customer:
SELECT
c.id,
c.name,
COALESCE(SUM(o.total), 0) AS total_spent
FROM customers c
LEFT JOIN orders o
ON c.id = o.customer_id
GROUP BY c.id, c.name
ORDER BY total_spent DESC;
COALESCE replaces NULL with 0 for customers without orders.
Summary
- INNER JOIN: keep only matching rows from both tables.
- LEFT JOIN: keep all rows from the left table, fill missing right rows with NULL.
- RIGHT JOIN: mirror of LEFT JOIN, rarely needed if you reorder tables.
- FULL OUTER JOIN: keep all rows from both tables, match where possible, fill with NULL otherwise.
- CROSS JOIN: all combinations of rows from both tables, use with care.
- Join conditions usually connect primary keys to foreign keys with
ON. - LEFT JOIN with
WHERE right.column IS NULLis a common way to find "no related record" cases. - Self joins let you connect a table to itself for hierarchies and comparisons.
- Multiple JOINs are normal in real backend queries.
Understanding JOINs is essential for building any non-trivial backend that uses SQL databases.
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!