9.9. Many-to-Many Relationships
Table of Contents
Understanding Many-to-Many Relationships
Many-to-many relationships appear often in real applications. They describe situations where:
- One record can be related to many other records, and
- Each of those records can also be related to many records on the other side.
You already saw one-to-one and one-to-many. Many-to-many builds on top of them, so here we focus on what is special about many-to-many.
Typical examples:
- Students and Courses
- A student can enroll in many courses.
- A course has many students.
- Users and Roles
- A user can have many roles.
- A role can belong to many users.
- Products and Categories
- A product can belong to many categories.
- A category can contain many products.
- Authors and Books
- A book can have multiple authors.
- An author can write multiple books.
Relational databases cannot represent many-to-many with just two tables. You need a third table, the join table (also called a junction table or link table).
Key rule:
Relational databases implement a many-to-many relationship using two one-to-many relationships with an intermediate join table.
The Join Table Concept
A join table is a separate table that holds pairs of foreign keys. Each row connects one record from table A with one record from table B.
General pattern:
- Table A, for example
students - Table B, for example
courses - Join table, for example
student_coursesorenrollments
Basic structure of a join table:
- A foreign key to table A
- A foreign key to table B
- Usually a composite primary key on (A_id, B_id)
- Sometimes extra columns that describe the relationship itself, like
enrolled_at,role,grade,status
Example structure:
| Table | Columns |
|---|---|
| students | id (PK), name, email |
| courses | id (PK), title, description |
| student_courses | student_id (FK → students.id), course_id (FK → courses.id), enrolled_at |
Here student_courses does not represent a real-world object like "a separate entity" by itself. It represents the fact that a student takes a course.
Implementing Many-to-Many: Student and Course
Let us walk through an example from scratch.
Step 1: Main tables
CREATE TABLE students (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);
CREATE TABLE courses (
id SERIAL PRIMARY KEY,
title TEXT NOT NULL
);So far this is just two independent tables.
Step 2: Join table
CREATE TABLE student_courses (
student_id INTEGER NOT NULL,
course_id INTEGER NOT NULL,
enrolled_at TIMESTAMP NOT NULL DEFAULT NOW(),
PRIMARY KEY (student_id, course_id),
FOREIGN KEY (student_id) REFERENCES students (id),
FOREIGN KEY (course_id) REFERENCES courses (id)
);Important design decisions here:
student_idandcourse_idare bothNOT NULL, since a link without one side does not make sense.PRIMARY KEY (student_id, course_id)makes the pair unique. The same student cannot be enrolled in the same course twice.- Each foreign key ensures data consistency:
- A row in
student_coursesmust reference a real student. - It must also reference a real course.
Important design rule:
In many-to-many join tables, you usually create a composite primary key from the two foreign keys, for example (student_id, course_id), to prevent duplicate links.
Inserting Data into a Many-to-Many Relationship
You always insert into the main tables first, then insert the links in the join table.
1. Insert records into main tables
INSERT INTO students (name) VALUES
('Alice'),
('Bob'),
('Charlie');
INSERT INTO courses (title) VALUES
('Math 101'),
('History 201'),
('Programming 101');Assume the database assigns IDs:
students:
| id | name |
|---|---|
| 1 | Alice |
| 2 | Bob |
| 3 | Charlie |
courses:
| id | title |
|---|---|
| 1 | Math 101 |
| 2 | History 201 |
| 3 | Programming 101 |
2. Link students to courses
Example rules:
- Alice takes Math 101 and Programming 101
- Bob takes History 201 only
- Charlie takes Math 101 and History 201
INSERT INTO student_courses (student_id, course_id) VALUES
(1, 1), -- Alice - Math 101
(1, 3), -- Alice - Programming 101
(2, 2), -- Bob - History 201
(3, 1), -- Charlie - Math 101
(3, 2); -- Charlie - History 201
Now the student_courses table:
| student_id | course_id |
|---|---|
| 1 | 1 |
| 1 | 3 |
| 2 | 2 |
| 3 | 1 |
| 3 | 2 |
The many-to-many relationship is completely represented by this table.
Querying Many-to-Many Data
You use JOINs to read data across a many-to-many relationship. The join table sits in the middle.
Find courses that a specific student is taking
Goal: Get all course titles for Alice (id = 1).
SELECT c.id, c.title
FROM courses AS c
JOIN student_courses AS sc
ON c.id = sc.course_id
WHERE sc.student_id = 1;Result:
| id | title |
|---|---|
| 1 | Math 101 |
| 3 | Programming 101 |
Explanation:
- Start from
courses c. - Join
student_courses scwherec.id = sc.course_id, so each course is matched to its enrollment links. - Limit to
sc.student_id = 1, which is Alice.
You can also start from the other direction.
Find students enrolled in a specific course
Goal: Get all students in Math 101 (course id = 1).
SELECT s.id, s.name
FROM students AS s
JOIN student_courses AS sc
ON s.id = sc.student_id
WHERE sc.course_id = 1;Result:
| id | name |
|---|---|
| 1 | Alice |
| 3 | Charlie |
Show all students with their courses
You can join both sides and select both columns.
SELECT s.name AS student_name, c.title AS course_title
FROM students AS s
JOIN student_courses AS sc
ON s.id = sc.student_id
JOIN courses AS c
ON c.id = sc.course_id
ORDER BY s.name, c.title;Result:
| student_name | course_title |
|---|---|
| Alice | Math 101 |
| Alice | Programming 101 |
| Bob | History 201 |
| Charlie | History 201 |
| Charlie | Math 101 |
This is a very common pattern: main table A → join table → main table B.
Deleting and Updating in Many-to-Many
When you delete or change records in one table, you must consider the join table.
Removing a single link
To remove only the link between Alice and Math 101:
DELETE FROM student_courses
WHERE student_id = 1 AND course_id = 1;Alice still exists. Math 101 still exists. Only that relationship is removed.
Deleting a main record
If you try to delete a student who still has links in student_courses, the database will usually reject it unless you configured cascading.
Example:
DELETE FROM students WHERE id = 1;
If student_courses.student_id has a regular foreign key, you will get a foreign key violation error, because there are rows in student_courses that reference Alice.
Two options:
- Delete the links first:
DELETE FROM student_courses WHERE student_id = 1;
DELETE FROM students WHERE id = 1;- Use
ON DELETE CASCADEon the foreign key when you create the join table:
CREATE TABLE student_courses (
student_id INTEGER NOT NULL,
course_id INTEGER NOT NULL,
PRIMARY KEY (student_id, course_id),
FOREIGN KEY (student_id) REFERENCES students (id) ON DELETE CASCADE,
FOREIGN KEY (course_id) REFERENCES courses (id) ON DELETE CASCADE
);
With ON DELETE CASCADE, when you delete a student, the database automatically deletes the related rows in student_courses.
Cascade rule:
If you use ON DELETE CASCADE on join table foreign keys, deleting a row in a main table will automatically remove all its links in the join table.
Join Table With Extra Attributes
Sometimes the relationship itself has data. For example, for student_courses you may want:
- The date when the student enrolled
- The final grade
- Whether the student is currently active in the course
In this case, the join table is not just a technical detail. It represents a real domain entity, for example "Enrollment".
Example: Enrollment with extra columns
CREATE TABLE enrollments (
id SERIAL PRIMARY KEY,
student_id INTEGER NOT NULL,
course_id INTEGER NOT NULL,
enrolled_at TIMESTAMP NOT NULL DEFAULT NOW(),
grade NUMERIC(3,1), -- for example 0.0 to 10.0
status TEXT NOT NULL DEFAULT 'active',
UNIQUE (student_id, course_id),
FOREIGN KEY (student_id) REFERENCES students (id),
FOREIGN KEY (course_id) REFERENCES courses (id)
);Changes compared to the simple join table:
- We have an auto-increment primary key
id. (student_id, course_id)is nowUNIQUE, not the primary key.- Extra columns
enrolled_at,grade,status.
The relationship is still many-to-many, but the join table now holds richer information.
Query with extra attributes
Get all students with their courses and grades:
SELECT
s.name AS student_name,
c.title AS course_title,
e.grade,
e.status,
e.enrolled_at
FROM enrollments AS e
JOIN students AS s ON s.id = e.student_id
JOIN courses AS c ON c.id = e.course_id
ORDER BY s.name, c.title;Many-to-Many Between Products and Categories
Another classic example: products and categories.
- A product can be in multiple categories.
- A category includes many products.
Table design
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
price NUMERIC(10,2) NOT NULL
);
CREATE TABLE categories (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL UNIQUE
);
CREATE TABLE product_categories (
product_id INTEGER NOT NULL,
category_id INTEGER NOT NULL,
PRIMARY KEY (product_id, category_id),
FOREIGN KEY (product_id) REFERENCES products (id),
FOREIGN KEY (category_id) REFERENCES categories (id)
);Inserting data
INSERT INTO products (name, price) VALUES
('Laptop', 1200.00),
('Mouse', 20.00),
('Keyboard', 50.00);
INSERT INTO categories (name) VALUES
('Electronics'),
('Computers'),
('Accessories');Assume IDs:
- Products:
| id | name |
|---|---|
| 1 | Laptop |
| 2 | Mouse |
| 3 | Keyboard |
- Categories:
| id | name |
|---|---|
| 1 | Electronics |
| 2 | Computers |
| 3 | Accessories |
Define relationships:
- Laptop in Electronics and Computers
- Mouse in Electronics and Accessories
- Keyboard in Accessories only
INSERT INTO product_categories (product_id, category_id) VALUES
(1, 1), -- Laptop - Electronics
(1, 2), -- Laptop - Computers
(2, 1), -- Mouse - Electronics
(2, 3), -- Mouse - Accessories
(3, 3); -- Keyboard - AccessoriesQuery examples
All categories for a given product (Laptop, id = 1):
SELECT c.name
FROM categories AS c
JOIN product_categories AS pc
ON c.id = pc.category_id
WHERE pc.product_id = 1;All products in a given category (Accessories, id = 3):
SELECT p.name, p.price
FROM products AS p
JOIN product_categories AS pc
ON p.id = pc.product_id
WHERE pc.category_id = 3;Products with their categories:
SELECT
p.name AS product_name,
c.name AS category_name,
p.price
FROM products AS p
JOIN product_categories AS pc
ON p.id = pc.product_id
JOIN categories AS c
ON c.id = pc.category_id
ORDER BY p.name, c.name;Detecting Many-to-Many in Requirements
When you design a database, you can identify many-to-many situations in the requirements text.
Look for sentences that contain:
- "A X can have many Y, and a Y can have many X."
- "Users can be in many groups, and each group has many users."
- "Posts can have many tags, and each tag can belong to many posts."
Some patterns:
| Requirement sentence | Relationship type |
|---|---|
| Each order belongs to exactly one customer. | One-to-many |
| A customer can place many orders. | One-to-many |
| A book has one publisher, a publisher publishes many books. | One-to-many |
| A student can enroll in many courses, each course many students. | Many-to-many |
| A post can have many tags, a tag can be used for many posts. | Many-to-many |
| A user can have many roles, a role can be assigned to many users. | Many-to-many |
Whenever both directions say "many", you normally want a join table.
Common Design Patterns and Pitfalls
Naming conventions
Good practice is to give clear names:
- Join table describing what it connects:
student_coursesproduct_categoriesuser_roles- Sometimes you use a real domain name:
enrollmentsmembershipssubscriptions
Avoid duplicates
Always enforce uniqueness of the pair of foreign keys. This can be done through:
- Composite primary key:
PRIMARY KEY (student_id, course_id)- Or unique constraint:
UNIQUE (student_id, course_id)without a composite primary key, you might accidentally insert the same pair multiple times.
Direct foreign keys between main tables
A common beginner mistake is to try to add an array or a multiple-value column instead of using a join table.
Bad idea examples:
- Adding a
course_idscolumn tostudentswith a comma separated list like"1,3,7". - Adding an
INT[]array of course IDs in students.
Problems with this approach:
- You cannot enforce referential integrity with foreign keys easily.
- Queries become complex and inefficient.
- It breaks normalization principles.
The normalized and correct relational design uses the join table.
Do not store multiple IDs in a single column (like "1,3,7") to model many-to-many. Always use a separate join table.
Many-to-Many versus Two One-to-Many
Internally, a many-to-many is implemented as two one-to-many relationships:
- One student has many
student_courses. - One course has many
student_courses.
You can think of it as:
students1 → manystudent_coursescourses1 → manystudent_courses
Then you use the join table to "cross" from students to courses or from courses to students.
Summary
- Many-to-many relationships connect records so that each side can have multiple related records on the other side.
- Relational databases do not have a direct "many-to-many" feature. You implement it with a join table that holds foreign keys to both sides.
- The join table typically uses a composite primary key
(a_id, b_id)or a unique constraint on that pair. - You always:
- Insert into the main tables first.
- Insert relationships into the join table.
- Query across both sides using JOINs through the join table.
- If the relationship itself has data, you add extra columns to the join table, which often gets its own name like
enrollmentsormemberships. - Never try to model many-to-many by storing lists of IDs in a single column. Use a normalized join table instead.
Understanding many-to-many relationships and join tables is essential for real-world backend applications, because you will use this pattern in almost every nontrivial database design.
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!