10.10. Aggregate Functions
Table of Contents
Understanding Aggregate Functions
Aggregate functions help you calculate a single value from many rows. Instead of working on one row at a time, they look at a group of rows and return one result, for example a total, an average, or a maximum.
You will use aggregate functions constantly in reporting, dashboards, and analytics.
Typical aggregates include:
| Function | Description | Common use example |
|---|---|---|
COUNT | Number of rows or non-null values | How many users signed up |
SUM | Sum of numeric values | Total revenue |
AVG | Average of numeric values | Average order value |
MIN | Smallest value | First signup date |
MAX | Largest value | Biggest purchase amount |
All of these return one value for a set of rows.
Important rule:
Aggregate functions compute one result per group of rows.
If you use aggregate functions together with regular columns, you must use a GROUP BY clause or you will get an error in most SQL databases.
In the examples, imagine a table:
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
user_id INTEGER,
amount NUMERIC(10, 2),
status VARCHAR(20), -- 'pending', 'paid', 'canceled'
created_at TIMESTAMP
);COUNT
COUNT returns how many rows match a condition.
Variants:
| Expression | What it counts |
|---|---|
COUNT(*) | All rows, including rows with NULL in some columns |
COUNT(column) | Rows where column is not NULL |
COUNT(DISTINCT column) | Unique, non-null values in column |
Basic COUNT examples
Count all orders:
SELECT COUNT(*) AS total_orders
FROM orders;Count all paid orders:
SELECT COUNT(*) AS paid_orders
FROM orders
WHERE status = 'paid';
Count users that have at least one order (ignores NULL user_id):
SELECT COUNT(user_id) AS users_with_orders
FROM orders;
If some rows have user_id = NULL, COUNT(user_id) will not include them.
Count distinct users who have made at least one order:
SELECT COUNT(DISTINCT user_id) AS unique_customers
FROM orders;COUNT with GROUP BY
Count orders per status:
SELECT status, COUNT(*) AS count_orders
FROM orders
GROUP BY status;Possible result:
| status | count_orders |
|---|---|
| pending | 12 |
| paid | 35 |
| canceled | 3 |
Each group of rows with the same status produces one count.
SUM
SUM adds up numeric values.
Total revenue from paid orders:
SELECT SUM(amount) AS total_revenue
FROM orders
WHERE status = 'paid';
If there are no matching rows, most databases return NULL for SUM(amount), not 0. You often want to handle this:
SELECT COALESCE(SUM(amount), 0) AS total_revenue
FROM orders
WHERE status = 'paid';SUM with GROUP BY
Revenue per user:
SELECT user_id, SUM(amount) AS user_revenue
FROM orders
WHERE status = 'paid'
GROUP BY user_id;Revenue per status:
SELECT status, SUM(amount) AS revenue
FROM orders
GROUP BY status;SUM with expressions
You can sum expressions, not only columns.
Sum of a discounted amount, for example 10 percent off:
SELECT SUM(amount * 0.9) AS discounted_revenue
FROM orders
WHERE status = 'paid';Sum of orders per day:
SELECT
DATE(created_at) AS order_date,
SUM(amount) AS total_amount
FROM orders
WHERE status = 'paid'
GROUP BY DATE(created_at)
ORDER BY order_date;AVG
AVG calculates the average of numeric values.
Average order amount:
SELECT AVG(amount) AS avg_order_amount
FROM orders
WHERE status = 'paid';Average order amount per user:
SELECT user_id, AVG(amount) AS avg_order_amount
FROM orders
WHERE status = 'paid'
GROUP BY user_id;Average daily revenue:
SELECT
DATE(created_at) AS day,
AVG(amount) AS avg_order_amount
FROM orders
WHERE status = 'paid'
GROUP BY DATE(created_at)
ORDER BY day;
Like SUM, if there are no matching rows, AVG returns NULL.
Rule: AVG(column) ignores NULL values.
Only non-null values are included in the average.
Example:
- Values:
10, 20, NULL, 30 AVGuses only10, 20, 30, so the result is $(10 + 20 + 30) / 3 = 20$.
MIN and MAX
MIN returns the smallest value and MAX returns the largest.
First and last order dates:
SELECT
MIN(created_at) AS first_order,
MAX(created_at) AS last_order
FROM orders;Smallest and largest order amounts:
SELECT
MIN(amount) AS smallest_order,
MAX(amount) AS largest_order
FROM orders
WHERE status = 'paid';Per user:
SELECT
user_id,
MIN(amount) AS min_order_amount,
MAX(amount) AS max_order_amount
FROM orders
GROUP BY user_id;
MIN and MAX also ignore NULL values.
MIN and MAX with non-numeric columns
You can use them on dates and text.
Earliest and latest signup date:
SELECT
MIN(created_at) AS first_order,
MAX(created_at) AS last_order
FROM orders;Alphabetically first and last status:
SELECT
MIN(status) AS first_status,
MAX(status) AS last_status
FROM orders;This is not often useful for text, but it works.
Using Aggregate Functions with GROUP BY
Aggregate functions are often combined with GROUP BY. Every group produces one row.
General pattern:
SELECT
group_column_1,
group_column_2,
AGG_FUNC(column) AS some_value
FROM table
GROUP BY group_column_1, group_column_2;
Rule: Every column in SELECT that is not inside an aggregate function must appear in GROUP BY.
For example, revenue per day and status:
SELECT
DATE(created_at) AS day,
status,
SUM(amount) AS total_amount,
COUNT(*) AS order_count
FROM orders
GROUP BY DATE(created_at), status
ORDER BY day, status;Here:
DATE(created_at)andstatusare grouping columns.SUM(amount)andCOUNT(*)are aggregates.
If you tried to select amount directly, like:
SELECT DATE(created_at), amount, SUM(amount) FROM orders GROUP BY DATE(created_at);
Most databases would give an error, because amount is neither grouped nor aggregated.
Aggregate Functions with WHERE and HAVING
You can filter rows before aggregation with WHERE, and filter groups after aggregation with HAVING.
WHERE filters rows before aggregation
For example, only paid orders:
SELECT user_id, SUM(amount) AS paid_revenue
FROM orders
WHERE status = 'paid'
GROUP BY user_id;
The WHERE clause removes non-paid orders from the input.
HAVING filters groups after aggregation
For example, show only users whose total revenue is over 100:
SELECT user_id, SUM(amount) AS total_revenue
FROM orders
WHERE status = 'paid'
GROUP BY user_id
HAVING SUM(amount) > 100;
Here, HAVING uses SUM(amount), which is an aggregate result.
Filter days where there were at least 10 paid orders:
SELECT
DATE(created_at) AS day,
COUNT(*) AS orders_count
FROM orders
WHERE status = 'paid'
GROUP BY DATE(created_at)
HAVING COUNT(*) >= 10
ORDER BY day;Rule:
- Use
WHEREto filter individual rows before aggregates. - Use
HAVINGto filter whole groups after aggregates.
Combining Multiple Aggregates
You can use several aggregate functions in the same query.
Overall statistics:
SELECT
COUNT(*) AS total_orders,
SUM(amount) AS total_amount,
AVG(amount) AS avg_amount,
MIN(amount) AS min_amount,
MAX(amount) AS max_amount
FROM orders
WHERE status = 'paid';Per user:
SELECT
user_id,
COUNT(*) AS orders_count,
SUM(amount) AS total_spent,
AVG(amount) AS avg_order,
MIN(amount) AS smallest_order,
MAX(amount) AS largest_order
FROM orders
WHERE status = 'paid'
GROUP BY user_id;DISTINCT with Aggregate Functions
You can combine DISTINCT with some aggregates.
Count distinct users per status:
SELECT
status,
COUNT(DISTINCT user_id) AS unique_users
FROM orders
GROUP BY status;Average of distinct amounts:
SELECT AVG(DISTINCT amount) AS avg_unique_amount
FROM orders
WHERE status = 'paid';This ignores duplicate amounts before averaging.
Be careful: DISTINCT inside aggregates can be slower on large data, since the database must remove duplicates first.
Aggregate Functions and NULL Values
How aggregates treat NULL:
| Function | Handles NULL as |
|---|---|
COUNT(*) | Counts all rows, including rows with NULL columns |
COUNT(column) | Ignores rows where column is NULL |
SUM(column) | Ignores NULL values |
AVG(column) | Ignores NULL values |
MIN(column) | Ignores NULL values |
MAX(column) | Ignores NULL values |
Example table numbers:
| value |
|---|
| 10 |
| NULL |
| 20 |
Then:
COUNT(*)is3COUNT(value)is2SUM(value)is30AVG(value)is $30 / 2 = 15$MIN(value)is10MAX(value)is20
If a group has no non-null values, aggregates like SUM, AVG, MIN, MAX return NULL.
You can wrap them with COALESCE to replace NULL with a default:
SELECT
COALESCE(SUM(amount), 0) AS total_amount
FROM orders
WHERE status = 'non_existing_status';Practical Examples
Here are some realistic queries that use aggregate functions.
Daily revenue and order count
SELECT
DATE(created_at) AS day,
COUNT(*) AS orders_count,
SUM(amount) AS total_revenue,
AVG(amount) AS avg_order_amount
FROM orders
WHERE status = 'paid'
GROUP BY DATE(created_at)
ORDER BY day;Top 5 customers by total revenue
SELECT
user_id,
COUNT(*) AS orders_count,
SUM(amount) AS total_revenue
FROM orders
WHERE status = 'paid'
GROUP BY user_id
ORDER BY total_revenue DESC
LIMIT 5;Number of orders and average amount per status
SELECT
status,
COUNT(*) AS orders_count,
AVG(amount) AS avg_amount
FROM orders
GROUP BY status;Users with at least 3 orders
SELECT
user_id,
COUNT(*) AS orders_count
FROM orders
GROUP BY user_id
HAVING COUNT(*) >= 3;Percentage of revenue by status
Use aggregate functions in expressions:
SELECT
status,
SUM(amount) AS revenue,
ROUND(
SUM(amount) * 100.0 / SUM(SUM(amount)) OVER (),
2
) AS revenue_percent
FROM orders
GROUP BY status;Explanation, without going deep into window functions:
SUM(amount)is the revenue for each status.SUM(SUM(amount)) OVER ()is the total revenue across all statuses.- The division gives the share per status in percent.
Summary
Aggregate functions are central to reporting and analytics in SQL:
COUNTcounts rows or values.SUMadds values.AVGcomputes averages.MINandMAXfind smallest and largest values.- They work together with
GROUP BYto produce one result per group. WHEREfilters rows before aggregation,HAVINGfilters groups after aggregation.- Most aggregates ignore
NULL, exceptCOUNT(*), which counts every row.
You will combine these with GROUP BY, WHERE, HAVING, and joins to answer almost any statistical question about your data.
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!