26.6. Indexing
Table of Contents
Why Indexes Matter for Performance
Indexes are one of the most powerful tools for speeding up database queries. Used correctly, they can make a slow query thousands of times faster. Used wrongly, they can slow down writes and waste memory.
This chapter focuses on indexing from a performance and scalability perspective. It assumes you already know basic database concepts and what an index is at a high level.
Key idea: An index lets the database find rows without scanning the whole table. You trade extra storage and slower writes for much faster reads.
How Indexes Affect Query Performance
Full table scan vs indexed lookup
Imagine a users table with 10 million rows.
SELECT * FROM users WHERE email = 'alice@example.com';
Without an index on email, the database must:
- Start at the first row.
- Check
emailvalue. - Move to the next row.
- Repeat until it finds matching rows or reaches the end.
This is a full table scan. Time grows roughly with the number of rows, $O(n)$.
With an index on email:
CREATE INDEX idx_users_email ON users (email);The database can:
- Search the index structure (for example a B-tree) to find the right position.
- Jump directly to the matching row(s).
This lookup is typically $O(\log n)$ and involves far fewer disk pages.
Very roughly:
| Rows | Full Scan (no index) | Indexed Lookup (B-tree) |
|---|---|---|
| 1,000 | ~1,000 checks | ~10 checks |
| 1,000,000 | ~1,000,000 checks | ~20 checks |
| 100M | ~100,000,000 checks | ~27 checks |
The exact numbers vary, but the pattern is stable: indexes scale much better as data grows.
Selectivity and cardinality
Indexes are fastest when they are selective, meaning they greatly reduce the number of rows the database must inspect.
- High cardinality column
Many distinct values, for exampleemail,id,order_id.
Good index candidate. - Low cardinality column
Few distinct values, for examplestatuswith valuesNEW,PAID,CANCELLED.
A plain index might not be as useful, because many rows share the same value.
Example:
SELECT * FROM orders WHERE status = 'PAID';
If 90% of orders are PAID, the index on status will not filter much. The database might choose a table scan instead, because jumping around through the index and table can be slower than a simple sequential scan.
Rule: Index columns that significantly reduce the number of rows to scan. High selectivity makes indexes effective.
Reading Queries Through the Lens of Indexes
Identifying the “filter columns”
Look at a query and mark the parts that filter rows:
SELECT id, email
FROM users
WHERE country = 'US'
AND is_active = true
AND created_at >= '2024-01-01'
ORDER BY created_at DESC
LIMIT 20;- Filter conditions:
country,is_active,created_at. - Sort:
ORDER BY created_at DESC. - Limit:
LIMIT 20.
Indexing goals:
- Help the database filter quickly by the
WHEREclause. - Help it avoid a sort for
ORDER BYif possible. - Combine both so it can find the top 20 rows quickly.
A possible composite index:
CREATE INDEX idx_users_country_active_created
ON users (country, is_active, created_at DESC);This index can:
- Filter by
countryandis_active. - Already be ordered by
created_at DESC. - Allow the database to stop early after grabbing 20 rows.
Range queries and indexes
Range conditions like >=, >, <, BETWEEN use indexes efficiently when they appear at the end of an index.
Example:
SELECT *
FROM orders
WHERE customer_id = 123
AND created_at >= '2024-01-01';Index:
CREATE INDEX idx_orders_customer_created
ON orders (customer_id, created_at);
This index structure is grouped by customer_id. Inside each group, rows are ordered by created_at. To handle the query:
- Find the first index entry with
customer_id = 123andcreated_at >= '2024-01-01'. - Scan forward until
customer_idchanges.
Very few rows are touched if the user has few orders.
If you reversed the index:
CREATE INDEX idx_orders_created_customer
ON orders (created_at, customer_id);This is worse for the same query, because:
- The index is grouped by
created_at, not bycustomer_id. - The database would have to scan many different
customer_idvalues.
Rule: For composite indexes, put equality filters first, then range filters.
How Indexes Affect Writes and Storage
Indexes improve read performance, but they are not free.
Inserts, updates, and deletes
When you:
INSERT INTO users (id, email) VALUES (...);the database must:
- Insert the row into the table.
- Update every index that touches
idoremail.
Similarly, when you UPDATE or DELETE rows, indexes must be maintained.
Effects:
- More CPU work per write.
- More disk I/O for index pages.
- Potentially more locking or contention in high write workloads.
A table with 10 indexes will have much slower inserts than a table with 2 well chosen indexes.
Rule: Indexes speed up reads, but slow down writes. Do not index every column by default.
Storage and memory
Indexes take disk space and memory.
- Disk: large tables with many indexes can use more disk space in indexes than in the base table.
- Memory (buffer cache): index pages must be cached in RAM, competing with table data.
On a busy system, extra indexes can:
- Evict useful data from cache.
- Increase disk reads.
- Hurt overall performance.
Index maintenance over time
Indexes also influence:
- Vacuum and autovacuum in databases like PostgreSQL.
- Rebuilds or defragmentation in some systems.
- Backup size and time.
From a scalability point of view, too many or poorly designed indexes can become a serious operational cost.
Types of Indexes and When to Use Them
Different database engines have different index types. Here we stay at a conceptual level.
B-tree indexes
Most common default index type.
Good for:
- Equality searches:
WHERE email = '...' - Range searches:
WHERE created_at BETWEEN ... - Sorting:
ORDER BY created_at
Most of your indexes in OLTP (online transaction processing) systems will be B-tree like structures.
Hash indexes
Optimized for equality checks, for example WHERE session_token = 'xyz'.
Limitations often include:
- Not useful for range queries.
- Sometimes less flexible than B-tree.
- Sometimes not WAL logged or durable in the same way, depending on database.
For many workloads B-tree is still the best default.
Covering indexes
A covering index is an index that contains all the columns needed for a query, so the database does not have to read the base table at all.
Example query:
SELECT id, email
FROM users
WHERE email LIKE 'alice%@example.com';If the index is:
CREATE INDEX idx_users_email
ON users (email);The database:
- Uses the index to find matching
emailvalues. - Then reads the table to fetch
idfor each row (a "bookmark" lookup).
If you create a covering index:
-- Syntax varies by database, concept is what matters
CREATE INDEX idx_users_email_id
ON users (email, id);
Now, the index has both email and id. The database might satisfy the entire query from the index, which saves I/O.
Covering indexes are especially useful for frequent, performance critical queries that read few columns.
Rule: Use covering indexes for hot, simple queries where avoiding table lookups is worth extra index storage.
Designing Composite Indexes for Performance
Index column order
For an index on (a, b, c):
- The database can efficiently filter on:
aa, ba, b, c- But not directly on:
balonecaloneb, cwithouta
This is sometimes called the left prefix rule.
Example:
CREATE INDEX idx_orders_customer_status_created
ON orders (customer_id, status, created_at);Useful for queries like:
-- 1. Uses (customer_id)
SELECT * FROM orders WHERE customer_id = 123;
-- 2. Uses (customer_id, status)
SELECT * FROM orders WHERE customer_id = 123 AND status = 'PAID';
-- 3. Uses (customer_id, status, created_at)
SELECT * FROM orders
WHERE customer_id = 123 AND status = 'PAID'
ORDER BY created_at DESC;But less useful for:
-- Cannot fully use the index, no customer_id
SELECT * FROM orders WHERE status = 'PAID';So choose the column order based on actual query patterns, not just "what seems important."
Combining WHERE and ORDER BY
Try to support both filtering and sorting with one index.
Example query:
SELECT *
FROM products
WHERE category_id = 5
ORDER BY price ASC
LIMIT 50;Index:
CREATE INDEX idx_products_category_price
ON products (category_id, price);Benefits:
- Filter by
category_id. - Already sorted by
pricewithin that category. - Database can scan until it collects 50 rows, then stop.
If you instead only had:
CREATE INDEX idx_products_category ON products (category_id);The database:
- Uses the index to find all products with
category_id = 5. - Collects them, then sorts them by
price. - Returns the top 50.
This is slower, especially for large categories.
Multiple indexes vs one composite index
Sometimes you might think:
CREATE INDEX idx_users_country ON users (country);
CREATE INDEX idx_users_is_active ON users (is_active);for:
SELECT * FROM users
WHERE country = 'US' AND is_active = true;Whether this is good or not depends on the database. Some can combine indexes, using both. But usually a single composite index is more effective:
CREATE INDEX idx_users_country_is_active
ON users (country, is_active);The composite index keeps the combination of values together, often reducing work.
Indexing Patterns for Common Workloads
Point lookups
Use case: Find a single row by unique key.
Example:
SELECT * FROM users WHERE id = 42;Backend pattern: Getting a user by ID for authentication, showing a profile, etc.
Index design:
- A primary key index on
id. - Effectively always present on
idif it is the primary key.
Another example:
SELECT * FROM users WHERE email = 'alice@example.com';
If email must be unique:
CREATE UNIQUE INDEX idx_users_email ON users (email);Use unique indexes to:
- Enforce business rules.
- Get very fast lookups.
Recent data queries
Use case: "Latest N" items, like last 100 orders, last 50 log entries.
Example:
SELECT *
FROM logs
ORDER BY created_at DESC
LIMIT 100;Index:
CREATE INDEX idx_logs_created_at_desc
ON logs (created_at DESC);The database can:
- Scan the index from the newest entries.
- Stop after 100 rows.
- Potentially avoid scanning the full table.
Very common in dashboards and activity feeds.
Time range queries
Use case: Data for a given time window.
SELECT *
FROM orders
WHERE created_at BETWEEN '2024-01-01' AND '2024-12-31';Index:
CREATE INDEX idx_orders_created_at
ON orders (created_at);With additional filters:
SELECT *
FROM orders
WHERE customer_id = 123
AND created_at >= '2024-01-01'
AND created_at < '2024-02-01';Index:
CREATE INDEX idx_orders_customer_created
ON orders (customer_id, created_at);Pagination
Pattern:
SELECT *
FROM products
WHERE category_id = 7
ORDER BY id
LIMIT 20 OFFSET 1000;Offset-based pagination can be slow because the database must skip and count many rows.
Better pattern for performance: keyset pagination (also called cursor-based):
-- First page
SELECT *
FROM products
WHERE category_id = 7
ORDER BY id
LIMIT 20;
-- Next page, use last id from previous page
SELECT *
FROM products
WHERE category_id = 7
AND id > :last_id
ORDER BY id
LIMIT 20;Index:
CREATE INDEX idx_products_category_id
ON products (category_id, id);
This index lets the database jump directly to category_id = 7 and id > last_id and then scan forward.
From a backend perspective, designing pagination that works well with indexes is crucial for scalability.
Avoiding Common Indexing Pitfalls
Indexing every column
It is easy to think: "Indexes make queries faster, so let us add one on every column."
Problems:
- Write performance drops.
- Storage grows quickly.
- Query planner has too many choices, potential suboptimal plans.
- Maintenance overhead increases.
Instead:
- Start with essential indexes: primary keys, foreign keys, and a few critical query indexes.
- Measure performance.
- Add indexes based on evidence.
Ignoring the query planner
Relational databases have tools to show query plans, such as EXPLAIN in PostgreSQL and MySQL.
Example:
EXPLAIN ANALYZE
SELECT * FROM users WHERE email = 'alice@example.com';This shows:
- Whether an index is used.
- If it is doing a sequential scan instead.
- How many rows are touched.
- Estimated vs actual cost.
Use these tools to:
- Confirm that your index is effective.
- Discover missing indexes.
- See when an index is not selective enough.
Functions on indexed columns
This overlaps with more detailed SQL topics, but the performance idea is:
SELECT *
FROM users
WHERE LOWER(email) = 'alice@example.com';
If you have an index on email, the database might not use it, because LOWER(email) prevents direct index lookup.
Possible fix:
- Use a functional index if supported, for example an index on
LOWER(email). - Or store normalized values (e.g. lowercase emails) and index them directly.
Overlapping indexes
Example:
CREATE INDEX idx_orders_customer ON orders (customer_id);
CREATE INDEX idx_orders_customer_status ON orders (customer_id, status);The first index is mostly covered by the second. You might not need both.
Too many overlapping indexes:
- Waste disk and memory.
- Slow writes for little gain.
Regularly review your index list and remove unused or redundant ones.
Monitoring and Evolving Index Strategy
Measuring index usage
Production databases expose statistics:
- How often an index is scanned.
- How many rows it returns.
- How many index-only scans occur.
- How many table scans happen without using an index.
By monitoring:
- You can find unused indexes to drop.
- You can find hot queries with missing indexes.
- You can detect regressions after schema changes.
Adapting to changing query patterns
As your backend grows:
- New features add new queries.
- Old queries are no longer used.
- Traffic patterns change.
Your index strategy should evolve:
- When adding new features, think about their queries and necessary indexes.
- Periodically review index usage in production.
- Clean up obsolete indexes.
Treat indexes as part of your performance-focused API design, not as a one-time database detail.
Practical workflow
A simple workflow when debugging a slow query:
- Get the exact SQL query the application sends.
- Run
EXPLAINor equivalent to see the plan. - Check if a full table scan is happening.
- Identify filter, join, and sort columns.
- Design a candidate index that helps with the biggest cost.
- Create index in a test or staging environment.
- Re-run
EXPLAINand measure execution time. - If improved, roll out carefully to production.
Over time, this workflow becomes a normal part of backend performance tuning.
Summary
Indexes are a central tool in backend performance and scalability:
- They let databases find rows efficiently without scanning entire tables.
- They are most effective when they are selective and match real query patterns.
- Composite indexes should be designed with filtering, sorting, and pagination in mind.
- Indexes come with costs: slower writes, more storage, and operational overhead.
- Good performance engineering includes measuring, planning indexes around real queries, and regular maintenance.
By understanding indexing at this practical level, you can design schemas and queries that scale far better as your application and data grow.
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!