6.4. Query Parameters
Table of Contents
Understanding Query Parameters
When you build web backends, query parameters are one of the most common ways that clients send extra information with a request. You will see them everywhere, for example when searching, filtering, sorting, or paginating data.
This chapter focuses on what query parameters are, how they differ from other types of parameters, and how to use them correctly, with many concrete examples.
What Are Query Parameters?
A query parameter is a key value pair that appears in the URL after a question mark ?.
Basic structure:
https://example.com/search?query=python&limit=10Breakdown:
https://example.comis the scheme and domain./searchis the path.?starts the query string.query=pythonis a query parameter.limit=10is another query parameter.&separates multiple query parameters.
In general, a URL with query parameters looks like this:
/path?key1=value1&key2=value2&key3=value3
Each key=value pair is one query parameter.
Rule: Query parameters always appear after ? in the URL and are separated by &.
Rule: Query parameters are not part of the path. They are optional and can appear in any order.
Query Parameters vs Path Parameters
You have already seen path parameters in routing. Path parameters are part of the path itself, for example:
/users/123
Here 123 might be a path parameter that identifies a specific user.
Query parameters are not part of the path, but are attached after ?:
/users?active=true&limit=20Conceptual difference
- Path parameters identify a specific resource or a specific location.
Example:/users/123usually means user with id123. - Query parameters modify or filter how a resource is returned.
Example:/users?active=truemeans: give me users, but only active ones.
You can combine both:
/users/123/orders?status=delivered&limit=10Here:
- Path part:
/users/123/orders - user id is
123 - Query part:
?status=delivered&limit=10 - status filter is
delivered - limit is
10items
A useful mental rule:
Rule: Use path parameters to say which resource.
Use query parameters to say how you want it.
Common Uses of Query Parameters
Query parameters are typically used for:
- Filtering
- Example:
/products?category=books&price_max=20- Returns products in category "books" with price less than or equal to 20.
- Sorting
- Example:
/products?sort=price_asc- Returns products sorted by price ascending.
- Pagination
- Example:
/products?page=2&page_size=50- Returns page 2 of products, 50 items per page.
- Searching
- Example:
/search?query=laptop&in_stock=true- Optional flags
- Example:
/users/123?include=orders,profileUsing query parameters for these things keeps your path clean and shows clearly that these are optional modifiers, not the main resource identifier.
Anatomy of a Query String
Consider this URL:
https://api.example.com/articles?author=alice&tag=python&tag=web&sort=recent&page=3Break it into a table:
| Part | Example | Meaning |
|---|---|---|
| Path | /articles | Main resource |
author | author=alice | Filter by author |
tag (1) | tag=python | One tag filter |
tag (2) | tag=web | Another tag filter |
sort | sort=recent | Sorting option |
page | page=3 | Pagination page |
Important details:
- A key can appear multiple times (
tag=python&tag=web). - Order of parameters usually does not matter.
- Keys and values are strings, and are URL encoded.
URL Encoding Basics
URLs can only safely include certain characters. Others must be encoded.
For example, a space is not allowed directly in the query. It is encoded as + or %20.
Examples:
| Original value | Encoded in URL |
|---|---|
python backend | python+backend |
fast api | fast+api |
C# | C%23 |
a&b | a%26b |
So a search query like:
/search?query=python backendactually looks like:
/search?query=python+backendYour web framework and HTTP libraries usually handle this encoding and decoding for you. When you read the query parameter in code, you get back the decoded value.
Required vs Optional Query Parameters
By default, query parameters are optional. A client can decide whether to send them or not.
For example, suppose you design this endpoint:
GET /products?category=booksThe client might call:
/products?category=books/products(no query parameters)
You need to decide what your backend will do when the parameter is missing:
- Use a default value.
- Return all data.
- Return an error.
Example: optional parameters with defaults
GET /products?category=books&limit=20You could define:
categoryis optional, default is "all categories".limitis optional, default is 10.
So:
/products?category=books&limit=20
returns 20 book products./products?category=books
uses defaultlimit=10./products
uses defaultcategory=all,limit=10.
You must document these defaults in your API description.
Example: required query parameters
Sometimes, you intentionally make a query parameter required, for example:
GET /search?query=pythonYou might decide:
queryis required.- If
queryis missing, return an error response.
So:
/search?query=pythonis valid./searchreturns a 400 Bad Request.
Multiple Values for the Same Parameter
Clients can send the same query parameter key multiple times. How your backend framework exposes this depends on the framework.
Example URL:
/articles?tag=python&tag=web&tag=backendPossible interpretations:
- The backend might treat
tagas a list of values:["python", "web", "backend"]. - Or if you only read the first value, you might only see
"python".
As an API designer, you should choose a clear style and document it. Some options:
- Allow repeated keys:
/articles?tag=python&tag=web- Allow comma separated values:
/articles?tag=python,web
Both are common. Your backend code must handle whichever style you choose.
Table of common patterns:
| Client URL style | Backend sees as |
|---|---|
?tag=python&tag=web | ["python", "web"] |
?tag=python,web | "python,web" then split it |
?tag[]=python&tag[]=web | ["python", "web"] |
You do not have to support every style. Pick one and be consistent.
Designing Query Parameters
When you design query parameters, think about clarity and predictability.
Naming conventions
Use clear, descriptive names:
page,page_sizeorlimit,offsetsort,order_byprice_min,price_maxcreated_after,created_beforeinclude,fields
Avoid cryptic names like p, s, or q2.
Boolean parameters
Boolean query parameters often appear as:
?active=true?active=false
Sometimes developers shorten this, for example:
?activeto meantrue- nothing to mean
false
That can be confusing. Prefer explicit values.
Sorting
Several patterns are common for sorting:
- Single parameter with pattern:
/users?sort=name_asc
/users?sort=name_desc
/users?sort=-name (minus sign for descending)- Separate field and direction:
/users?sort_by=name&sort_dir=ascChoose one style and apply it everywhere in your API.
Pagination
Pagination is nearly always done with query parameters. Common patterns:
| Pattern | Example | Meaning |
|---|---|---|
| page / page_size | ?page=2&page_size=50 | Page number and items per page |
| limit / offset | ?limit=50&offset=100 | Page size and offset from start |
| cursor based | ?cursor=abc123&limit=50 | Use a cursor token, not a numeric page index |
You do not need cursor based pagination for beginners. Page / page_size is simple and widely used.
Query Parameters and the HTTP Method
You can technically use query parameters with any HTTP method, for example:
GET /products?category=booksPOST /products?dry_run=trueDELETE /products/123?force=true
However, the most common use is with GET:
- In
GETrequests, the query parameters specify filters and options for reading data.
For example:
GET /users?country=US&active=true
In requests that modify data (POST, PUT, PATCH, DELETE), you usually put most of the input in the request body, and use query parameters only for control flags, such as:
POST /orders?send_email=trueHere:
- The order data is in the body (JSON or form).
- The
send_emailflag is in the query.
This separation keeps URLs readable and makes clear what is core data and what is optional behavior.
Query Parameters vs Request Body
For a beginner, it is useful to compare query parameters with request bodies.
| Feature | Query Parameters | Request Body |
|---|---|---|
| Location | In the URL after ? | In the HTTP message body |
| Common use | Filters, options, pagination | Main data for create/update |
| Typical methods | Mostly GET | POST, PUT, PATCH |
| Data format | Simple key value pairs (strings) | JSON, form data, XML, etc. |
| Size limit | Often limited by URL length | Usually can be larger |
Example:
GET /products?category=books&limit=10Here:
- No body is needed.
- Category and limit are query parameters.
Another example:
POST /products
Content-Type: application/json
{
"name": "Clean Code",
"category": "books",
"price": 25.00
}Here:
- The product data is in the body.
- You could still add query parameters as flags, such as
?notify_subscribers=true.
Examples of Query Parameter Usage
Simple filtering
GET /users?country=DEBehavior:
- Return users whose
countryis"DE".
Multiple filters
GET /users?country=DE&active=true&role=adminBehavior:
- Return users with all of:
country = "DE"active = truerole = "admin"
Optional search
GET /articles?query=python
GET /articlesBehavior:
- First request: filter by search query
"python". - Second request: no search filter, maybe return all articles.
Pagination example
GET /articles?page=3&page_size=20Backend logic, for example:
page_sizedefault is 20.- Starting index is:
$$\text{offset} = (\text{page} - 1) \times \text{page\_size}$$
So:
page = 3,page_size = 20offset = (3 - 1) × 20 = 40
The backend might run a query like:
- "Get 20 articles starting from index 40."
Formula: For page based pagination,
$$\text{offset} = (\text{page} - 1) \times \text{page\_size}$$
Sorting example
GET /products?sort=price_asc
GET /products?sort=-created_atBackend interpretation:
- First: order by
priceascending. - Second: order by
created_atdescending (minus sign indicates descending).
Multiple tags example
Option 1: repeated parameters:
GET /articles?tag=python&tag=backendOption 2: comma separated:
GET /articles?tag=python,backendBackend must convert these into a list internally, such as:
["python", "backend"]Handling Query Parameters in Code (Conceptually)
Different web frameworks and languages have different syntax, but the ideas are the same.
Almost always, you:
- Read the query parameters from the request.
- Validate them (type check, ranges, allowed values).
- Apply them to your logic (filters, pagination, sorting).
- Provide defaults when a parameter is missing.
Conceptual pseudocode:
def list_products(request):
category = request.query.get("category") # str or None
page = int(request.query.get("page", 1)) # default 1
page_size = int(request.query.get("page_size", 20)) # default 20
# Validate page_size
if page_size > 100:
page_size = 100 # or return an error
# Calculate offset
offset = (page - 1) * page_size
# Use these values to query the database
products = find_products(category=category, offset=offset, limit=page_size)
return productsYou do not need to know Python details here. The key steps apply in any backend language or framework.
Good Practices for Query Parameters
To finish, here are some practical guidelines.
Be consistent
Use the same parameter names and patterns across your whole API.
- If you use
pageandpage_sizein one place, do not usepandlimitin another. - If you use
sort=-fieldfor descending, use that everywhere.
Prefer simple types
Keep query parameters simple:
- Strings
- Numbers
- Booleans
Avoid complex JSON structures in the query string, such as:
?filter={"price":{"min":10,"max":50}}This is hard to read, hard to encode, and often better handled in the request body if you really need complex filters.
Validate everything
Do not blindly trust any query parameter:
- Check that numbers are within allowed ranges.
- Example:
page >= 1,1 <= page_size <= 100. - Check that sort fields are allowed.
- Example: only
name,price,created_atare valid. - Check that values are of the correct type.
If something is wrong, return a clear error response with a helpful message.
Document your parameters
For each endpoint, document:
- Which query parameters exist.
- Their types.
- Whether they are required or optional.
- Default values.
- Allowed ranges or values.
This will later be expressed more formally with tools like OpenAPI and Swagger, but the idea is the same.
You now know what query parameters are, how they differ from path parameters and request bodies, and how they are commonly used for filtering, sorting, searching, and pagination. In the next topics, you will see how to work with other request parts, such as request bodies and form data, in more detail.
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!