10.8. ORDER BY
Table of Contents
Why `ORDER BY` Matters
When you query a database, the default order of rows is usually undefined. You might get rows in the order they were inserted, or in some internal order, but you must never rely on that.
If you care about the order of results, you must use ORDER BY.
Rule: If you need sorted results, always use ORDER BY.
Never assume the database returns rows in a meaningful order without it.
ORDER BY lets you sort your result set by one or more columns, in ascending or descending order, and even by expressions.
Basic `ORDER BY` Syntax
The general form is:
SELECT column1, column2, ...
FROM table_name
ORDER BY column_name [ASC | DESC];ASCmeans ascending order (smallest to largest, A to Z). It is the default.DESCmeans descending order (largest to smallest, Z to A).
Example with a simple users table:
users
+----+----------+-----------+--------+
| id | username | full_name | age |
+----+----------+-----------+--------+
| 1 | alice | Alice A | 30 |
| 2 | bob | Bob B | 25 |
| 3 | carol | Carol C | 35 |
+----+----------+-----------+--------+Sort by age ascending:
SELECT id, username, age
FROM users
ORDER BY age;Result:
+----+----------+-----+
| id | username | age |
+----+----------+-----+
| 2 | bob | 25 |
| 1 | alice | 30 |
| 3 | carol | 35 |
+----+----------+-----+Sort by age descending:
SELECT id, username, age
FROM users
ORDER BY age DESC;Sorting by Multiple Columns
You can sort by more than one column. This is useful when several rows share the same value in the first column.
Syntax:
SELECT ...
FROM table_name
ORDER BY column1 [ASC | DESC],
column2 [ASC | DESC],
...;Table example:
employees
+----+----------+----------+--------+
| id | name | dept | salary |
+----+----------+----------+--------+
| 1 | Alice | Sales | 50000 |
| 2 | Bob | Sales | 55000 |
| 3 | Carol | IT | 60000 |
| 4 | Dave | IT | 60000 |
| 5 | Eve | Sales | 45000 |
+----+----------+----------+--------+Sort by department ascending, then by salary descending inside each department:
SELECT name, dept, salary
FROM employees
ORDER BY dept ASC, salary DESC;Result:
+--------+--------+--------+
| name | dept | salary |
+--------+--------+--------+
| Carol | IT | 60000 |
| Dave | IT | 60000 |
| Bob | Sales | 55000 |
| Alice | Sales | 50000 |
| Eve | Sales | 45000 |
+--------+--------+--------+
dept controls the main grouping, salary DESC sorts within each department.
Another example, sort by salary ascending, then name ascending to stabilize the order:
SELECT name, dept, salary
FROM employees
ORDER BY salary ASC, name ASC;`ASC` vs `DESC` in Practice
You can mix ascending and descending in the same query.
Table example:
products
+----+----------+----------+--------+
| id | name | category | price |
+----+----------+----------+--------+
| 1 | Laptop | Tech | 900 |
| 2 | Mouse | Tech | 20 |
| 3 | Chair | Office | 70 |
| 4 | Desk | Office | 150 |
| 5 | Monitor | Tech | 200 |
+----+----------+----------+--------+Sort by category ascending, price descending:
SELECT name, category, price
FROM products
ORDER BY category ASC, price DESC;Result:
+---------+----------+-------+
| name | category | price |
+---------+----------+-------+
| Desk | Office | 150 |
| Chair | Office | 70 |
| Laptop | Tech | 900 |
| Monitor | Tech | 200 |
| Mouse | Tech | 20 |
+---------+----------+-------+
If you omit ASC or DESC, SQL uses ascending by default:
SELECT name, price
FROM products
ORDER BY price; -- same as ORDER BY price ASCSorting by Column Position
You can also sort by the position of a column in the SELECT list.
Syntax:
SELECT col1, col2, col3
FROM table_name
ORDER BY 2, 3 DESC;
Here, 2 means ordered by the second selected column, and 3 DESC means third selected column in descending order.
Example:
SELECT name, category, price
FROM products
ORDER BY 2, 3 DESC;
This orders by category (the second selected column), and then by price (the third) descending inside each category.
Recommendation: Sorting by column position works, but using column names is clearer and less error prone.
Use column positions only when you have a strong reason, such as quick ad hoc queries.
Sorting With Expressions
You are not limited to column names in ORDER BY. You can sort by expressions and calculated values.
Common examples:
- Sort by a computed discount price
ORDER BY price * (1 - discount_rate) - Sort by the length of a string
ORDER BY LENGTH(name) - Sort by a case expression
Example: Sorting by a Computed Column
Table:
orders
+----+----------+----------+--------+
| id | item | quantity | price |
+----+----------+----------+--------+
| 1 | Pen | 10 | 1.5 |
| 2 | Notebook | 3 | 4.0 |
| 3 | Bag | 1 | 25.0 |
+----+----------+----------+--------+Sort by total cost (quantity times price):
SELECT id, item, quantity, price, quantity * price AS total_cost
FROM orders
ORDER BY quantity * price DESC;Result:
+----+----------+----------+-------+------------+
| id | item | quantity | price | total_cost |
+----+----------+----------+-------+------------+
| 3 | Bag | 1 | 25.0 | 25.0 |
| 2 | Notebook | 3 | 4.0 | 12.0 |
| 1 | Pen | 10 | 1.5 | 15.0 |
+----+----------+----------+-------+------------+Note: The order of id 1 and 2 here will depend on the actual computed totals. Always check your math.
Example: Using the Alias in `ORDER BY`
Many databases let you use the alias defined in the SELECT list:
SELECT id, item, quantity * price AS total_cost
FROM orders
ORDER BY total_cost DESC;This is easier to read than repeating the expression.
Example: Sorting With `CASE`
Suppose you have priorities: "high", "medium", "low". You want "high" first, then "medium", then "low", even though alphabetically "high" comes before "low" and "medium".
tasks
+----+---------+----------+
| id | title | priority |
+----+---------+----------+
| 1 | Task A | low |
| 2 | Task B | high |
| 3 | Task C | medium |
+----+---------+----------+
Custom order with CASE:
SELECT id, title, priority
FROM tasks
ORDER BY
CASE priority
WHEN 'high' THEN 1
WHEN 'medium' THEN 2
WHEN 'low' THEN 3
ELSE 4
END;Result:
+----+---------+----------+
| id | title | priority |
+----+---------+----------+
| 2 | Task B | high |
| 3 | Task C | medium |
| 1 | Task A | low |
+----+---------+----------+This pattern is common when you need custom business ordering.
Sorting With `NULL` Values
When your data contains NULL, databases must decide where to place those rows in an ordered list.
By default:
- Many databases, such as PostgreSQL, sort
NULLvalues first in ascending order and last in descending order. - Others, such as some configurations of MySQL, may treat
NULLdifferently.
To control this, you can usually use NULLS FIRST or NULLS LAST in ORDER BY.
Table:
users
+----+----------+------+
| id | name | age |
+----+----------+------+
| 1 | Alice | 30 |
| 2 | Bob | NULL |
| 3 | Carol | 25 |
| 4 | Dave | NULL |
+----+----------+------+Ascending by age, with nulls last:
SELECT id, name, age
FROM users
ORDER BY age ASC NULLS LAST;Possible result:
+----+-------+------+
| id | name | age |
+----+-------+------+
| 3 | Carol | 25 |
| 1 | Alice | 30 |
| 2 | Bob | NULL |
| 4 | Dave | NULL |
+----+-------+------+Descending by age, with nulls first:
SELECT id, name, age
FROM users
ORDER BY age DESC NULLS FIRST;
Important: Handling NULL correctly is critical.
Always think about where rows with missing values should appear in sorted results, and use NULLS FIRST or NULLS LAST if needed.
If your database does not support NULLS FIRST / LAST, you can simulate it with expressions, for example:
ORDER BY (age IS NULL), age
Since (age IS NULL) is false (0) or true (1), non null ages come first.
`ORDER BY` With `LIMIT` (Top N Results)
ORDER BY becomes especially powerful when combined with LIMIT (or TOP in some SQL engines) to get only the first N rows.
Common patterns:
- Get the 10 most recent posts.
- Get the 5 highest paid employees.
- Get the cheapest 3 products.
Example table:
posts
+----+-----------------+---------------------+
| id | title | created_at |
+----+-----------------+---------------------+
| 1 | Hello World | 2023-01-01 10:00:00 |
| 2 | Second Post | 2023-01-02 09:00:00 |
| 3 | Another Post | 2023-01-03 12:00:00 |
| 4 | Newest Post | 2023-01-04 08:00:00 |
+----+-----------------+---------------------+Latest 2 posts:
SELECT id, title, created_at
FROM posts
ORDER BY created_at DESC
LIMIT 2;Result:
+----+-------------+---------------------+
| id | title | created_at |
+----+-------------+---------------------+
| 4 | Newest Post | 2023-01-04 08:00:00 |
| 3 | Another Post| 2023-01-03 12:00:00 |
+----+-------------+---------------------+Top 3 most expensive products:
SELECT name, price
FROM products
ORDER BY price DESC
LIMIT 3;This pattern is extremely common in backend development, for example when you display "Top 10" lists or recent activity.
Using `ORDER BY` With `GROUP BY` and Aggregates
When you use GROUP BY, you often want to sort by an aggregate value, such as COUNT, SUM, or AVG.
Table:
sales
+----+----------+--------+
| id | product | amount |
+----+----------+--------+
| 1 | Pen | 10 |
| 2 | Pen | 5 |
| 3 | Notebook | 7 |
| 4 | Bag | 20 |
| 5 | Notebook | 8 |
+----+----------+--------+Total sales per product, highest first:
SELECT product, SUM(amount) AS total_amount
FROM sales
GROUP BY product
ORDER BY total_amount DESC;Result:
+----------+--------------+
| product | total_amount |
+----------+--------------+
| Bag | 20 |
| Notebook | 15 |
| Pen | 15 |
+----------+--------------+
If there is a tie in total_amount, the order between those rows is undefined unless you add a secondary sort:
ORDER BY total_amount DESC, product ASC;Common Patterns and Examples
Here is a compact table of common sorting tasks and how to write them.
| Goal | Example ORDER BY clause |
|---|---|
| Alphabetical A to Z | ORDER BY name ASC |
| Alphabetical Z to A | ORDER BY name DESC |
| Lowest price first | ORDER BY price ASC |
| Highest price first | ORDER BY price DESC |
| Newest record first | ORDER BY created_at DESC |
| Oldest record first | ORDER BY created_at ASC |
| Sort by multiple fields | ORDER BY category ASC, price DESC |
| Custom priority order | ORDER BY CASE priority WHEN 'high' THEN 1 ... END |
| Shortest name first | ORDER BY LENGTH(name) ASC |
| Longest name first | ORDER BY LENGTH(name) DESC |
| Non null values first | ORDER BY (age IS NULL), age ASC |
| Nulls last, descending score | ORDER BY score DESC NULLS LAST |
| Top N by score | ORDER BY score DESC LIMIT 10 |
| Sort by aggregate (most orders) | ORDER BY COUNT(*) DESC with GROUP BY customer_id |
Summary
ORDER BYdefines the order of rows in your query results.- Without
ORDER BYthe order is not guaranteed, so never rely on it. - You can sort by:
- Single or multiple columns, each with
ASCorDESC. - Column positions from the
SELECTlist, although names are clearer. - Expressions and aliases, including calculations and
CASEexpressions. - Always think about how to handle
NULLvalues, and useNULLS FIRSTorNULLS LASTor equivalent patterns when necessary. ORDER BYbecomes very powerful in combination withLIMITand aggregate functions for top N queries and reports.
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!