7.16. Filtering
Table of Contents
Why Filtering Matters in REST APIs
In most real applications, clients rarely want all data. They usually want a subset that matches some criteria. For example:
- All users who live in "London"
- Products cheaper than $50
- Orders created this week
- Tasks that are "completed"
This process of narrowing results based on criteria is filtering.
Filtering is usually done using query parameters in REST APIs, and it directly affects:
- Performance (fetch only what you need)
- Usability (clients can build flexible UIs)
- Network usage (smaller responses)
In this chapter we focus on how to design and use filtering in REST APIs, not on implementing it in any specific framework.
Basic Filtering with Query Parameters
The most common way to filter is with query parameters.
Imagine an endpoint:
GET /productsWithout any parameters, it might return all products. To filter, we add query parameters:
GET /products?category=books
GET /products?in_stock=true
GET /products?min_price=10&max_price=50
Here, category, in_stock, min_price, and max_price are filter parameters.
A typical pattern looks like this:
| Purpose | Example URL |
|---|---|
| Equality filter | /users?country=US |
| Multiple filters | /users?country=US&status=active |
| Range filter | /products?min_price=10&max_price=100 |
| Boolean filter | /tasks?completed=true |
| Date-based filter | /orders?created_after=2024-01-01 |
You can combine multiple filters. For example:
GET /products?category=clothing&min_price=20&max_price=100&in_stock=true
The server interprets this as something like:
"Give me clothing products that cost between 20 and 100, and are in stock."
Common Filtering Patterns
There is no single universal standard for filter names, but there are some very common patterns. Choosing and documenting consistent patterns makes your API easy to use.
Equality Filters
Equality filters check if a field equals some value.
Examples:
GET /users?country=DE
GET /tasks?status=completed
GET /orders?payment_method=credit_cardThe server might translate:
SELECT * FROM users WHERE country = 'DE';Range Filters
Ranges are useful for numbers, dates, and times.
Common naming patterns:
| Type | Pattern example |
|---|---|
| Price | min_price, max_price |
| Date | created_before, created_after |
| Date short | from, to (but can be ambiguous) |
| Count | min_items, max_items |
Example:
GET /orders?created_after=2024-01-01&created_before=2024-12-31
GET /products?min_price=5&max_price=20Server side might do:
SELECT * FROM orders
WHERE created_at >= '2024-01-01'
AND created_at <= '2024-12-31';Boolean Filters
Booleans can be sent as "true" / "false" or "1" / "0".
Examples:
GET /products?in_stock=true
GET /users?email_verified=true
GET /tasks?completed=falseYou should document what values you accept. Many APIs accept:
true,false1,0- Sometimes
yes,no(but this is less common)
Multiple Values for a Single Field
Sometimes you want to filter by several values for one field. For example: all users in "US" or "CA".
Common patterns:
- Repeat the parameter
GET /users?country=US&country=CA- Comma separated values
GET /users?country=US,CA- Array-like syntax (some frameworks like this)
GET /users?country[]=US&country[]=CAThe server usually interprets this as:
SELECT * FROM users WHERE country IN ('US', 'CA');You should choose one style and be consistent in your API. Repeated parameters and comma separated are both very common.
Text Search as a Filter
Simple search can be treated as a filter too.
Examples:
GET /products?search=laptop
GET /users?q=john
Here search or q is used to look into fields like name, description, etc.
Typical behaviors:
- Search in name and description
- Case insensitive
- Partial matches
Advanced Filtering: Operators in Parameters
Basic equality and ranges are often enough, but sometimes you need more powerful filtering. There are several common strategies to express operators like "less than", "greater than", "not equal".
Operator Suffixes in Parameter Names
You can encode operators in parameter names.
Examples:
GET /products?price_lt=100 # price < 100
GET /products?price_lte=100 # price <= 100
GET /products?price_gt=10 # price > 10
GET /products?price_gte=10 # price >= 10
GET /users?age_ne=18 # age != 18
Here the suffix _lt, _lte, _gt, _gte, _ne specifies the operator.
This is easy to parse and easy to document.
Operator Functions in Values
Another approach is using an operator function in the value, used by some APIs and ORMs conceptually:
GET /products?price=lt:100
GET /products?price=gt:10
GET /users?age=ne:18
GET /events?date=between:2024-01-01,2024-01-31This is more flexible but more complex to parse. For beginners, suffixes in names are usually easier.
Filter Objects (More Advanced Pattern)
Some APIs accept a single filter parameter with a JSON object, usually on POST for complex queries, or encoded as a string. This is more advanced and less "pure" REST, so we just show an idea:
GET /products?filter={"price":{"gt":10,"lt":100},"category":"books"}The client must URL encode the JSON. This gives a lot of power but adds complexity.
For a beginner friendly REST API, simple query parameters are usually enough.
Combining Filtering with Pagination, Sorting, and Searching
Filtering rarely lives alone. Clients usually want:
- Filtered results
- In a specific order
- Returned page by page
This means filtering, pagination, sorting, and searching are used together.
Example endpoint:
GET /products?category=books&min_price=10&max_price=50&sort=price_asc&page=2&page_size=20&search=pythonBreaking this down:
| Part | Purpose |
|---|---|
category=books | Filter by category |
min_price=10 | Minimum price |
max_price=50 | Maximum price |
search=python | Full text search term |
sort=price_asc | Sorting by price ascending |
page=2 | Get second page |
page_size=20 | 20 items per page |
On the server you usually:
- Start with the base query, for example:
SELECT * FROM products - Apply filters based on query parameters
- Apply sorting
- Apply pagination
Always apply filtering before pagination.
If you paginate first and then filter, the pages will be inconsistent and results will be confusing.
Designing Filterable Endpoints
Good filtering starts with good design choices.
Decide What Fields Are Filterable
Not every field must be filterable. Exposing filters for every small field can:
- Make your API harder to understand
- Make certain database queries slow
- Increase the risk of complex, slow requests
Instead, choose filters that are:
- Frequently needed by clients
- Indexed in the database when necessary
- Clear and meaningful
Examples of common filterable fields:
- Users:
country,status,created_after,created_before - Products:
category,min_price,max_price,in_stock,brand - Orders:
status,user_id,created_after,created_before
Keep Filter Names Human Friendly
Good filter parameter names:
- Are descriptive:
min_price,created_before - Use a consistent style, for example
snake_case - Do not expose internal database column names if they are confusing
For instance, if your database column is is_active, it is fine to expose it as active in the API.
Do Not Use Request Body for GET Filters
Many beginners try to send a complex JSON body for filters on a GET request. Most HTTP clients and proxies do not treat bodies in GET requests in a standard way.
The common practice:
- Use query parameters for filtering on
GET - Use request body for filters only if you use
POST /searchor similar endpoints for complex search
Examples of Filtering in Different Domains
To make this concrete, here are a few mini API designs with filters.
Example 1: Users API
Base endpoint:
GET /usersSupported filters:
| Parameter | Type | Description |
|---|---|---|
country | string | Only users from this country |
status | string | active, inactive, banned |
email_verified | boolean | Filter by email verification |
created_after | date | Registered after this date |
created_before | date | Registered before this date |
age_min | integer | Minimum age |
age_max | integer | Maximum age |
Example requests:
GET /users?country=US&status=active
GET /users?email_verified=true&created_after=2024-01-01
GET /users?age_min=18&age_max=30&country=DE
GET /users?country=US,CA&status=active # multiple countriesExample 2: Orders API
Base endpoint:
GET /ordersSupported filters:
| Parameter | Description |
|---|---|
user_id | Orders for a specific user |
status | pending, paid, shipped, cancelled |
created_after | Orders created after this date |
created_before | Orders created before this date |
min_total | Minimum total price |
max_total | Maximum total price |
Example requests:
GET /orders?user_id=123&status=paid
GET /orders?status=shipped&created_after=2024-06-01
GET /orders?min_total=50&max_total=200
GET /orders?user_id=123&status=pending,paidExample 3: Blog Posts API
Base endpoint:
GET /postsSupported filters:
| Parameter | Description |
|---|---|
author_id | Posts by this author |
tag | Posts that contain this tag |
published | Only published posts |
published_after | Published after this date |
q | Search query in title or content |
Example requests:
GET /posts?author_id=42&published=true
GET /posts?tag=python&published=true
GET /posts?q=fastapi&published=true
GET /posts?tag=python&tag=backend&published=true # multiple tagsValidation and Error Handling for Filters
Filters are just input to your API, so they must be validated.
Type Validation
Make sure filter values have the right types:
- Integers for
min_price,age_min,page, etc. - Booleans for
in_stock,email_verified - Dates in a clear format like ISO 8601 (
YYYY-MM-DDor with time)
If a client sends:
GET /products?min_price=abcThe server should not crash. Instead, it should respond with a 4xx error and a clear message.
Typical response:
{
"detail": "Invalid value for 'min_price'. Expected a number."
}Allowed Values
Some filters should accept only specific values.
For example:
GET /orders?status=not_a_real_status
Here status might be limited to: pending, paid, shipped, cancelled.
You should:
- Validate that
statusis one of the allowed values - Return a helpful error message if it is not
Business Rules
Some filter combinations might not make sense. For example:
age_mingreater thanage_maxmin_pricegreater thanmax_pricecreated_beforeearlier thancreated_after
You can check these and respond with a 400 Bad Request and a clear explanation.
Filters must never cause server errors like 500 just because the client sent wrong input.
Always validate and return a 4xx error with a clear message when filters are invalid.
Performance Considerations for Filtering
Filtering affects how your database queries are constructed. Poorly designed filters can make your API slow.
Key ideas:
Use Indexes for Common Filters
If you frequently filter by user_id, status, or created_at, it is common to add indexes on these columns in your database. This helps queries run much faster.
You do not need to know how to create indexes here, but remember:
- Choose filters that can be supported by database indexes
- Avoid building extremely flexible filter systems that produce slow queries
Avoid Very Complex Filter Grammars
A filter like this:
GET /products?filter=(price>10 AND price<50) OR (category='books' AND in_stock=true)is very flexible, but hard to implement, hard to validate, and may lead to slow queries.
For most simple backend projects, clear, separate filter parameters are better.
Return Paginated Results
Filtering can still return thousands of rows. Always combine it with pagination, which is covered in a separate chapter.
Consistency and Documentation
Filtering is only useful if clients know how to use it.
To make your filtering design successful:
- Keep it consistent across endpoints
- If you use
min_price/max_priceon/products, use similar names likeage_min/age_maxor keep the pattern consistent. - If you accept multiple values with commas, do that on every endpoint, not just some.
- Document all filters clearly
For each endpoint:
- List all supported filter parameters
- Describe their types
- Show allowed values if they are limited
- Provide examples
Example documentation snippet for /orders:
| Parameter | Type | Description | Example |
|------------------|----------|--------------------------------------------------|-------------------------------------|
| user_id | integer | Only orders placed by this user | /orders?user_id=123 |
| status | string | pending, paid, shipped, cancelled | /orders?status=paid,shipped |
| created_after | date | ISO 8601 date, only orders created after this | /orders?created_after=2024-01-01 |
| created_before | date | ISO 8601 date, only orders created before this | /orders?created_before=2024-12-31|
| min_total | number | Minimum order total | /orders?min_total=50 |
| max_total | number | Maximum order total | /orders?max_total=200 |
- Provide example requests
Real URLs with filters help clients understand how to combine parameters.
Putting It All Together: A Complete Example
Consider a simple Task Management API with this endpoint:
GET /tasksYou decide to support these filters:
| Parameter | Type | Description |
|---|---|---|
status | string | pending, in_progress, completed |
priority | integer | Task priority from 1 to 5 |
priority_min | integer | Minimum priority |
priority_max | integer | Maximum priority |
assigned_to | integer | User id that owns the task |
due_before | date | Tasks due before this date |
due_after | date | Tasks due after this date |
search | string | Search term in title or description |
You also support:
- Pagination:
page,page_size - Sorting:
sortwith values likedue_date_asc,due_date_desc
Some example requests:
- All completed tasks for user 10, sorted by due date ascending, first page:
GET /tasks?status=completed&assigned_to=10&sort=due_date_asc&page=1&page_size=20- High priority tasks (priority 4 or 5), not completed:
GET /tasks?priority_min=4&status=pending,in_progress- Tasks due this week for user 5:
GET /tasks?assigned_to=5&due_after=2024-09-01&due_before=2024-09-07- Tasks that mention "backend" in title or description:
GET /tasks?search=backendOn the server side, you would:
- Start from
SELECT * FROM tasks - Check which query parameters are present
- Add
WHEREconditions for each filter - Add
ORDER BYbased onsort - Apply
LIMITandOFFSETfor pagination
You will learn more about the SQL and implementation details in later chapters. In this chapter, the main idea is: designing clear, consistent, and useful filters using query parameters.
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!