10.17. SQL Performance Basics
Table of Contents
Why SQL Performance Matters
When your application is small, almost any SQL query feels fast. Once you have thousands or millions of rows, badly written queries can make your whole backend feel slow.
In this chapter you will learn the basics of SQL performance, enough to:
- Recognize slow patterns.
- Write queries that scale better.
- Know when to reach for indexes or query changes.
More advanced optimization topics belong to later chapters, but the foundation starts here.
Goal: Your SQL should return the correct results in the simplest way that uses appropriate indexes and avoids unnecessary work.
How Databases Execute Queries (High Level)
Relational databases have a query planner or optimizer. When you send a SQL query, the database:
- Parses the SQL.
- Figures out possible ways to execute it.
- Chooses what it thinks is the cheapest plan.
- Executes that plan.
You can inspect this plan with commands like:
EXPLAIN SELECT * FROM users WHERE email = 'alice@example.com';You will see steps like:
- Sequential scan (full table scan).
- Index scan.
- Nested loop join.
- Sort, aggregate, etc.
You do not need to understand every detail yet. The key idea is:
The same SQL query can be executed in different ways, and some ways are much faster than others.
Your job is to write queries and design schemas so that the planner can choose a fast plan, usually by using indexes and avoiding unnecessary work.
Reading Execution Plans (Conceptually)
Every database has its own format, but common ideas repeat.
Example in PostgreSQL style:
EXPLAIN
SELECT * FROM users WHERE email = 'alice@example.com';Output might look like:
Index Scan using users_email_idx on users (cost=0.29..8.30 rows=1 width=128)
Index Cond: (email = 'alice@example.com')Key concepts that matter:
- Scan type
Seq Scan= sequential scan = full table scan.Index Scan/Index Only Scan= uses an index, usually faster for selective queries.- Rows: estimated number of rows processed at each step.
- Cost: a relative number used by the planner to compare plans.
Very simplified rule:
Prefer query plans that use index scans for selective filters and avoid unnecessary sequential scans on large tables.
If you see repeated full table scans on big tables for simple lookups, performance will not scale.
Full Table Scans vs Index Scans
Full Table Scan (Sequential Scan)
A full table scan checks every row. For example:
SELECT * FROM users WHERE last_login_at > NOW() - INTERVAL '1 day';
If there is no index on last_login_at, the database must read all rows to check the condition.
This might be fine for a table with 100 rows, but painful for 10 million rows.
Index Scan
An index acts like a sorted phone book for one or more columns. With an index, the database can jump directly to the matching rows.
Example:
CREATE INDEX idx_users_last_login_at ON users(last_login_at);Now the same query:
SELECT * FROM users WHERE last_login_at > NOW() - INTERVAL '1 day';
can use idx_users_last_login_at to find the relevant range instead of scanning everything.
Summary:
| Situation | Likely Scan Type | Performance on Large Table |
|---|---|---|
| No index on filter column | Sequential scan | Slow |
| Index on filter column, selective | Index / index-only | Fast |
| Filter matches almost all rows | Sometimes seq scan | Sometimes seq scan is cheaper |
The optimizer may still choose a full scan if almost all rows match, because jumping through an index may cost more than reading the table once.
Basic Indexing for Performance
You learned about indexes in a separate chapter. Here we focus on how they affect query speed.
Indexes help when:
- You filter with
WHERE column = valueor ranges like>,<,BETWEEN. - You join tables on a column.
- You use
ORDER BYorGROUP BYon columns.
Example schema:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
country TEXT,
created_at TIMESTAMP NOT NULL
);Built-in or typical indexes:
- Primary key on
id. - Unique index for
email.
If you frequently query by country and creation date:
SELECT * FROM users
WHERE country = 'US'
AND created_at >= NOW() - INTERVAL '7 days';you might add:
CREATE INDEX idx_users_country_created_at
ON users(country, created_at);Two important effects:
- Filters on
countryandcreated_atcan be much faster. - Sorting by
created_atfor a givencountrymight not require an extra sort step.
Create indexes for columns that you query often, especially in WHERE, JOIN, ORDER BY, or GROUP BY, but avoid creating too many indexes because every index slows down writes.
Too many or unnecessary indexes can hurt insert, update, and delete performance, and increase storage.
Writing Efficient WHERE Clauses
How you write conditions can decide whether an index can be used.
Sargable vs Non-sargable Conditions
A "sargable" condition allows the database to use an index on a column. A "non-sargable" condition forces the database to check each row.
Non-sargable example:
-- Bad for index usage
SELECT * FROM users
WHERE LOWER(email) = 'alice@example.com';
If you have an index on email, this query may not use it because the function LOWER(email) changes the column.
Better approach:
- Normalize values before storing (for example always store lowercase emails).
- Or create a functional index (database feature), which is advanced.
Simpler for beginners:
-- Store lowercase email at insert time, then query directly
SELECT * FROM users
WHERE email = 'alice@example.com';Another common non-sargable pattern:
-- Bad: function on the column
SELECT * FROM orders
WHERE DATE(created_at) = '2026-08-27';Better:
-- Good: function on the constant, or no function at all
SELECT * FROM orders
WHERE created_at >= '2026-08-27'::date
AND created_at < '2026-08-28'::date;
This allows a regular index on created_at to be used.
Using AND and OR
Indexes work best when the database can use them directly for each condition.
SELECT * FROM users
WHERE country = 'US'
AND active = true;
If you have an index on (country, active) or on country, the query can be fast.
OR conditions are often harder to optimize, for example:
SELECT * FROM users
WHERE country = 'US'
OR email = 'alice@example.com';
The optimizer may still find a good plan, but OR can sometimes lead to more work. In real projects, you sometimes rewrite complex OR queries as UNION of simpler queries, which advanced chapters will cover.
Limiting Results and Pagination
Always avoid asking for more rows than you need.
-- Bad pattern in APIs or UIs
SELECT * FROM users;If your table has a million users, the application will be overwhelmed.
Better:
SELECT * FROM users
ORDER BY id
LIMIT 50;
For APIs, combine ORDER BY with LIMIT and some pagination logic.
Basic offset pagination:
SELECT * FROM users
ORDER BY id
LIMIT 50 OFFSET 100;
But OFFSET can become slow for very large offsets, because the database still counts through the skipped rows.
Keyset pagination pattern is more efficient:
-- Get first page
SELECT * FROM users
ORDER BY id
LIMIT 50;
-- Then use the last seen id for the next page
SELECT * FROM users
WHERE id > 50
ORDER BY id
LIMIT 50;This avoids scanning many skipped rows.
Never fetch unbounded result sets in production APIs. Always use LIMIT and some form of pagination.
Selecting Only Needed Columns
Selecting fewer columns means:
- Less data to read from disk or memory.
- Less data to send over the network.
- Often less work for the database.
-- Bad if you only need names
SELECT * FROM users;Better:
SELECT id, email FROM users;This becomes more important when tables have large text or JSON columns.
In some databases, a query that only needs indexed columns can use an "index only scan," which can be even faster because it does not have to read the main table rows.
Avoiding N+1 Query Problems
The N+1 query problem happens when your application runs one query for a list, then another query for each item.
Example in pseudocode:
1) SELECT * FROM users LIMIT 100; -- 1 query
2) For each user, SELECT * FROM posts WHERE user_id = ?; -- 100 queries
Total = 101 queriesIf you have 10 000 users, this pattern can produce 10 001 queries.
Better: fetch related data in a single query with a JOIN.
SELECT u.id AS user_id,
u.email,
p.id AS post_id,
p.title
FROM users u
LEFT JOIN posts p ON p.user_id = u.id
WHERE u.id IN (1, 2, 3, ..., 100);Or:
SELECT * FROM posts
WHERE user_id IN (1, 2, 3, ..., 100);
Then group posts by user_id in your application code.
Summary:
| Pattern | Queries | Performance on N items |
|---|---|---|
| N+1 (per item) | N + 1 | Usually slow |
| Single join or IN query | 1 | Usually much faster |
If you see your backend making one small query in a loop, consider rewriting it to a single SQL query that fetches everything in one go.
Using JOINs Efficiently
JOINs are powerful but can also be slow if misused.
Index Join Columns
When you join tables, the join columns should usually be indexed.
Example:
SELECT o.*
FROM orders o
JOIN users u ON o.user_id = u.id
WHERE u.email = 'alice@example.com';Indexes that help:
- Primary key or index on
users.id(almost always exists). - Index on
orders.user_id.
Without index on orders.user_id, the database might:
- Find the user with the matching email using
users.emailindex. - Then scan the entire
orderstable to find rows with thatuser_id.
With an index on orders.user_id, it can jump directly to the user's orders.
Avoid Unnecessary JOINs
Do not join tables if you do not need their columns.
Bad:
SELECT o.id
FROM orders o
JOIN users u ON o.user_id = u.id;
If you do not use any users columns or filters, the join is useless and only adds work.
Better:
SELECT id FROM orders;Aggregations and GROUP BY
Queries with aggregates like COUNT, SUM, AVG, and GROUP BY can be expensive on large tables.
Example:
SELECT country, COUNT(*) AS users_count
FROM users
GROUP BY country;The database must:
- Scan rows.
- Group them by
country. - Count each group.
Effective tips:
- Index on the
GROUP BYcolumn can help, especially if the database can process data in index order. - Avoid grouping huge intermediate result sets when you can pre-filter first.
Less efficient:
SELECT country, COUNT(*)
FROM users
GROUP BY country
HAVING COUNT(*) > 1000;Better:
-- Often similar, but in some cases pre-filtering helps:
SELECT country, COUNT(*)
FROM users
WHERE created_at >= '2026-01-01'
GROUP BY country
HAVING COUNT(*) > 1000;You will learn more advanced aggregation optimizations later. For now, remember that aggregates on large tables can be heavy, so use filters and proper indexes.
Simple Query Rewriting Examples
Small changes sometimes make a big difference.
Example 1: LIKE vs Prefix Search
Query:
SELECT * FROM users
WHERE email LIKE '%example.com';
The leading % means the database cannot use a regular index on email. It must check every row.
If you only need to check the domain and you store emails as local_part@domain, you can split the domain into a separate column and index it:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
local_part TEXT NOT NULL,
domain TEXT NOT NULL,
...
);
CREATE INDEX idx_users_domain ON users(domain);
SELECT * FROM users
WHERE domain = 'example.com';This is much faster on large datasets.
Example 2: In-application vs in-database filtering
Bad pattern:
1) SELECT * FROM orders;
2) Filter orders in application code by created_at, status, etc.Better:
SELECT * FROM orders
WHERE status = 'PAID'
AND created_at >= NOW() - INTERVAL '30 days';Let the database filter as much as possible. It is optimized for that work.
Measuring and Observing Query Performance
To improve performance, you must measure it.
Basic things you can do:
- Use
EXPLAINorEXPLAIN ANALYZEto see query plans. - Add a timeout or log slow queries in your database configuration.
- Log query durations from your application.
Example in PostgreSQL:
EXPLAIN ANALYZE
SELECT * FROM users WHERE email = 'alice@example.com';This shows both the plan and real execution time.
Do not guess about performance. Measure query times and inspect query plans to understand what is slow.
Practical Checklist for Beginners
When you write or review a query that might run on a big table, use this checklist:
- WHERE conditions
- Are they written so indexes can be used (no unnecessary functions on columns)?
- Do you avoid
SELECT *if not needed? - Indexes
- Are there indexes on the columns used in
WHEREandJOIN? - Are there too many indexes on a table you update frequently?
- Result size
- Does the query use
LIMITwhere appropriate? - Are you using pagination for API responses?
- JOINs
- Are join columns indexed?
- Are you joining only the tables you really need?
- N+1 issues
- Is your application sending one query per item in a list?
- Can you replace this with a single query using
JOINorIN? - Aggregations
- Are you aggregating only what you need and with appropriate filters?
- Does a
GROUP BYon a huge table actually need all rows?
If you follow this checklist, you will already avoid a large portion of common SQL performance problems that beginners run into.
You now have a working understanding of SQL performance basics: how indexes affect speed, what to look for in query plans, and how to avoid typical pitfalls such as full table scans, N+1 queries, and unbounded result sets. More advanced tuning will come later, but these foundations are what you will use every day as a backend developer.
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!