15.9. Rate Limiting
Table of Contents
Why Rate Limiting Matters
Rate limiting is a security and stability technique that controls how many requests a client can make to your backend in a given amount of time.
Think of your API as a small shop with a single cashier. If 1,000 people rush in at the same time, the shop cannot serve anyone properly. Rate limiting is like a doorman who lets people in at a controlled pace, and stops people who come back too many times too quickly.
Rate limiting helps you:
- Protect against brute force attacks on login endpoints
- Protect against API abuse or scraping
- Prevent accidental overload from buggy clients
- Keep your service stable and fair for all users
Important: Every public-facing backend should have some form of rate limiting on sensitive or expensive operations, such as login, password reset, and resource-intensive endpoints.
Core Concepts
What Are “Rates” And “Limits”?
A rate limit always has at least two parts:
- Who is limited
- How many requests they can make in what time window
Common examples:
| Who is limited | Limit Example | Meaning |
|---|---|---|
| IP address | 100 requests per 1 minute | Each IP can make 100 requests every 60 seconds |
| User account (user ID) | 10 login attempts per 15 mins | Each user can try to log in 10 times in 15 mins |
| API key | 1,000 API calls per hour | Each key can call the API 1,000 times per hour |
| Entire system (global) | 500 requests per second total | System will only process 500 RPS globally |
Time Windows
Common time windows:
- Per second
- Per minute
- Per hour
- Per day
You can combine windows, for example:
- 10 requests / second
- 1,000 requests / hour
- 50,000 requests / day
This prevents both short bursts and long-term abuse.
What To Limit On
Identifiers: How To Know “Who” To Limit
You need an identifier to know which client you are tracking.
Typical identifiers:
| Identifier | When to use | Pros | Cons |
|---|---|---|---|
| IP address | Unauthenticated or public endpoints | Easy to get, no login required | Shared IPs, NAT, VPNs, mobile networks |
| User ID | Authenticated users | Stable per user, fairer than IP | Needs authentication |
| API key | Public APIs, 3rd-party consumers | Directly tied to a consumer or application | Needs key management |
| Session ID | Web apps with cookies/sessions | Treat each session as separate client | Session rotation can complicate counts |
| Device ID | Mobile apps | Per-device control | Requires device ID logic |
In practice, you often combine identifiers, for example:
- Limit logins by IP + username
- Limit API usage by API key
- Extra safety limit by IP to block obvious abusers
Simple Rate Limiting Strategies
Fixed Window
Fixed window rate limiting is the simplest approach.
Example rule:
- Each IP can perform 100 requests per minute
You divide time into fixed windows, for example:
- 12:00:00 to 12:00:59
- 12:01:00 to 12:01:59
For each window you count how many requests each identifier has made. If they exceed the limit, you reject further requests until the next window.
How It Works
For each request:
- Compute window key, for example,
current_minute = floor(current_time / 60) - Identify client, for example, IP address
- Key in storage:
rate:ip:<ip>:<current_minute> - Increment counter
- If counter > limit, block request
Example With Redis (Conceptual)
Key: rate:ip:203.0.113.10:202408271230
Value: number of requests in that minute
Pseudocode:
def is_allowed(ip):
window = current_minute_string() # e.g. "202408271230"
key = f"rate:ip:{ip}:{window}"
count = redis.incr(key)
if count == 1:
redis.expire(key, 60) # key auto deletes after 60 seconds
return count <= 100
If is_allowed returns False, you respond with an error.
Pros And Cons
| Pros | Cons |
|---|---|
| Very simple conceptually | Windows reset suddenly at boundary |
| Easy to implement with Redis | Short bursts across boundary can slip by |
| Fast and cheap | Less fair close to window reset |
Boundary problem example:
- Limit: 100 requests / minute
- Client makes 100 requests at 12:00:59
- Then 100 requests at 12:01:01
- Total 200 requests in 2 seconds, but both windows are within allowed limits
Sliding Window
Sliding window methods make rate limiting smoother by considering a moving time window instead of strict 1-minute blocks.
Two common variants:
- Sliding window counter (approximate)
- Sliding window log (more precise, more storage)
Sliding Window Counter (Approximate)
You keep counters for current window and previous window, and compute a weighted sum.
Example: 100 requests per minute
- At time $t$, within minute $M$
- Get counter for minute $M$ and minute $M - 1$
- Compute how far into the current minute we are, for example 30 seconds in is 0.5
- Effective count is:
$$
\text{effective} = C_M + (1 - \text{progress}) \cdot C_{M-1}
$$
If effective <= 100, allow.
This smooths out the boundary but is still approximate.
Sliding windows help avoid sudden resets at time boundaries. They provide fairer limits under bursty traffic than fixed windows.
Sliding Window Log (Precise)
You store a timestamp for each request per client, often in a sorted set or list.
Then, for each request:
- Remove timestamps older than
now - window_size - Count remaining timestamps
- If count >= limit, block
- Else, record current timestamp and allow
Storage example in Redis, key per user like: rate:user:123 with scores as timestamps.
Pros:
- Very accurate
- True sliding window
Cons:
- More memory, especially for large user bases
- Slower than simple counters
For most backend APIs, fixed window or token bucket is enough. Sliding windows are useful when you need smoother behavior.
Token Bucket And Leaky Bucket
These are classic algorithms that control burstiness more precisely.
Token Bucket
Imagine each user has a bucket that holds “tokens.”
- The bucket has a maximum size, for example 100 tokens
- Tokens are added over time, for example 1 token every 0.6 seconds
- Each request consumes 1 token
- If the bucket is empty, the request is blocked (or delayed)
This allows short bursts, as long as the user has accumulated tokens, but forces the average rate to stay under a certain limit.
Parameters
Two key parameters:
- Bucket capacity $B$
- Refill rate $R$ tokens per second
Example:
- $B = 100$
- $R = 1$ token per second
Behaviour:
- If the user does nothing for 100 seconds, the bucket fills to 100 tokens.
- They can then make 100 requests at once (burst), consuming all tokens.
- After that, they can only make 1 request per second on average.
Simple Token Bucket Formula
We often store:
- Last refill time $t_{last}$
- Current tokens $T$
On each request at time $t$:
- Calculate time difference: $\Delta t = t - t_{last}$
- Add new tokens:
$$
T = \min(B, T + \Delta t \cdot R)
$$
- Set $t_{last} = t$
- If $T \ge 1$, then:
- Allow request
- Decrease $T$ by 1
- Else:
- Block request
Token Bucket Rule:
At each request, first refill tokens using
$$T = \min(B, T + \Delta t \cdot R)$$
then consume 1 token if available. If not, block the request.
This algorithm is widely used in networking and APIs because it is simple and works well.
Leaky Bucket
Leaky bucket is very similar, but you imagine a bucket that leaks water at a constant rate.
Two versions exist:
- Queue based: Requests are queued and processed at a constant rate.
- Token-bucket-like: Implementation is mathematically similar to token bucket.
In many practical API systems, a token bucket is sufficient and conceptually easier.
Where To Apply Rate Limiting
Which Endpoints Need It Most
You should not treat all endpoints the same. Some are more sensitive.
Common priorities:
- Authentication endpoints
/login,/register,/password-reset,/email/verify- Protect against brute force, password guessing, and abuse
- Heavy or expensive endpoints
- Reports, exports, complicated database queries
- Endpoints that trigger background jobs, emails, or third-party calls
- Public APIs or anonymous endpoints
/search,/public/data- Rate limit by IP to stop scraping or unintended DoS
- Write operations
POST /orders,POST /comments- Reduce abuse or spam and protect databases
Example design:
| Endpoint | Identifier | Limit |
|---|---|---|
POST /auth/login | IP + Username | 5 attempts / 10 minutes |
POST /auth/password-reset | IP + Email | 3 emails / hour |
GET /search | IP | 60 requests / minute |
POST /orders | User ID | 10 orders / minute |
GET /public/* | IP | 100 requests / minute |
HTTP Responses For Rate Limits
Status Codes
When you block a request due to rate limiting, you should use:
- 429 Too Many Requests
Example response body:
{
"detail": "Too Many Requests",
"message": "You have exceeded the limit of 100 requests per minute.",
"retry_after_seconds": 30
}Other codes like 403 or 503 are sometimes used, but 429 is the most appropriate and standard.
Useful Rate Limiting Headers
Many APIs expose rate limit information through HTTP headers.
Common headers:
| Header | Example value | Meaning |
|---|---|---|
X-RateLimit-Limit | 100 | Maximum requests allowed in the current window |
X-RateLimit-Remaining | 20 | Requests remaining in the current window |
X-RateLimit-Reset | 1693142400 | Unix timestamp when the limit resets |
Retry-After | 30 | Seconds until the client should retry |
Example response during normal use:
HTTP/1.1 200 OK
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 42
X-RateLimit-Reset: 1693142400
{"data": "..."}Example when blocked:
HTTP/1.1 429 Too Many Requests
Retry-After: 60
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1693142460
{"detail": "Too Many Requests"}These headers help clients behave politely and avoid hitting limits accidentally.
Implementation Approaches
Local In-Memory vs Distributed
You have to store counters or tokens somewhere.
1. In-Memory (Inside Each Application Instance)
- Use a dictionary or cache inside each application process.
Example (Python pseudo):
from collections import defaultdict
import time
REQUEST_COUNTS = defaultdict(list)
def is_allowed(ip, limit=100, window_seconds=60):
now = time.time()
window_start = now - window_seconds
# Remove old timestamps
timestamps = [t for t in REQUEST_COUNTS[ip] if t >= window_start]
REQUEST_COUNTS[ip] = timestamps
if len(timestamps) >= limit:
return False
REQUEST_COUNTS[ip].append(now)
return TruePros:
- Simple to implement
- No external dependency
Cons:
- Each server instance has its own memory
- Users can bypass limits by switching between instances
- Not suitable for multi-instance or distributed setups
2. Centralized Store (Redis, Database)
Use a shared store like Redis, which supports:
- Atomic increments
- Expiration
- Fast operations
This is the most common approach in production backends.
Simple fixed window with Redis:
def is_allowed(ip, limit=100, window_seconds=60):
window_id = int(time.time() // window_seconds)
key = f"rate:ip:{ip}:{window_id}"
count = redis.incr(key)
if count == 1:
redis.expire(key, window_seconds)
return count <= limitPros:
- Works across multiple instances
- Centralized view of usage
- Easy to tune
Cons:
- Extra infrastructure
- Need to handle Redis outages
Defensive Design Considerations
What Happens When The Rate Limiter Store Fails?
If Redis or your store is down, you must decide:
- Fail open: Allow all requests, ignore rate limiting
- Fail closed: Block all requests
In practice:
- For a small internal app, you might fail open.
- For a high security system, you may want to be stricter on login-related endpoints.
Sometimes you can:
- Use a backup in-memory limiter if Redis fails, to at least protect your system partially.
Trusted vs Untrusted Paths
You may want to:
- Apply strict limits on public internet traffic
- Relax limits for internal services inside your private network
- Use different limits for premium customers vs free-tier users
Rate Limiting And Security
Brute Force Protection
Brute force attacks try many passwords or tokens until they guess correctly.
Rate limiting is a strong defense when combined with:
- Proper password hashing
- Account lockouts or step-up challenges (captcha, email verification)
Example login policy:
- 5 failed attempts per IP per 10 minutes
- 10 failed attempts per username per hour
- If exceeded, require captcha or temporary lockout
This makes large-scale guessing attacks very slow or impractical.
Protection Against API Abuse
Public APIs are attractive targets for:
- Data scraping
- DDoS-like abuse
- Uncontrolled bots
Rate limiting per API key, user, and/or IP helps:
- Keep your infrastructure safe
- Enforce usage plans (for example, free vs paid tiers)
Fairness And Strategy
Multiple Limits Per Client
A realistic system rarely uses only one limit. You can combine several:
Example for a public API:
- Per IP: 100 requests per minute
- Per user account: 1,000 requests per hour
- Per API key: 10,000 requests per day
The idea is:
- IP limit: Blocks obvious abusive IPs
- User limit: Ensures fairness between users
- API key limit: Enforces business usage plans
If any of these is exceeded, the request is blocked.
Soft vs Hard Limits
- Hard limit: The user is immediately blocked when the limit is reached.
- Soft limit: After passing a soft limit, you may:
- Degrade service quality
- Add delays
- Show warnings
Example:
- Up to 100 requests / minute, full speed
- After 100, slow down responses or introduce artificial delay
- After 200, start returning 429
Practical Examples
Example: Login Rate Limiting With IP And Username
Goal: Stop brute force attacks on login.
Rules:
- Max 5 failed logins per IP per 10 minutes
- Max 10 failed logins per username per hour
Pseudocode:
def can_attempt_login(ip, username):
if not is_ip_allowed(ip, limit=5, window=600):
return False, "Too many attempts from this IP."
if not is_username_allowed(username, limit=10, window=3600):
return False, "Too many attempts for this account."
return True, None
def on_login_attempt(ip, username, password):
allowed, reason = can_attempt_login(ip, username)
if not allowed:
return error_429(reason)
if authenticate(username, password):
reset_fail_counters(ip, username) # optional
return success()
else:
increment_fail_counters(ip, username)
return error_invalid_credentials()This combines security (against attackers) and usability (legitimate users still have several chances).
Example: Public Search Endpoint With Token Bucket
Goal: Allow bursts but control average rate.
Rule:
- Per IP, allow average 10 requests / second, burst up to 20.
Parameters:
- Bucket capacity $B = 20$
- Refill rate $R = 10$ tokens per second
Behavior:
- If idle for a while, bucket fills to 20 tokens.
- User can then make up to 20 fast requests.
- After that, they must keep average usage around 10 per second.
This avoids constantly hitting 429 during short bursts but still protects your system from sustained floods.
Designing Reasonable Limits
How To Choose Numbers
Some basic guiding questions:
- How expensive is each request for your backend?
- Heavy database or CPU work requires stricter limits.
- How quickly should a normal user be able to use the feature?
- For UI actions, users rarely click more than a few times per second.
- Are you dealing with humans or automated systems?
- Human users: 1 to 10 requests / second is usually enough
- Machine clients: may need higher, but you can still cap them
- Are there business constraints, such as pricing tiers?
- Free tier: lower limits
- Paid tiers: higher limits
Example guidelines:
| Use case | Reasonable starting limit |
|---|---|
| Web page views per IP | 60 requests / minute |
| Login attempts per IP | 5 attempts / 10 minutes |
| Search API per API key | 10 requests / second, 1,000 / hour |
| File upload endpoint | 10 uploads / hour per user |
| Password reset emails | 3 emails / hour per email address |
These are just starting points. You must monitor usage and adjust.
Summary
Rate limiting is a key part of backend security and stability. The main ideas:
- Decide who you are limiting, using identifiers like IP, user ID, API key, or combinations.
- Choose a rate limiting algorithm:
- Fixed window for simplicity
- Sliding window or logs for fairness
- Token bucket to allow bursts with controlled averages
- Apply strict limits to sensitive endpoints, especially authentication and expensive operations.
- Use HTTP 429 and helpful headers like
X-RateLimit-*andRetry-After. - Implement the limiter using in-memory storage for simple apps, or Redis / a database for distributed systems.
- Combine multiple limits per user, IP, and API key to balance security, fairness, and user experience.
With well-designed rate limiting, you significantly reduce the risk of brute force attacks and overload, and you keep your backend more reliable for everyone.
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!