9.11. Normalization
Table of Contents
Why Normalization Matters
When you design a relational database, one of your main goals is to avoid data problems such as:
- Duplicate data
- Conflicting or inconsistent values
- Hard to update records
- Unnecessary storage usage
Normalization is a set of rules and techniques that help you design tables that store each piece of data in the right place, in a clean and consistent way.
In this chapter you will:
- Learn what the common normal forms are (1NF, 2NF, 3NF)
- See the typical problems they solve
- Normalize example tables step by step
- Understand when you might not want to normalize completely
You will not learn SQL syntax here, only how to structure tables. SQL is covered elsewhere in the course.
Key idea: Normalization is about structuring tables so that:
- Each fact is stored once
- Data is consistent
- Changes are easy and safe
Types of Anomalies Normalization Solves
Before looking at normal forms, it helps to see the problems that normalization prevents. These are called anomalies.
Insertion Anomalies
An insertion anomaly happens when you cannot insert data because some other data is missing.
Example table: StudentCourse
| student_id | student_name | course_id | course_name |
|---|---|---|---|
| 1 | Alice | 101 | Databases |
| 2 | Bob | 102 | Web Development |
Problem: You want to add a new course that has no students yet.
To insert a new course row, you need to fill student_id and student_name. You might use a fake student id or leave it NULL. Both options are bad.
This is an insertion anomaly. You should be able to insert a course independently of any students.
Update Anomalies
An update anomaly happens when you must update the same piece of information in multiple rows, and you might miss some.
Continue with the same table. Suppose course 101 changes name from "Databases" to "Database Systems".
| student_id | student_name | course_id | course_name |
|---|---|---|---|
| 1 | Alice | 101 | Databases |
| 3 | Carol | 101 | Databases |
You must update course_name to "Database Systems" in all rows that have course_id = 101. If you miss one row, your data becomes inconsistent.
This is an update anomaly.
Deletion Anomalies
A deletion anomaly happens when deleting one fact accidentally removes other important data.
Using the same StudentCourse table, suppose the only student in course 102 is Bob:
| student_id | student_name | course_id | course_name |
|---|---|---|---|
| 2 | Bob | 102 | Web Development |
If Bob leaves the school and you delete his row, you also delete the only record of course 102. Now it looks like the course never existed.
This is a deletion anomaly.
First Normal Form (1NF)
First Normal Form is the most basic level of normalization. Almost all relational databases expect you to be in 1NF.
Definition of 1NF
A table is in First Normal Form (1NF) if:
- Every cell contains a single value, not a list or set.
- Each column contains values of the same type.
- Each row is uniquely identifiable by a primary key.
1NF rule: No repeating groups or arrays inside a single column. One value per cell.
Example of a Table Not in 1NF
Imagine a Customer table:
| customer_id | name | phones |
|---|---|---|
| 1 | Alice | +1-111-1111,+1-2222 |
| 2 | Bob | +1-333-3333 |
Problems:
phonescontains multiple values in a single cell (for Alice).- You cannot easily search for "customers with phone +1-2222" with clean SQL.
- You cannot add another phone number without editing the string.
This violates 1NF.
Converting to 1NF Using a Separate Table
Correct design:
Customer
| customer_id | name |
|---|---|
| 1 | Alice |
| 2 | Bob |
CustomerPhone
| customer_id | phone |
|---|---|
| 1 | +1-111-1111 |
| 1 | +1-2222 |
| 2 | +1-333-3333 |
Now:
- Each cell has a single value.
- You can search, filter, and aggregate phone numbers easily.
- Customers can have any number of phones.
Repeating Groups Example
Another bad 1NF design:
| order_id | customer_id | item1_name | item1_qty | item2_name | item2_qty |
|---|---|---|---|---|---|
| 1 | 10 | Apple | 2 | Banana | 5 |
Issues:
- Columns
item1_name,item2_nameare repeating groups. - What if an order has 3 or 10 items?
Correct 1NF design:
Order
| order_id | customer_id |
|---|---|
| 1 | 10 |
OrderItem
| order_id | item_name | quantity |
|---|---|---|
| 1 | Apple | 2 |
| 1 | Banana | 5 |
Functional Dependencies (Intuition)
To understand higher normal forms, you need the idea of a functional dependency. This sounds abstract, but the idea is simple.
A functional dependency written as:
$$ A \rightarrow B $$
means: if you know A, you can uniquely determine B.
For example, in a Student table:
student_id -> student_name
Once you know the student id, you know the student name.
In a Product table:
product_id -> price
Once you know the product id, you know the price.
In a CourseEnrollment table:
| student_id | course_id | grade |
|---|
The pair (student_id, course_id) might uniquely determine grade.
(student_id, course_id) -> grade
This pair can be the primary key. A primary key always functionally determines all other columns in its table.
You do not need to master the theory here. You only need to recognize when:
- A non key column depends on part of a primary key
- A non key column depends on another non key column
This is what 2NF and 3NF care about.
Second Normal Form (2NF)
2NF builds on 1NF. It only matters when your primary key is composite, meaning it uses multiple columns together as the key.
Definition of 2NF
A table is in Second Normal Form (2NF) if:
- It is already in 1NF.
- Every non key column depends on the whole primary key, not just part of it.
If a non key column depends only on part of a composite key, that column is in the wrong table.
2NF rule: No partial dependencies.
No non key column should depend on just a part of a composite primary key.
Example of a Table Not in 2NF
Consider this Enrollment table:
| student_id | course_id | student_name | course_name | grade |
|---|---|---|---|---|
| 1 | 101 | Alice | Databases | A |
| 2 | 101 | Bob | Databases | B |
| 1 | 102 | Alice | Web Dev | A- |
Primary key: (student_id, course_id)
Non key columns: student_name, course_name, grade
Look at the dependencies:
(student_id, course_id) -> grade
Grade depends on both student and course. Good.student_id -> student_name
Student name depends only onstudent_id, not on the course. Problem.course_id -> course_name
Course name depends only oncourse_id, not on the student. Problem.
So student_name and course_name depend only on part of the composite key, which violates 2NF.
This leads to:
- Duplicated student names in many rows
- Duplicated course names in many rows
- Update anomalies if a name changes
Converting to 2NF
Split the table into three:
Student
| student_id | student_name |
|---|---|
| 1 | Alice |
| 2 | Bob |
Course
| course_id | course_name |
|---|---|
| 101 | Databases |
| 102 | Web Dev |
Enrollment
| student_id | course_id | grade |
|---|---|---|
| 1 | 101 | A |
| 2 | 101 | B |
| 1 | 102 | A- |
Now all non key columns in each table depend on the whole primary key of that table:
- In
Student, primary key isstudent_idandstudent_namedepends on it. - In
Course, primary key iscourse_idandcourse_namedepends on it. - In
Enrollment, key is(student_id, course_id)andgradedepends on both.
Third Normal Form (3NF)
3NF builds on 2NF and focuses on removing indirect dependencies.
Definition of 3NF
A table is in Third Normal Form (3NF) if:
- It is in 2NF.
- Every non key column depends directly on the primary key, not on another non key column.
If a non key column depends on another non key column, you have a transitive dependency, which 3NF forbids.
3NF rule: No transitive dependencies.
Non key columns must depend only on the primary key, not on other non key columns.
Example of a Table Not in 3NF
Consider an Employee table:
| employee_id | employee_name | department_id | department_name |
|---|---|---|---|
| 1 | Alice | 10 | Sales |
| 2 | Bob | 20 | IT |
| 3 | Carol | 10 | Sales |
Primary key: employee_id
Non key columns: employee_name, department_id, department_name
Dependencies:
employee_id -> employee_nameemployee_id -> department_iddepartment_id -> department_name
Here, department_name does not depend directly on employee_id.
Instead, you have an indirect chain:
$$ employee\_id \rightarrow department\_id \rightarrow department\_name $$
This is a transitive dependency. It causes:
- Duplicate department names
- Update anomalies if department names change
Converting to 3NF
Split the table:
Employee
| employee_id | employee_name | department_id |
|---|---|---|
| 1 | Alice | 10 |
| 2 | Bob | 20 |
| 3 | Carol | 10 |
Department
| department_id | department_name |
|---|---|
| 10 | Sales |
| 20 | IT |
Now:
- In
Employee, non key columns (employee_name,department_id) depend directly onemployee_id. - In
Department,department_namedepends ondepartment_id.
No non key column depends on another non key column in the same table.
Another 3NF Example: Address Data
Bad 3NF design for Customer:
| customer_id | name | city | zip_code |
|---|---|---|---|
| 1 | Alice | London | 12345 |
| 2 | Bob | London | 12345 |
| 3 | Carol | Bristol | 54321 |
Suppose zip_code uniquely identifies the city, so:
zip_code -> city
But in this table:
customer_id -> zip_codezip_code -> city- So
customer_id -> citythroughzip_code
city depends transitively on customer_id. To be strict 3NF, you might separate:
Customer
| customer_id | name | zip_code |
|---|---|---|
| 1 | Alice | 12345 |
| 2 | Bob | 12345 |
| 3 | Carol | 54321 |
ZipCode
| zip_code | city |
|---|---|
| 12345 | London |
| 54321 | Bristol |
In practice, many applications leave city and zip in the same table, because the practical benefit of further normalization is small compared to the extra joins. This leads to the next topic: trade offs.
Higher Normal Forms (Brief Overview)
There are more advanced normal forms:
- BCNF (Boyce Codd Normal Form)
A stricter version of 3NF. It requires that every determinant is a candidate key. Useful when you have complex or unusual dependencies. - 4NF (Fourth Normal Form)
Deals with multi valued dependencies. For example if a table mixes two independent multi valued facts about an entity. - 5NF (Fifth Normal Form)
Deals with decomposing tables to remove every possible join dependency.
For most typical backend applications:
- Up to 3NF or BCNF is usually enough.
- Higher normal forms appear in specialized or complex designs.
For this course, you only need a basic awareness that they exist, not to apply them daily.
Step by Step Normalization Example
Let us normalize a realistic table step by step. Suppose we start with a single table:
OrderFull
| order_id | order_date | customer_id | customer_name | customer_city | product_id | product_name | unit_price | quantity |
|---|---|---|---|---|---|---|---|---|
| 1 | 2024-01-01 | 10 | Alice | London | 100 | Keyboard | 30.00 | 2 |
| 1 | 2024-01-01 | 10 | Alice | London | 101 | Mouse | 10.00 | 1 |
| 2 | 2024-01-02 | 11 | Bob | Bristol | 100 | Keyboard | 30.00 | 1 |
Assume the primary key is (order_id, product_id).
Step 1: Ensure 1NF
Is this in 1NF?
- Each cell has a single value.
- No repeating groups like
item1_name,item2_name. - Data types per column are consistent.
So this table is already in 1NF.
Step 2: Check 2NF (Partial Dependencies)
Primary key: (order_id, product_id)
Non key columns: order_date, customer_id, customer_name, customer_city, product_name, unit_price, quantity
Check dependencies:
(order_id, product_id) -> quantityorder_id -> order_dateorder_id -> customer_idcustomer_id -> customer_name, customer_cityproduct_id -> product_name, unit_price
Partial dependencies:
order_dateandcustomer_iddepend only onorder_id.product_nameandunit_pricedepend only onproduct_id.
So OrderFull is not in 2NF.
Split into separate tables
We can identify at least three entities:
- Customer
- Product
- Order (with items)
Create these tables:
Customer
| customer_id | customer_name | customer_city |
|---|---|---|
| 10 | Alice | London |
| 11 | Bob | Bristol |
Product
| product_id | product_name | unit_price |
|---|---|---|
| 100 | Keyboard | 30.00 |
| 101 | Mouse | 10.00 |
Order
| order_id | order_date | customer_id |
|---|---|---|
| 1 | 2024-01-01 | 10 |
| 2 | 2024-01-02 | 11 |
OrderItem
| order_id | product_id | quantity |
|---|---|---|
| 1 | 100 | 2 |
| 1 | 101 | 1 |
| 2 | 100 | 1 |
Now, in each table:
- Non key columns depend on the whole primary key.
- We have removed partial dependencies.
So these tables are in 2NF.
Step 3: Check 3NF (Transitive Dependencies)
Check each table:
Customer
- Primary key:
customer_id - Non key:
customer_name,customer_city - Do any non key columns depend on another non key column?
Likely no obvious rule like "customer_city determines customer_name". So 3NF is fine.
Product
- Primary key:
product_id - Non key:
product_name,unit_price - No non key determines another non key. 3NF is fine.
Order
- Primary key:
order_id - Non key:
order_date,customer_id customer_idis a foreign key, but does not depend onorder_date. 3NF is fine.
OrderItem
- Primary key:
(order_id, product_id) - Non key:
quantity - Quantity depends on the full key. 3NF is fine.
So our final design is in 3NF and avoids the anomalies:
- To change a product price, update one row in
Product. - To change a customer city, update one row in
Customer. - Deleting an
OrderItemdoes not delete information about theProductorCustomer. - You can insert a new
Productthat has not been ordered yet.
Normalization vs Performance: Trade Offs
Normalization improves data quality but can increase the number of joins in queries.
For example, to get an order summary, you might need:
- Join
OrdertoCustomer - Join
OrdertoOrderItem - Join
OrderItemtoProduct
This is fine in many systems, but in very high traffic scenarios you might:
- Use denormalization: store some redundant data in a table to speed up reads.
- Cache results in Redis or another cache.
- Use materialized views.
Examples of intentional denormalization:
- Storing
customer_nameon theOrderfor quick reporting, even though you could join toCustomer. - Storing
product_nameandunit_pricesnapshot onOrderItemso that you know what the customer saw at the time, even if the product price changes later.
Practical rule:
- Use normalization (up to 3NF) as your default when designing a schema.
- Denormalize only when you have a clear reason, such as performance, and you understand how to keep data consistent.
How To Use Normalization When Designing Schemas
When you design a new set of tables, you can follow this checklist:
- List the facts you need to store.
Example: "Order has a customer, date, items, quantities, and prices." - Find the primary key for each table.
Example:order_idfor order,(order_id, product_id)for order items. - Check 1NF
- Any columns with multiple values in one cell?
- Any repeating groups like
phone1,phone2? - Check 2NF
- If a table has a composite primary key, do any non key columns depend on only part of the key?
- Check 3NF
- In each table, does any non key column depend on another non key column?
- If yes, split the table to remove the dependency.
Summary
- Normalization is about structuring data to reduce duplication and prevent anomalies.
- 1NF: No repeating groups, one value per cell, consistent types, and a primary key.
- 2NF: No partial dependencies on a composite primary key. Non key columns must depend on the whole key.
- 3NF: No transitive dependencies. Non key columns must depend only on the primary key, not on other non key columns.
- Higher normal forms (BCNF, 4NF, 5NF) exist but are less common in everyday backend work.
- In practice, you usually normalize up to 3NF, then sometimes denormalize for performance or historical reasons.
With this understanding, you can design safer, more maintainable database schemas for 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!