9.7. One-to-One Relationships
Table of Contents
Understanding One-to-One Relationships
One-to-one relationships are a specific way to connect data between two tables in a relational database. In this chapter, you will learn what they are, why they are useful, and how to design and query them with clear examples.
What Is a One-to-One Relationship?
A one-to-one relationship connects two tables so that each row in the first table is related to at most one row in the second table, and each row in the second table is related to at most one row in the first.
You can think of it as "exactly one or zero related row on each side".
Examples from real applications:
| Table A | Table B | Relationship idea |
|---|---|---|
users | user_profiles | Each user has at most one profile |
persons | passports | Each person has at most one passport |
employees | employee_salaries | Each employee has at most one salary row |
customers | customer_settings | Each customer has at most one settings row |
If a one-to-one relationship is mandatory, then each row in table A must have exactly one row in table B, and vice versa. If it is optional, then some rows in table A might not have a related row in table B.
Core definition
In a one-to-one relationship, if row $a$ from table A is related to row $b$ from table B, then:
- $a$ is not related to any other row from B, and
- $b$ is not related to any other row from A.
When Should You Use a One-to-One Relationship?
One-to-one relationships are less common than one-to-many, but they are very useful in some situations.
Separating Optional or Rare Data
Sometimes, most rows do not need certain columns. You can move these columns into a separate table.
Example:
- Table
userscontains basic info:id,email,password_hash. - Only a small percentage of users fill out detailed profile information like
bio,date_of_birth,avatar_url.
Instead of having many NULL columns in users, you can:
- Keep
usersfor core information. - Create
user_profilesfor extra information, in a one-to-one relationship.
This makes reads and writes on the users table smaller and can be better for performance.
Separating Sensitive Information
You might want to separate sensitive or restricted data from general data.
Example:
employeestable: public or commonly used data likeid,name,department_id.employee_private_infotable:ssn,tax_id,medical_info.
You can tighten permissions on employee_private_info so only some parts of your application or some database users can read it.
Splitting Very Large Tables
If one table is growing "wide" with many columns, some of which are rarely used, you can split it into two tables connected with a one-to-one relationship.
Example:
orderstable: core fields used all the time likeid,user_id,status,total_amount.order_metadatatable: rarely needed extra fields likenotes,internal_comments,tracking_history_json.
This can keep the main table smaller and faster to query.
Design Options for One-to-One Relationships
There are two main patterns to model a one-to-one relationship:
- Shared primary key pattern.
- Unique foreign key pattern.
You should understand both and know when to use each.
Pattern 1: Shared Primary Key
In the shared primary key pattern, the second table uses the same value as the primary key of the first table.
Example: users and user_profiles.
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL
);
CREATE TABLE user_profiles (
user_id INTEGER PRIMARY KEY REFERENCES users(id),
full_name TEXT,
bio TEXT,
date_of_birth DATE
);Here:
users.idis the primary key ofusers.user_profiles.user_idis:- a primary key of
user_profiles, - a foreign key that references
users(id).
Since user_id is primary key in user_profiles, there can be at most one profile row for each user.
This pattern is very strict. It makes the relationship very clear:
- One profile belongs to exactly one user.
- A profile cannot exist without a user.
You can insert a user first, then optionally create a profile later.
Key points:
| Feature | Description |
|---|---|
| Identity | Profile uses the same ID as the user |
| Enforces max one profile per user | Yes, by primary key |
| Can a profile exist without a user? | No, foreign key prevents it |
| Typical use | Strong ownership, same lifecycle as parent |
Pattern 2: Unique Foreign Key
In the unique foreign key pattern, the second table has its own primary key, but also has a foreign key that is marked as UNIQUE.
Example:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL
);
CREATE TABLE user_profiles (
id SERIAL PRIMARY KEY,
user_id INTEGER UNIQUE REFERENCES users(id),
full_name TEXT,
bio TEXT,
date_of_birth DATE
);Here:
user_profiles.idis the primary key ofuser_profiles.user_profiles.user_idis:- a foreign key pointing to
users.id, - declared as
UNIQUE.
The UNIQUE constraint on user_id ensures that one user can have at most one profile row.
This pattern allows the child table to have its own identity (its own id). It can be useful if:
- The profile table may be referenced by other tables.
- You want a separate
idthat is not tied directly to the parent table.
Key points:
| Feature | Description |
|---|---|
| Identity | Child table has its own primary key |
| Enforces max one profile per user | Yes, due to UNIQUE (user_id) |
| Can a profile exist without a user? | No, foreign key prevents it |
| Typical use | Slightly more flexible, extra relationships |
Important rule
To enforce a one-to-one relationship:
- Either make the foreign key column a
PRIMARY KEYin the child table, - Or add a
UNIQUEconstraint on the foreign key column in the child table.
If you forget theUNIQUEorPRIMARY KEYconstraint, the relationship becomes one-to-many.
Choosing the Parent and Child Table
In a one-to-one relationship, you still think in terms of a parent and a child.
Usually:
- The parent table represents the main entity.
Example:users,employees,persons. - The child table contains additional data about that entity.
Example:user_profiles,employee_private_info.
Typical rules:
- The parent is created first.
- The child row can be created later, updated independently, or sometimes deleted independently.
- The child row references the parent with a foreign key.
You choose which table is the parent based on the meaning in your application, not just on the database structure.
Examples of One-to-One Relationship Designs
Example 1: User and User Profile
This is a common design in web applications.
Shared primary key version:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL
);
CREATE TABLE user_profiles (
user_id INTEGER PRIMARY KEY REFERENCES users(id),
full_name TEXT,
bio TEXT,
avatar_url TEXT
);Usage:
- Create a user:
INSERT INTO users (email, password_hash)
VALUES ('alice@example.com', 'hash123')
RETURNING id;
Assume this returns id = 1.
- Later, create a profile for that user:
INSERT INTO user_profiles (user_id, full_name, bio, avatar_url)
VALUES (1, 'Alice Doe', 'Loves cats and coding', 'https://example.com/avatar1.png');
There can never be a second row in user_profiles with user_id = 1, because user_id is a primary key.
Example 2: Person and Passport
A real world example for strong one-to-one.
CREATE TABLE persons (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);
CREATE TABLE passports (
person_id INTEGER PRIMARY KEY REFERENCES persons(id),
passport_number TEXT NOT NULL UNIQUE,
country_code CHAR(2) NOT NULL
);Here:
- Each
passports.person_idis both a primary key and a foreign key. - Each person can have at most one passport row in this table.
Enforcing Optional vs Mandatory One-to-One
A one-to-one relationship can be:
- Optional: The child row does not have to exist.
- Mandatory: The child row must exist.
Optional One-to-One
This is the default in most designs. The foreign key in the child table can be NULL or missing row.
Example:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE
);
CREATE TABLE user_profiles (
user_id INTEGER PRIMARY KEY REFERENCES users(id),
full_name TEXT
-- no NOT NULL here makes the relationship optional in practice
);
Actually, the relationship is optional because you do not need to create a row in user_profiles at all. A user without a profile simply has no row in user_profiles.
Mandatory One-to-One
If you want to guarantee that every parent has a child row, the database cannot directly enforce this in a simple way across two tables. The foreign key ensures the child references a valid parent, but it does not ensure that each parent has a child.
Common approaches:
- Use shared primary key and always create both rows at the same time inside a transaction.
- Use a database constraint such as a trigger to check that every parent has a child.
- In many real systems, this rule is enforced at the application level, not by the database.
For beginners, it is usually enough to:
- Understand that the database naturally supports "optional" one-to-one.
- Recognize that "mandatory" one-to-one needs extra work, usually in the application code.
Querying One-to-One Relationships
A one-to-one relationship is queried with JOINs, similar to one-to-many relationships, but you expect at most one row on each side.
Basic JOIN
Example with users and user_profiles:
SELECT
u.id,
u.email,
p.full_name,
p.bio
FROM users AS u
LEFT JOIN user_profiles AS p
ON p.user_id = u.id
WHERE u.id = 1;Explanation:
LEFT JOINreturns the user even if there is no profile.p.full_nameandp.biowill beNULLif the user has no profile.
If you only want users that have a profile, you can use INNER JOIN:
SELECT
u.id,
u.email,
p.full_name
FROM users AS u
INNER JOIN user_profiles AS p
ON p.user_id = u.id;Checking Whether the Child Exists
You can check whether each user has a profile:
SELECT
u.id,
u.email,
(p.user_id IS NOT NULL) AS has_profile
FROM users AS u
LEFT JOIN user_profiles AS p
ON p.user_id = u.id;Example result:
| id | has_profile | |
|---|---|---|
| 1 | alice@example.com | true |
| 2 | bob@example.com | false |
| 3 | carol@example.com | true |
Inserting, Updating, and Deleting in One-to-One
Inserting Parent and Child
- Insert parent, get its ID.
- Insert child using that ID as the foreign key.
Example:
-- Insert parent
INSERT INTO users (email, password_hash)
VALUES ('bob@example.com', 'hash456')
RETURNING id;
Assume the returned id is 2.
-- Insert child
INSERT INTO user_profiles (user_id, full_name)
VALUES (2, 'Bob Smith');Updating the Child
Updating the child is like updating any other table.
UPDATE user_profiles
SET bio = 'Backend developer and musician'
WHERE user_id = 2;Deleting Parent or Child
Deleting the child is simple:
DELETE FROM user_profiles
WHERE user_id = 2;Deleting the parent can cause referential integrity problems if the child still exists. The foreign key constraint controls what happens.
Common options:
ON DELETE RESTRICT(default in many databases): block deletion if child exists.ON DELETE CASCADE: automatically delete the child when the parent is deleted.ON DELETE SET NULL: set the foreign key column toNULLin the child when the parent is deleted, which is not possible if the column is also a primary key.
Example with cascading delete:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE
);
CREATE TABLE user_profiles (
user_id INTEGER PRIMARY KEY
REFERENCES users(id) ON DELETE CASCADE,
full_name TEXT
);Now:
DELETE FROM users WHERE id = 1;
This will automatically delete the user_profiles row where user_id = 1 if it exists.
Foreign key delete rule
If you delete a parent row that has a child row and there is no ON DELETE rule, the database will reject the delete to protect data integrity.
Common safe choice: ON DELETE CASCADE when the child data belongs strictly to the parent.
One-to-One vs One-to-Many: Design Considerations
Sometimes a relationship that looks one-to-one can become one-to-many in the future. It is important to think about this when designing your schema.
Example: Employee and Address
You might first think:
- Each employee has one address.
So you design:
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);
CREATE TABLE employee_addresses (
employee_id INTEGER PRIMARY KEY REFERENCES employees(id),
address_line TEXT NOT NULL,
city TEXT NOT NULL,
country TEXT NOT NULL
);Later, the business rules change:
- Employees can have multiple addresses, for example, home and office.
Now your one-to-one is no longer correct. You need a one-to-many relationship.
New design:
CREATE TABLE employee_addresses (
id SERIAL PRIMARY KEY,
employee_id INTEGER NOT NULL REFERENCES employees(id),
address_type TEXT NOT NULL,
address_line TEXT NOT NULL,
city TEXT NOT NULL,
country TEXT NOT NULL
);
There is no UNIQUE on employee_id, so each employee can have multiple rows in employee_addresses.
Lesson:
- Be careful when you think a relationship is one-to-one. Ask whether it might become one-to-many later.
- If you are not sure, it may be safer to design a one-to-many relationship. You can still treat it as one-to-one on the application side for now.
Performance Notes
One-to-one relationships have some performance characteristics you should know.
Table Width and Query Speed
Splitting frequently used and rarely used columns into separate tables can:
- Make the main table smaller,
- Make index pages smaller,
- Improve cache hit rates in the database,
- Potentially improve query speed for common queries that need only the main table.
However, this benefit comes at the cost of extra JOINs when you do need the extra data.
Indexes
The primary key and unique constraints used in one-to-one designs automatically create indexes, which are helpful for lookups.
Typical useful indexes:
- On the child table, the foreign key column is already indexed because it is either
PRIMARY KEYorUNIQUE. - On the parent table, the primary key index is used when joining.
You usually do not need extra indexes just to support a one-to-one relationship.
Summary
In this chapter, you learned:
- What a one-to-one relationship is, and how it differs from one-to-many.
- When it makes sense to use one-to-one, for example to separate optional, sensitive, or rarely used data.
- Two main design patterns:
- Shared primary key in the child table.
- Unique foreign key in the child table.
- How to query one-to-one relationships using
JOIN. - How to insert, update, and delete data in a one-to-one relationship.
- Design considerations when a relationship might change to one-to-many.
- Basic performance considerations related to table width and indexes.
Understanding one-to-one relationships helps you design cleaner schemas and decide when to split data across multiple tables in your backend applications.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!