10.9. GROUP BY
Table of Contents
Why `GROUP BY` Matters
When you work with data, you often need to answer questions like:
- How many orders did each customer make?
- What is the total sales per day?
- What is the average salary per department?
All these questions require grouping rows that share some value and then applying aggregate functions (like COUNT, SUM, AVG) on each group.
That is exactly what GROUP BY does.
Rule: Use GROUP BY whenever you want to apply aggregate functions per group of rows, not just over the entire table.
This chapter focuses only on GROUP BY. Aggregate functions themselves (like COUNT, SUM, AVG) are covered in the Aggregate Functions chapter, but we will use them in examples here.
Basic `GROUP BY` Syntax
The logical structure looks like this:
SELECT
column_or_expression,
aggregate_function(...)
FROM table_name
GROUP BY column_or_expression;The idea:
GROUP BYsplits the rows fromFROMinto groups with the same values in the group-by columns.- Aggregate functions calculate one result per group.
- The
SELECTreturns one row per group.
Simple Example: Counting rows per value
Table: orders
| id | customer_id | status | total_amount |
|---|---|---|---|
| 1 | 10 | 'paid' | 100.00 |
| 2 | 10 | 'paid' | 50.00 |
| 3 | 11 | 'unpaid' | 70.00 |
| 4 | 12 | 'paid' | 120.00 |
Count how many orders each customer has:
SELECT
customer_id,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id;Result:
| customer_id | order_count |
|---|---|
| 10 | 2 |
| 11 | 1 |
| 12 | 1 |
Here, GROUP BY customer_id creates 3 groups (customer 10, 11, 12). COUNT(*) runs once per group.
Rules for Columns in `SELECT` with `GROUP BY`
This is the part that often confuses beginners.
Very important rule:
In a SELECT with GROUP BY:
- Every column or expression in the
SELECTmust be: - either listed in the
GROUP BYclause - or wrapped in an aggregate function (like
COUNT,SUM,MIN,MAX,AVG, etc.)
Valid vs invalid examples
Using orders table again.
✅ Valid:
SELECT
customer_id,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id;customer_idappears inGROUP BY.COUNT(*)is an aggregate.
❌ Invalid:
SELECT
customer_id,
status,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id;
Problem: status is in SELECT but not in GROUP BY and not aggregated. The database does not know which status to show for each customer_id, since a customer could have multiple statuses across orders.
To fix it, either:
- Add
statusto the grouping:
SELECT
customer_id,
status,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id, status;
Now each group is a combination of (customer_id, status).
Result example:
| customer_id | status | order_count |
|---|---|---|
| 10 | 'paid' | 2 |
| 11 | 'unpaid' | 1 |
| 12 | 'paid' | 1 |
- Or aggregate
status, for example, withMIN(status)orMAX(status):
SELECT
customer_id,
MIN(status) AS some_status,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id;
Now MIN(status) chooses one status per customer according to sorting rules. Whether this makes sense depends on the data and the question you are answering.
Grouping by Multiple Columns
You are not limited to a single column. You can group by multiple columns to create more detailed groups.
Example: Sales per customer per status
SELECT
customer_id,
status,
COUNT(*) AS order_count,
SUM(total_amount) AS total_spent
FROM orders
GROUP BY customer_id, status;
Here the groups are defined by both customer_id and status. For each unique pair of (customer_id, status) you get one row.
With our sample data:
| id | customer_id | status | total_amount |
|---|---|---|---|
| 1 | 10 | 'paid' | 100.00 |
| 2 | 10 | 'paid' | 50.00 |
| 3 | 11 | 'unpaid' | 70.00 |
| 4 | 12 | 'paid' | 120.00 |
Result:
| customer_id | status | order_count | total_spent |
|---|---|---|---|
| 10 | 'paid' | 2 | 150.00 |
| 11 | 'unpaid' | 1 | 70.00 |
| 12 | 'paid' | 1 | 120.00 |
Grouping by expressions
You can group by calculated expressions too.
Suppose orders has a created_at column of type timestamp.
| id | customer_id | total_amount | created_at |
|---|---|---|---|
| 1 | 10 | 100.00 | 2024-01-01 10:15:00 |
| 2 | 10 | 50.00 | 2024-01-01 11:00:00 |
| 3 | 11 | 70.00 | 2024-01-02 09:30:00 |
Group by date only, ignoring time:
SELECT
DATE(created_at) AS order_date,
COUNT(*) AS orders_on_date,
SUM(total_amount) AS total_on_date
FROM orders
GROUP BY DATE(created_at);Result:
| order_date | orders_on_date | total_on_date |
|---|---|---|
| 2024-01-01 | 2 | 150.00 |
| 2024-01-02 | 1 | 70.00 |
Note that the expression DATE(created_at) appears both in SELECT and GROUP BY.
`GROUP BY` and `WHERE`: Filtering Before Grouping
Often you do not want to group all rows, only some of them. Use WHERE to filter rows before grouping.
Order of operations (simplified):
FROMandJOINWHERE(filters individual rows)GROUP BY(groups remaining rows)HAVING(filters groups, covered later)SELECTORDER BY
Example: Count only paid orders per customer
SELECT
customer_id,
COUNT(*) AS paid_orders
FROM orders
WHERE status = 'paid'
GROUP BY customer_id;Here:
- First,
WHERE status = 'paid'keeps only paid orders. - Then
GROUP BY customer_idgroups those. - Then
COUNT(*)counts how many paid orders in each group.
If the original table was:
| id | customer_id | status |
|---|---|---|
| 1 | 10 | 'paid' |
| 2 | 10 | 'paid' |
| 3 | 10 | 'unpaid' |
| 4 | 11 | 'paid' |
| 5 | 12 | 'unpaid' |
After WHERE status = 'paid', remaining rows:
| id | customer_id | status |
|---|---|---|
| 1 | 10 | 'paid' |
| 2 | 10 | 'paid' |
| 4 | 11 | 'paid' |
Then grouping and counting gives:
| customer_id | paid_orders |
|---|---|
| 10 | 2 |
| 11 | 1 |
`GROUP BY` with `HAVING`: Filtering After Grouping
Sometimes you want to filter groups, not individual rows. For example, "only customers with more than 3 orders".
You cannot do that with WHERE, because WHERE does not know about group results like COUNT(*).
For that, SQL has the HAVING clause. The Aggregate Functions chapter will discuss this more deeply, but here is the basic idea connected to GROUP BY.
Basic pattern with `HAVING`
SELECT
group_column,
aggregate_function(...) AS agg
FROM table_name
GROUP BY group_column
HAVING aggregate_function(...) condition;Example: Customers with at least 2 orders
SELECT
customer_id,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id
HAVING COUNT(*) >= 2;Interpretation:
GROUP BY customer_idcreates groups.COUNT(*)is computed for each group.HAVING COUNT(*) >= 2removes the groups that do not meet the condition.
Given this data:
| id | customer_id |
|---|---|
| 1 | 10 |
| 2 | 10 |
| 3 | 11 |
| 4 | 12 |
| 5 | 12 |
Result:
| customer_id | order_count |
|---|---|
| 10 | 2 |
| 12 | 2 |
Combining `WHERE` and `HAVING`
You can and often should use both.
Example: Find customers who have at least 2 paid orders.
SELECT
customer_id,
COUNT(*) AS paid_orders
FROM orders
WHERE status = 'paid' -- filter rows first
GROUP BY customer_id
HAVING COUNT(*) >= 2; -- then filter groupsWHERElimits to paid orders.GROUP BYgroups by customer.HAVINGkeeps only groups with at least 2 paid orders.
Practical Examples of `GROUP BY`
Let us look at different question types and how GROUP BY helps.
Example 1: Counting distinct values
Table: users
| id | country | age |
|---|---|---|
| 1 | 'US' | 22 |
| 2 | 'US' | 30 |
| 3 | 'DE' | 25 |
| 4 | 'FR' | 27 |
Question: How many users per country?
SELECT
country,
COUNT(*) AS user_count
FROM users
GROUP BY country;Result:
| country | user_count |
|---|---|
| 'US' | 2 |
| 'DE' | 1 |
| 'FR' | 1 |
Example 2: Average per group
Question: What is the average age per country?
SELECT
country,
AVG(age) AS avg_age
FROM users
GROUP BY country;Result:
| country | avg_age |
|---|---|
| 'US' | 26.0 |
| 'DE' | 25.0 |
| 'FR' | 27.0 |
Example 3: Grouping by multiple columns
Table: events
| id | user_id | event_type | created_at |
|---|---|---|---|
| 1 | 1 | 'login' | 2024-01-01 10:00:00 |
| 2 | 1 | 'click' | 2024-01-01 10:05:00 |
| 3 | 2 | 'login' | 2024-01-01 11:00:00 |
| 4 | 1 | 'login' | 2024-01-02 09:00:00 |
Question: How many events per user and per event type?
SELECT
user_id,
event_type,
COUNT(*) AS event_count
FROM events
GROUP BY user_id, event_type;Result:
| user_id | event_type | event_count |
|---|---|---|
| 1 | 'login' | 2 |
| 1 | 'click' | 1 |
| 2 | 'login' | 1 |
Example 4: Grouping by a transformed value
Question: How many logins per day?
SELECT
DATE(created_at) AS login_date,
COUNT(*) AS login_count
FROM events
WHERE event_type = 'login'
GROUP BY DATE(created_at)
ORDER BY login_date;If the timestamps are:
| id | event_type | created_at |
|---|---|---|
| 1 | 'login' | 2024-01-01 10:00:00 |
| 2 | 'login' | 2024-01-01 11:00:00 |
| 3 | 'login' | 2024-01-02 09:00:00 |
Result:
| login_date | login_count |
|---|---|
| 2024-01-01 | 2 |
| 2024-01-02 | 1 |
Common Pitfalls and How to Avoid Them
Pitfall 1: Selecting non grouped, non aggregated columns
You might try:
SELECT
customer_id,
status,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id;
This is usually not allowed (or it gives undefined results in some databases) because status is neither grouped nor aggregated.
Fix: Either group by status too, or aggregate it.
-- Option 1
GROUP BY customer_id, status;
-- Option 2
SELECT
customer_id,
MIN(status) AS some_status,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id;Pitfall 2: Using `WHERE` for group conditions
You cannot write:
SELECT
customer_id,
COUNT(*) AS order_count
FROM orders
WHERE COUNT(*) > 1
GROUP BY customer_id;
WHERE cannot use COUNT(*) because grouping is not done yet.
Fix: Use HAVING instead.
SELECT
customer_id,
COUNT(*) AS order_count
FROM orders
GROUP BY customer_id
HAVING COUNT(*) > 1;Pitfall 3: Forgetting to group by all non aggregated columns
When you have more than one non aggregated column, all of them must appear in the GROUP BY.
❌ Wrong:
SELECT
country,
city,
COUNT(*) AS user_count
FROM users
GROUP BY country;✅ Correct:
SELECT
country,
city,
COUNT(*) AS user_count
FROM users
GROUP BY country, city;Mental Model for `GROUP BY`
It helps to imagine GROUP BY in steps:
- Start with all rows from
FROMandWHERE. - Place each row into a bucket based on the group-by column values.
- Group by
countrymeans one bucket per country. - Group by
country, citymeans one bucket per pair of values. - For each bucket, compute aggregate functions using only rows in that bucket.
- Output one row per bucket.
For example, GROUP BY country:
- Bucket "US": all rows where
country = 'US'. - Bucket "DE": all rows where
country = 'DE'. - Bucket "FR": all rows where
country = 'FR'.
COUNT(*) counts how many rows are in each bucket. SUM(amount) adds amounts in each bucket. AVG(age) averages ages in each bucket.
Summary
GROUP BYis used to group rows that have the same values in one or more columns.- Combine
GROUP BYwith aggregate functions to compute results per group, such as counts, sums, or averages. - Every column in
SELECTmust either: - appear in
GROUP BY, or - be inside an aggregate function.
- Use
WHEREto filter individual rows before grouping. - Use
HAVINGto filter groups after aggregation. - You can group by multiple columns and by expressions, not just simple column names.
Understanding GROUP BY is essential for any backend developer who reads or writes SQL for reporting, analytics, or even simple statistics in APIs.
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!