9.8. One-to-Many Relationships
Table of Contents
Understanding One-to-Many Relationships
One-to-many relationships are at the core of relational database design. You will use them in almost every real application, from blogs and shops to authentication systems.
In this chapter we focus on what makes one-to-many relationships unique, how to recognize them, and how to implement them in SQL, especially in PostgreSQL.
What Is a One-to-Many Relationship?
A one-to-many relationship exists when:
- One record in table A can be associated with many records in table B.
- Each record in table B is associated with exactly one record in table A.
You can think of it as:
- One author has many books.
- One user has many orders.
- One category has many products.
- One blog post has many comments.
We usually describe this as:
A (one) → B (many)
Conceptual Example
Imagine a simple blogging system:
- One user can write many posts.
- Each post is written by exactly one user.
Tables conceptually:
users(one side)posts(many side)
Relationship:
- User 1 → Post 1, Post 2, Post 3
- User 2 → Post 4
Every post belongs to a single user, but each user can have multiple posts.
Identifying One-to-Many in Real Projects
When you design a database, you first think about entities and their relationships.
You usually have a one-to-many relationship when:
- You can complete the sentence:
“One X has many Y”
and also
“Each Y belongs to exactly one X.”
Some common patterns:
| Domain | One side | Many side | Sentence |
|---|---|---|---|
| E-commerce | users | orders | One user has many orders |
| E-commerce | orders | order_items | One order has many order items |
| Blogging | posts | comments | One post has many comments |
| Education | courses | lessons | One course has many lessons |
| Company | departments | employees | One department has many employees |
| Social network | users | posts | One user has many posts |
If, instead, you can say “many X can belong to many Y,” that is a many-to-many relationship, which is handled differently and is covered in its own chapter.
How One-to-Many Is Implemented in SQL
Technically, a one-to-many relationship is implemented using a foreign key on the many side of the relationship.
Rule:
In a one-to-many relationship, the table on the many side contains a foreign key column that references the primary key of the table on the one side.
So for:
- One
userhas manyposts
We create:
userswith a primary keyidpostswith a foreign keyuser_idthat referencesusers(id)
Basic structure:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);
CREATE TABLE posts (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
title TEXT NOT NULL,
content TEXT NOT NULL
);Here:
users.idis the primary key on the one side.posts.user_idis the foreign key on the many side.
One-to-Many: Parent and Child Tables
In a one-to-many relationship we often say:
- Parent table for the one side.
- Child table for the many side.
Typical structure:
| Role | Table | Key column | Description |
|---|---|---|---|
| Parent | users | id | One user row |
| Child | posts | user_id FK | Many posts, each linked to one user |
You can read it like this:
- A parent row in
userscan be linked to 0, 1, or many child rows inposts. - A child row in
postsmust be linked to exactly one parent row inusers(ifuser_idis NOT NULL).
Creating One-to-Many Relationships in SQL
Let us walk through a few examples in SQL to make this concrete.
Example 1: Users and Orders
Business rule
- One user can place many orders.
- Each order belongs to exactly one user.
Table design
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
full_name TEXT NOT NULL
);
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
total_cents INTEGER NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);Explanation:
users.idis the primary key.orders.user_idis a foreign key that points tousers.id.- The one-to-many relationship is enforced by the database through this foreign key.
Inserting Related Data
-- Insert two users (parents)
INSERT INTO users (email, full_name)
VALUES
('alice@example.com', 'Alice'),
('bob@example.com', 'Bob');
-- Insert orders for Alice (id = 1)
INSERT INTO orders (user_id, total_cents)
VALUES
(1, 1500),
(1, 3200);
-- Insert one order for Bob (id = 2)
INSERT INTO orders (user_id, total_cents)
VALUES
(2, 5000);Here:
- User 1 (Alice) has 2 orders.
- User 2 (Bob) has 1 order.
Query: Get All Orders for a User
SELECT *
FROM orders
WHERE user_id = 1;
This returns all orders for user with id = 1.
Query: Join Parent and Children
SELECT
u.full_name,
o.id AS order_id,
o.total_cents,
o.created_at
FROM users u
JOIN orders o ON o.user_id = u.id
WHERE u.id = 1;
This joins users (one side) with orders (many side) using the foreign key.
Cardinality and Optional Relationships
You can constrain one-to-many in different ways, for example:
- Mandatory child reference
A child must have a parent. - Optional child reference
A child may or may not have a parent.
This is controlled by whether the foreign key column can be NULL.
Mandatory Relationship (Most Common)
CREATE TABLE posts (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
title TEXT NOT NULL
);
Here, every post must have a user_id. The database will reject a post without a user.
Optional Relationship
Sometimes a relationship is optional. For example, maybe an article can be written by the “system” without a specific author.
CREATE TABLE articles (
id SERIAL PRIMARY KEY,
author_id INTEGER REFERENCES users(id), -- NULL allowed
title TEXT NOT NULL
);
Here, author_id can be NULL. This means:
- An article might not have an associated user.
- When present,
author_idmust be a validusers.id.
One-to-Many and Cascading Behavior
When you have one-to-many relationships, you must decide what happens when:
- The parent row is deleted.
- The parent key changes.
This is handled by foreign key actions such as ON DELETE and ON UPDATE.
Common ON DELETE Strategies
| Strategy | Behavior when parent is deleted |
|---|---|
ON DELETE RESTRICT | Prevent deletion if child rows exist |
ON DELETE NO ACTION | Similar to RESTRICT in many databases |
ON DELETE CASCADE | Automatically delete child rows |
ON DELETE SET NULL | Set the foreign key in children to NULL |
Rule of thumb:
Use ON DELETE CASCADE only when it is safe to remove all related child rows automatically, for example, for temporary or dependent data. For important business data, prefer RESTRICT or handle deletion manually.
Example: Posts and Comments
- One
posthas manycomments. - When a post is removed, you usually want to remove its comments too.
CREATE TABLE posts (
id SERIAL PRIMARY KEY,
title TEXT NOT NULL
);
CREATE TABLE comments (
id SERIAL PRIMARY KEY,
post_id INTEGER NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
content TEXT NOT NULL
);Now:
DELETE FROM posts WHERE id = 10;This will:
- Delete post 10.
- Automatically delete all comments whose
post_id = 10.
Example: Departments and Employees
- One department has many employees.
- You usually do not want to delete employees automatically if a department is removed, or you may even want to prevent deleting a department that still has employees.
CREATE TABLE departments (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
department_id INTEGER NOT NULL REFERENCES departments(id),
full_name TEXT NOT NULL
);
Here, if you try to delete a department that still has employees, the database will block the operation (default behavior similar to RESTRICT).
You can then:
- Move employees to another department first.
- Or decide to use
ON DELETE SET NULLif it is acceptable that employees temporarily have no department.
Practical Modeling Patterns
Let us look at some typical one-to-many designs you will meet as a backend developer.
Blog: Posts and Comments
Business rule
- A post can have many comments.
- Each comment belongs to exactly one post.
Tables
CREATE TABLE posts (
id SERIAL PRIMARY KEY,
title TEXT NOT NULL,
body TEXT NOT NULL
);
CREATE TABLE comments (
id SERIAL PRIMARY KEY,
post_id INTEGER NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
author_name TEXT NOT NULL,
content TEXT NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);Queries
Get all comments for a post:
SELECT *
FROM comments
WHERE post_id = 5
ORDER BY created_at;Get posts with their comment count:
SELECT
p.id,
p.title,
COUNT(c.id) AS comment_count
FROM posts p
LEFT JOIN comments c ON c.post_id = p.id
GROUP BY p.id, p.title
ORDER BY comment_count DESC;
Here, we are using GROUP BY and COUNT on the many side, which is a common pattern with one-to-many relationships.
E-commerce: Orders and Order Items
Business rule
- One order can have many order items.
- Each order item belongs to exactly one order.
Tables
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TABLE order_items (
id SERIAL PRIMARY KEY,
order_id INTEGER NOT NULL REFERENCES orders(id) ON DELETE CASCADE,
product_id INTEGER NOT NULL REFERENCES products(id),
quantity INTEGER NOT NULL,
unit_price_cents INTEGER NOT NULL
);Query: Get an Order with Its Items
SELECT
o.id AS order_id,
o.created_at,
oi.product_id,
oi.quantity,
oi.unit_price_cents
FROM orders o
JOIN order_items oi ON oi.order_id = o.id
WHERE o.id = 42;Query: Calculate Order Total
SELECT
o.id AS order_id,
SUM(oi.quantity * oi.unit_price_cents) AS total_cents
FROM orders o
JOIN order_items oi ON oi.order_id = o.id
WHERE o.id = 42
GROUP BY o.id;Again, you see the pattern:
- Join parent (one) with children (many).
- Group by the parent to summarize children.
Avoiding Common Mistakes
Mistake 1: Storing Lists in One Column
Sometimes beginners try to store multiple values in one column, for example:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL,
order_ids TEXT -- "1,2,3" or JSON
);This is not correct for a relational database, because:
- It is hard to query, filter, and enforce integrity.
- The database cannot check if those IDs actually exist in
orders.
Use a proper one-to-many relationship instead:
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id)
);Mistake 2: Putting the Foreign Key on the Wrong Side
For a one-to-many relationship:
- The foreign key must be on the many side.
Wrong:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
last_order_id INTEGER REFERENCES orders(id) -- this does not model one-to-many
);Right:
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id)
);
You might still have last_order_id as a derived convenience column, but it is not what defines the relationship.
Mistake 3: Forgetting Indexes on Foreign Keys
Foreign key columns are used often in queries and joins. Without an index, those queries can become slow as data grows.
In most databases:
- You should create an index on foreign key columns.
Example:
CREATE INDEX idx_orders_user_id ON orders(user_id);Some databases create indexes automatically for foreign keys, but not all. PostgreSQL does not create an index for foreign keys automatically, so you should do it explicitly for performance.
One-to-Many in Application Code
Although implementation details depend on the programming language and ORM, the underlying concept is always:
- A child object has a foreign key field pointing to the parent.
- The parent object can expose a collection of children.
Pseudo Python with an ORM-like syntax:
class User(Base):
id = Column(Integer, primary_key=True)
email = Column(String, unique=True)
class Post(Base):
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("users.id"))
title = Column(String)Conceptually:
Post.user_idis the foreign key.- A
Userobject can fetchpoststhrough that key.
Although ORMs make it more convenient, the database structure is still the same one-to-many pattern you learned here.
Summary
In this chapter you learned that:
- A one-to-many relationship links one parent row to many child rows.
- It is implemented by placing a foreign key in the many side table that references the primary key of the one side.
- Cardinality and optionality are controlled by
NOT NULLand foreign key actions likeON DELETE CASCADE. - You use one-to-many relationships for common patterns such as users and posts, orders and order items, departments and employees.
- Proper design avoids storing lists in a single column and ensures foreign keys are indexed.
You will use one-to-many relationships constantly when designing schemas and building backends, and they form the basis for more advanced relationship types you will see next.
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!