7.17. Sorting
Table of Contents
Why Sorting Matters in REST APIs
Sorting lets API clients control the order of returned data. Instead of always getting data in the order stored in the database, clients can ask for:
- Newest items first
- Alphabetical order
- Highest rated items first
- Custom business order
Good sorting support makes your API more flexible and reduces the need for clients to download data and sort it themselves.
In this chapter we focus on how to design and implement sorting in REST APIs, not on database-specific details or performance topics, which are covered elsewhere.
Common Sorting Requirements
Different APIs and clients often need similar sorting behaviors.
Examples:
- A product list:
- Sort by price ascending or descending
- Sort by popularity
- Sort by newest first
- A blog:
- Sort posts by publish date
- Sort by title alphabetically
- A user list:
- Sort by name
- Sort by creation date
- Sort by last login
A typical requirement is:
- Allow sorting by certain fields only
- Support ascending and descending order
- Support stable, predictable sorting
- Sometimes support sorting by multiple fields
Passing Sorting in Query Parameters
Sorting is part of how you want results, not what you want. So it belongs in query parameters, not in the URL path or request body for simple GET list endpoints.
Example endpoint:
GET /products?sort=price
GET /products?sort=-price
GET /products?sort=price,-rating
You will see several common conventions for the sort query parameter.
Sorting Conventions
1. Single field, separate direction parameter
You provide one parameter for field, one for direction.
GET /users?sort_by=name&order=asc
GET /users?sort_by=created_at&order=descThis is easy to understand but can be less compact when you add multiple fields.
Pros
- Very explicit
- Easy for beginners
Cons
- Handling multiple sort fields becomes clumsy:
sort_by=name,created_at&order=asc,descis harder to parse and use
2. Single `sort` parameter, plus-minus convention
You use one parameter, and a minus sign indicates descending order.
GET /users?sort=name # name ascending
GET /users?sort=-name # name descending
GET /users?sort=age,-name # age ascending, then name descendingThis is used by many APIs, for example JSON:API.
Pros
- Compact, powerful
- Natural way to support multiple fields
- Easy to add more sort options in the future
Cons
- Needs documentation, the minus sign is not obvious by itself
- Some API clients or tools might not like punctuation, but usually this is fine
3. Verbose direction syntax
You include both field and direction explicitly in one parameter.
Examples:
GET /users?sort=name:asc
GET /users?sort=name:desc
GET /users?sort=age:asc,name:descor even:
GET /users?sort=+name,-created_atPros
- Very explicit
- Direction is always clear
Cons
- Slightly more complex to parse on the backend
- More verbose to write manually
Supporting Multiple Sort Fields
Sometimes you need to sort by more than one field to get predictable ordering.
Example: You want users ordered by age, and if two users have the same age, order them by name.
In SQL you might write:
ORDER BY age ASC, name ASC;In your API you might express it as:
GET /users?sort=age,nameOr with directions:
GET /users?sort=age,-nameIn this example:
- Primary sort:
ageascending - Secondary sort:
namedescending
The backend should apply these in order.
Important rule: Sorting by multiple fields should always be deterministic.
If you allow sorting by one field only, consider adding a hidden tiebreaker like the primary key:
ORDER BY given_field, id
This avoids unstable result order when data changes between requests.
Safe and Allowed Sort Fields
Never allow clients to sort by any arbitrary string they pass in. This is dangerous:
- It can lead to SQL injection if you build queries incorrectly
- It can leak internal field names or structure
- It may allow very expensive sorts on large text fields
Instead, always define a whitelist of allowed sort fields.
Example strategy in pseudocode:
ALLOWED_SORT_FIELDS = {
"name": "users.name",
"age": "users.age",
"created_at": "users.created_at",
}Workflow:
- Parse the
sortquery parameter. - For each requested sort field:
- Remove any leading
-. - Check if the field is in
ALLOWED_SORT_FIELDS. - If not, return a 400 Bad Request with a helpful error message.
- Build your ORDER BY clause only from allowed, known fields.
Rule: Never put user input directly into an ORDER BY clause.
Always map client-visible sort names to internal, hardcoded column names or expressions.
Handling Invalid Sorting Requests
When clients send invalid sorting options, your API should respond clearly.
Common invalid cases:
- Unknown sort field
- Wrong format
- Conflicting parameters such as using both
sortandorder_byat once
A good approach is to return 400 Bad Request with a structured error response.
Example response:
{
"detail": {
"error": "invalid_sort",
"message": "Cannot sort by 'height'. Allowed fields: name, age, created_at.",
"field": "sort"
}
}This is easier to debug than silently ignoring bad sort parameters.
Sorting and Default Order
You should define a default sort order for each list endpoint. This default is used when the client does not specify sorting.
Examples:
GET /users
Default: newest users first
Implementation:ORDER BY created_at DESCGET /products
Default: alphabetically by name
Implementation:ORDER BY name ASC
You have two main choices when the client sends sort:
- Override the default completely with the requested sorting.
- Append the default as a tiebreaker.
For example, if the client asks:
GET /products?sort=priceYou can:
- Use
ORDER BY price ASConly. - Or add default tiebreaker:
ORDER BY price ASC, id ASC.
Appending a tiebreaker like primary key is usually helpful, but you should not override the client’s intent about which field is primary.
Sorting and Pagination
Sorting and pagination are tightly connected. If you change sort order, page 1 will show different items.
Key points:
- Always apply sorting before pagination in your implementation.
- Document that changing sorting results in different pages.
- If clients use cursor-based pagination (covered in pagination chapter), sorting affects how cursors are built and interpreted.
Example workflow for a typical page-number pagination:
- Parse
sortparameter, decide sort fields and directions. - Apply
ORDER BYto the query. - Apply
LIMITandOFFSET(or equivalent).
In SQL terms:
SELECT *
FROM products
ORDER BY price ASC, id ASC
LIMIT 20 OFFSET 40; -- page 3 of size 20
If a client changes sort from price to name, the same page and page size will show a completely different subset of products.
You should document:
- Which fields are sortable
- Default sort
- How sort interacts with pagination
Examples of Sorting in REST APIs
Example 1: Simple user listing
Endpoint:
GET /usersSupported sort fields:
namecreated_atlast_login
Client examples:
GET /users
Meaning: default sort, for example created_at descending.
GET /users?sort=nameMeaning: order by name ascending.
GET /users?sort=-last_loginMeaning: most recently logged in first.
Response (sorted by name):
{
"items": [
{"id": 3, "name": "Alice", "created_at": "2024-01-10T10:00:00Z"},
{"id": 5, "name": "Bob", "created_at": "2024-01-12T12:30:00Z"},
{"id": 1, "name": "Charlie", "created_at": "2023-12-20T09:15:00Z"}
]
}Example 2: Products with combined sort and pagination
Endpoint:
GET /productsQuery:
GET /products?sort=price,-rating&page=1&page_size=3Assume the data:
| id | name | price | rating |
|---|---|---|---|
| 1 | A | 10 | 4.5 |
| 2 | B | 10 | 3.0 |
| 3 | C | 5 | 5.0 |
| 4 | D | 20 | 4.0 |
| 5 | E | 5 | 4.0 |
Sort: price ascending, then rating descending.
Sorted order:
C(price 5, rating 5.0)E(price 5, rating 4.0)A(price 10, rating 4.5)B(price 10, rating 3.0)D(price 20, rating 4.0)
For page=1&page_size=3, the API returns the first 3 in that order.
Response:
{
"items": [
{"id": 3, "name": "C", "price": 5, "rating": 5.0},
{"id": 5, "name": "E", "price": 5, "rating": 4.0},
{"id": 1, "name": "A", "price": 10, "rating": 4.5}
],
"page": 1,
"page_size": 3,
"total": 5
}Sorting and Filtering Together
Sorting is often used together with filtering (covered in another chapter). The typical order in implementation:
- Apply filters (where conditions).
- Apply sorting (order by).
- Apply pagination.
Example request:
GET /products?category=books&min_price=10&sort=-created_atMeaning:
- Only show products in category "books".
- Only show products with price >= 10.
- Newest products first.
The API might translate that to something like:
SELECT *
FROM products
WHERE category = 'books'
AND price >= 10
ORDER BY created_at DESC, id DESC
LIMIT 20;Note how sorting comes after filtering in the SQL query.
Sorting Best Practices
To make your API sorting support robust and user friendly, follow these guidelines.
Sorting best practice checklist
- Use a single query parameter for sorting, such as
sort. - Support both ascending and descending order.
- Use a consistent convention, for example:
sort=fieldfor ascending,sort=-fieldfor descending.- Always whitelist allowed sort fields.
- Handle invalid sort values with clear 400 Bad Request responses.
- Document:
- List of sortable fields.
- Default sort order.
- How to sort descending.
- How to sort by multiple fields.
- Apply sorting before pagination and after filtering.
- Add a stable tiebreaker such as primary key in your actual query, so the order is deterministic.
If you follow these rules, clients can predictably control data order and your API remains safe and maintainable.
Summary
In REST APIs, sorting is controlled through query parameters and usually uses a dedicated parameter such as sort. You should:
- Choose and document a clear sorting convention.
- Limit sorting to known, safe fields.
- Provide useful defaults.
- Integrate sorting correctly with filtering and pagination.
This makes your API flexible to client needs without sacrificing security or clarity.
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!