9.10. Database Schema Design
Table of Contents
Why Schema Design Matters
When you build any non‑trivial backend, your database schema quickly becomes one of the most important parts of your system. A good schema:
- Makes common queries easy and fast.
- Reduces bugs and inconsistent data.
- Is easier to change and extend later.
A bad schema:
- Forces you to write complicated queries.
- Leads to duplicate and contradictory data.
- Becomes painful to maintain as the app grows.
In this chapter we focus on how to think about designing relational database schemas. We will not go deep into SQL syntax or normalization theory proofs, because those have their own chapters. Here we look at the practical process and patterns.
From Requirements to Tables
Schema design always starts from the data and the questions you need to answer.
Step 1: Identify entities
An entity is a thing you need to store information about.
Example: Simple blog application
You might see entities like:
- User
- Post
- Comment
- Tag
Each entity usually becomes a table.
Example mapping:
| Entity | Likely table name |
|---|---|
| User | users |
| Post | posts |
| Comment | comments |
| Tag | tags |
Try a similar exercise for an online bookstore:
- Book
- Author
- Customer
- Order
- Order item
- Payment
Already you can imagine tables like books, authors, customers, orders, order_items, payments.
Step 2: Identify attributes
Attributes are the properties of each entity. These become columns.
Example: users table
idemailpassword_hashfull_namecreated_atis_active
Example: posts table
idauthor_idtitlecontentpublished_atis_published
Do not worry too much about exact data types at this stage, only about what must be stored.
Step 3: Identify relationships
Entities rarely live alone. You need to understand how they relate.
Typical questions:
- Can a user have many posts?
- Can a post have many comments?
- Can a post have many tags?
- Can a tag belong to many posts?
Examples:
- User to Post: one user, many posts, so one‑to‑many
- Post to Comment: one post, many comments, so one‑to‑many
- Post to Tag: posts can have many tags, tags can belong to many posts, so many‑to‑many
You already saw separate chapters for relationships, so here we only talk about the impact on schema design:
- One‑to‑many often uses a foreign key column on the "many" side.
- Many‑to‑many often uses an extra "join" table.
Example design:
users
id (PK)
email
...
posts
id (PK)
author_id (FK -> users.id)
...
comments
id (PK)
post_id (FK -> posts.id)
author_id (FK -> users.id)
...
tags
id (PK)
name
post_tags
post_id (FK -> posts.id)
tag_id (FK -> tags.id)
PRIMARY KEY (post_id, tag_id)
The post_tags table exists only to represent the many‑to‑many relationship.
Choosing Table and Column Names
Names are part of the design. Clear names reduce confusion and bugs.
Naming tables
Common conventions:
- Use plural nouns, for example
users,orders,products. - Use lowercase with underscores in SQL databases like PostgreSQL.
- Avoid spaces and special characters in names.
Examples:
| Good | Avoid |
|---|---|
users | UserTable |
order_items | OrderItemsTable |
blog_posts | BP or blogPosts |
Tips:
- Be consistent across the whole schema.
- Use the same word everywhere for the same concept, for example always
user, notmemberin some places andaccountin others.
Naming columns
Keep columns simple and descriptive.
Examples:
| Good | Avoid |
|---|---|
id | user_id_number_123 |
created_at | creationDate |
updated_at | lastUpdateTimeStamp |
is_active | active_or_not |
email | userEmailAddress |
Common patterns:
- Primary key: often
id. - Foreign key:
<related_table_singular>_id, for exampleuser_id,product_id. - Timestamps:
created_at,updated_at, sometimesdeleted_at. - Boolean flags:
is_active,is_admin,email_verified.
Example table:
orders
id
customer_id
total_amount
currency
status
created_at
updated_atPrimary Keys in Schema Design
You already know what primary keys are. In schema design you must decide how to define them.
Natural vs surrogate keys
- Natural key comes from actual business data, for example email, SKU, ISBN.
- Surrogate key is an artificial identifier, for example auto‑increment integer, UUID.
Example natural keys:
users.emailcountries.code(like "US", "DE")books.isbn
Example surrogate keys:
users.idas integerorders.idas UUID
Why surrogate keys are common
Surrogate keys are often preferred for main primary keys because:
- They do not change when business rules change.
- They are usually shorter and more efficient in indexes than long strings.
- They keep foreign keys small and simple.
Typical pattern:
users
id SERIAL PRIMARY KEY
email TEXT UNIQUE NOT NULL
...
orders
id UUID PRIMARY KEY
user_id INTEGER REFERENCES users(id)
...
Email is unique, but id is still the primary key.
Composite primary keys
A composite primary key uses several columns together as the primary key.
You usually see this in join tables.
Example:
post_tags
post_id INTEGER REFERENCES posts(id)
tag_id INTEGER REFERENCES tags(id)
PRIMARY KEY (post_id, tag_id)
Here, (post_id, tag_id) uniquely identifies a row. There is no separate id column.
Another example: an order item
order_items
order_id INTEGER REFERENCES orders(id)
line_number INTEGER
product_id INTEGER REFERENCES products(id)
quantity INTEGER NOT NULL
PRIMARY KEY (order_id, line_number)
Each order has line numbers 1, 2, 3 and so on. The pair (order_id, line_number) is unique.
Important rule: If an entity can be naturally identified by a small combination of columns, a composite primary key is often a good fit, especially in relationship tables.
Foreign Keys and Relationships in Design
Foreign keys connect your tables.
One‑to‑many example: Users and Posts
Design:
users
id (PK)
email
...
posts
id (PK)
author_id (FK -> users.id)
title
content
author_id is a foreign key. This enforces that every post references an existing user.
You can decide what happens when a user is deleted:
- Prohibit deleting the user if posts exist (
ON DELETE RESTRICT). - Automatically delete the posts (
ON DELETE CASCADE). - Set
author_idtoNULL(ON DELETE SET NULL).
You choose this behavior based on business rules.
Example SQL idea (syntax simplified):
author_id INTEGER REFERENCES users(id) ON DELETE CASCADEMany‑to‑many example: Products and Categories
Design:
products
id (PK)
name
price
categories
id (PK)
name
product_categories
product_id (FK -> products.id)
category_id (FK -> categories.id)
PRIMARY KEY (product_id, category_id)
To find all products in a category, you join products with product_categories.
To find all categories of a product, you join categories with product_categories.
Required vs Optional Data
Not every column must always have a value.
NOT NULL vs NULL
You decide which columns are required and which are optional.
Example:
users
id (PK)
email NOT NULL
password_hash NOT NULL
full_name NOT NULL
bio NULL
avatar_url NULL
created_at NOT NULL- A user must have
email,password_hash,full_name. - A user may or may not have
bio,avatar_url.
Rule: Use NOT NULL for every column that must always have a value. Use NULL only when "no value" is a valid and expected state.
Examples of clearly required fields:
created_atfor audit.order_idinorder_items.quantityfor an order item.
Examples of clearly optional fields:
middle_namein a user profile.shipped_atwhen order is not shipped yet.deleted_atwhen record is active.
Default values
Default values simplify inserts and make data more consistent.
Examples:
users
is_active BOOLEAN NOT NULL DEFAULT TRUE
created_at TIMESTAMP NOT NULL DEFAULT now()
orders
status TEXT NOT NULL DEFAULT 'pending'
currency TEXT NOT NULL DEFAULT 'USD'
If you insert a user without specifying is_active, it becomes TRUE.
Use defaults where most rows will have the same value.
Avoiding Redundant and Inconsistent Data
Poor schema design often leads to duplicated data that becomes inconsistent.
Obvious duplication example
Bad design:
orders
id
customer_id
customer_email
customer_name
Here the email and name are copied from customers. If the customer updates their email, which value is correct?
Better design:
customers
id
email
name
...
orders
id
customer_id (FK -> customers.id)
...
When you need the email for an order, you join orders with customers.
Legitimate duplication example
Sometimes you need to store historical data at the time of an event.
Example: storing the price of a product when the order is placed.
Bad idea:
order_items
id
order_id
product_id
-- later you select product price from products tableIf product price changes over time, past orders become inaccurate.
Better design:
order_items
id
order_id
product_id
unit_price_at_order
quantityYou duplicate the price value intentionally, because it represents "price at order time", which should not change.
Key idea:
- Avoid duplication of data that should always be the same across the system.
- Allow duplication when you are capturing a snapshot of reality at a specific time.
Denormalization for Performance
Normalization is about reducing redundancy and improving consistency. However, sometimes a fully normalized design becomes too slow or too complex for common queries.
Denormalization means you intentionally duplicate or precompute some data to speed up reads.
You will see normalization concepts separately, so here we only look at practical cases.
Example: storing counts
Normalized design:
posts
id
title
content
comments
id
post_id
content
To get the number of comments for a post, you count on the comments table:
SELECT COUNT(*) FROM comments WHERE post_id = :post_id;For a small app this is fine. For a big app with millions of comments, this may be slow if you do it all the time.
Denormalized design:
posts
id
title
content
comments_count INTEGER NOT NULL DEFAULT 0
comments
id
post_id
content
When you insert a comment, you also increment posts.comments_count. Now you can show the count directly from posts without counting every time.
Trade‑off: You must keep comments_count accurate in your application logic or with database triggers.
Example: caching computed values
Imagine a users table and orders table. You want to often display each user's "total_spent".
Normalized:
- Compute on the fly with
SUM(order_items.unit_price * order_items.quantity)joined withorders.
Denormalized:
users
id
email
total_spent NUMERIC NOT NULL DEFAULT 0
On each new paid order, you update users.total_spent. Reads become trivial.
Rule: Start with a normalized schema. Only denormalize when you have measured performance problems and you understand the consistency cost.
Modeling Common Patterns
Let us look at a few recurring schema patterns and how to model them.
Soft deletes
Sometimes you do not want to delete rows physically. You want to "soft delete" them so you can restore later or keep history.
Common options:
is_deletedboolean flag:
users
id
email
is_deleted BOOLEAN NOT NULL DEFAULT FALSE
Application queries must filter out deleted records: WHERE is_deleted = FALSE.
deleted_attimestamp:
users
id
email
deleted_at TIMESTAMP NULL
If deleted_at is NULL, user is active. If not NULL, user is deleted.
Advantage: you know when deletion occurred.
Status fields
Many entities go through states, such as orders or tickets.
Example: order status
orders
id
customer_id
status -- 'pending', 'paid', 'shipped', 'cancelled'
placed_at
paid_at
shipped_at
cancelled_atUse clear status values. You can enforce allowed values with constraints or enums in the database.
You often store both the status and the timestamps of important transitions.
Polymorphic relationships
Sometimes an entity can belong to more than one type of parent.
Example: You want to store "likes", which can apply to posts or comments.
Option 1: separate tables
post_likes
user_id
post_id
comment_likes
user_id
comment_idOption 2: polymorphic relation
likes
id
user_id
target_type -- 'post' or 'comment'
target_id
With option 2 you must check in application logic that target_id actually exists in the right table.
As a beginner, prefer separate tables when possible. They are simpler and enforce referential integrity.
Designing for Queries
You design a schema not only from entities, but also from the questions you need to answer.
When planning tables, always ask:
- What are the most common queries?
- Which combinations of fields are searched and filtered?
- How will data be sorted and paginated?
Example: simple task manager
Requirements:
- List tasks for a user, most recent first.
- Filter tasks by status (open / done).
- Search tasks by title.
Draft schema:
tasks
id
user_id
title
description
status -- 'open', 'done'
created_at
due_atNow think queries:
- "Give me open tasks for user 42 ordered by created_at descending."
- "Search by title 'groceries' for user 42."
This influences your indexing decisions, which you will learn later. For now, the important part is to design columns that support the queries.
Bad design example:
tasks
id
user_id
title
description
is_done
is_archived
is_pinned
status_text
You have multiple columns representing the same concept (status). Better to use a single status column.
Better design:
tasks
id
user_id
title
description
status -- 'open', 'done', 'archived', 'pinned'
created_atOr, if "pinned" is independent of status:
tasks
id
user_id
title
description
status -- 'open', 'done', 'archived'
is_pinned BOOLEAN NOT NULL DEFAULT FALSE
created_atExample: Step‑by‑Step Design for a Simple E‑Commerce
Let us walk through a small example to see the process.
Requirements
- Customers can create accounts.
- Products are listed with prices.
- Customers can create orders with multiple items.
- You want to keep the price at the time of order.
- Each order has a status.
Step 1: Entities
- Customer
- Product
- Order
- OrderItem
Step 2: Attributes
Customer:
- id
- password_hash
- full_name
- created_at
Product:
- id
- name
- description
- price
- currency
- is_active
Order:
- id
- customer_id
- status
- created_at
- paid_at
- cancelled_at
OrderItem:
- id
- order_id
- product_id
- quantity
- unit_price
- currency
Step 3: Relationships
- One customer has many orders.
- One order has many order items.
- One product appears in many order items.
Schema sketch:
customers
id (PK)
email UNIQUE NOT NULL
password_hash NOT NULL
full_name NOT NULL
created_at NOT NULL
products
id (PK)
name NOT NULL
description
price NUMERIC NOT NULL
currency TEXT NOT NULL DEFAULT 'USD'
is_active BOOLEAN NOT NULL DEFAULT TRUE
orders
id (PK)
customer_id (FK -> customers.id) NOT NULL
status TEXT NOT NULL DEFAULT 'pending' -- 'pending', 'paid', 'cancelled'
created_at NOT NULL
paid_at
cancelled_at
order_items
id (PK)
order_id (FK -> orders.id) NOT NULL
product_id (FK -> products.id) NOT NULL
quantity INTEGER NOT NULL
unit_price NUMERIC NOT NULL
currency TEXT NOT NULLNotice:
- We avoid storing
customer_emailin orders to reduce duplication. - We duplicate
unit_priceandcurrencyinorder_itemsintentionally to capture historical price. - We use single
statusinordersinstead of multiple boolean flags.
You can then refine with indexes and constraints later.
Practical Tips and Checklist
When you design a schema, go through a checklist.
Table by table, ask:
- Entities
- Does this table represent one clear concept?
- Is the table name clear and consistent?
- Primary key
- Is there a primary key?
- Do I need a surrogate key or is a composite key better?
- Columns
- Are required columns marked
NOT NULL? - Do optional columns really need to be optional?
- Are default values set where useful?
- Relationships
- Are foreign keys defined where needed?
- Is the relationship one‑to‑many, many‑to‑many, or one‑to‑one?
- Do I need a join table?
- Redundancy
- Am I duplicating data that should be central?
- If I duplicate data, is it intentionally a historical snapshot?
- Usage
- What are the most common queries on this table?
- Do the columns support those queries naturally?
- Future changes
- Can I add fields later without breaking existing ones?
- Am I avoiding hard coding assumptions that are likely to change, such as "there are only three possible statuses forever"?
If you walk through this process and discuss the schema with teammates or just yourself on paper, you will already avoid many common problems.
This is the practical side of database schema design: start from the real world, map it to tables, think about relationships and queries, avoid unnecessary duplication, and only optimize with denormalization when you have to.
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!