18.6. Password Reset Emails
Table of Contents
Why Password Reset Emails Matter
Password reset emails are a critical part of almost every web application. They sit at the intersection of user experience and security. When a user forgets a password, this is usually the only safe way to let them regain access.
A good password reset flow must:
- Be simple for the user.
- Be very hard to abuse.
- Protect both the user account and your system from attackers.
In this chapter you will focus specifically on the email part of a password reset, not the entire authentication system. You will connect what you already know about authentication, tokens, and sending emails, and see how to design a secure and reliable reset email flow.
Core idea: A password reset email is a temporary, one-time way to prove identity. It must be treated as carefully as login and password storage.
Typical Password Reset Flow
Before you design the email content or send anything, you need to understand the ideal flow at a high level. Most modern applications follow a similar pattern:
- User requests a reset
- User goes to "Forgot password" page.
- Enters their email address.
- Server handles the request
- Looks up the user by email.
- If user exists:
- Creates a secure, random reset token.
- Stores it with an expiration time.
- Sends a password reset email containing a link with that token.
- If user does not exist:
- Responds as if everything is fine, but does not reveal that the email is unknown.
- User receives the email
- Opens the email.
- Clicks the reset link.
- User sets a new password
- The link opens a reset page on your application.
- Backend verifies the token.
- If valid and not expired, user can set a new password.
- Token is invalidated after use.
- Confirmation
- Optionally, send a "your password was changed" notification email.
In this chapter, your focus is mainly on step 2 (sending the reset email) and step 3 (what the email should contain and how to use it).
Designing the Reset Email Content
The content of a password reset email must be:
- Clear to non-technical users.
- Difficult to misuse.
- Helpful for security if something suspicious is going on.
Essential elements
A good password reset email typically contains:
- Clear subject line
Examples:
- "Reset your password"
- "Password reset request"
- "Instructions to reset your password"
Avoid subject lines that are vague or that look like spam.
- Greeting
If you know the user name, use it:
- "Hi Alice,"
- "Hello John Doe,"
If you do not, a generic greeting is fine:
- "Hello,"
- "Hi there,"
- Short explanation
Explain why the user is receiving the email:
- "We received a request to reset the password for your account associated with this email address."
- The reset action (call to action)
This is usually a button or a link:
- "Click the button below to reset your password:"
- A visible URL for backup, in case buttons fail.
- Expiration information
Tell the user that the link will expire:
- "This link will expire in 30 minutes."
- "For your security, this password reset link is valid for 1 hour."
- What to do if they did not request it
Very important for security awareness:
- "If you did not request a password reset, you can safely ignore this email. Your password will not be changed."
- Support information
Optional but useful:
- "If you are having trouble, contact us at support@example.com."
Example plaintext email
Here is a simple plaintext password reset email:
Subject: Reset your password
Hi {{user_name}},
We received a request to reset the password for your account at {{app_name}}.
To reset your password, click the link below:
{{reset_link}}
For your security, this link will expire in 30 minutes and can be used only once.
If you did not request a password reset, you can safely ignore this email.
Your password will not be changed.
Best regards,
The {{app_name}} TeamExample HTML email with a button
<!DOCTYPE html>
<html>
<body style="font-family: Arial, sans-serif; line-height: 1.5; color: #333;">
<p>Hi {{user_name}},</p>
<p>
We received a request to reset the password for your {{app_name}} account.
</p>
<p style="text-align: center; margin: 30px 0;">
<a href="{{reset_link}}"
style="background-color: #2563eb;
color: #ffffff;
padding: 12px 24px;
text-decoration: none;
border-radius: 4px;
display: inline-block;">
Reset your password
</a>
</p>
<p>If the button above does not work, copy and paste this link into your browser:</p>
<p style="word-break: break-all;">
<a href="{{reset_link}}">{{reset_link}}</a>
</p>
<p>
For your security, this link will expire in 30 minutes and can be used only once.
</p>
<p>
If you did not request a password reset, please ignore this email.
Your password will not be changed.
</p>
<p>Best regards,<br>The {{app_name}} Team</p>
</body>
</html>Using both HTML and plaintext versions improves deliverability and user experience.
Reset Links and Tokens
The most important part of the email is the reset link, because it carries the token that lets the user set a new password.
A typical reset link looks like this:
https://example.com/reset-password?token=abc123...But the token inside this link must be carefully designed.
Requirements for a reset token
A secure password reset token should be:
- Random: Not predictable.
- Long enough: To make brute-force guessing impractical.
- Single use: Once used, it becomes invalid.
- Short lived: Expires after a limited time, such as 15 to 60 minutes.
- Bound to a user: It should match exactly one account.
Important rule: Never use simple data like user id or email alone in the reset link. Always use a cryptographically secure random token, and verify it on the server.
Token formats
Some common approaches:
| Approach | Description | Pros | Cons |
|---|---|---|---|
| Random string in DB | Random bytes stored hashed in database | Simple, secure, revocable | Requires DB lookup |
| Signed token (JWT) | Token with payload signed by server secret | No DB if purely stateless | Revocation is harder |
| Hybrid | Signed token + optional DB storage | Flexible, extra control | More complex implementation |
For beginners, the database approach with a random string is easier to implement correctly.
Example token generation (Python)
import secrets
def generate_reset_token() -> str:
# 32 bytes of randomness encoded as URL-safe base64
return secrets.token_urlsafe(32)You then store a hash of this token in the database, not the token itself, similar to password storage practices.
Backend Logic for Sending Reset Emails
Now connect the email content with your backend logic. At a high level, the backend needs to:
- Receive the password reset request.
- Generate and store the token with expiration.
- Build the reset link.
- Render an email template with the reset link.
- Send the email through SMTP or an email service.
Handling the "Forgot password" request
You might define an endpoint such as:
POST /auth/forgot-password
Content-Type: application/json
{
"email": "user@example.com"
}Backend logic in pseudocode:
function forgot_password(email):
user = find_user_by_email(email)
if user exists:
token = generate_reset_token()
hashed_token = hash(token)
store_reset_token(user_id=user.id, token_hash=hashed_token, expires_at=now + 30 minutes)
reset_link = "https://example.com/reset-password?token=" + url_encode(token)
send_reset_email(user.email, user.name, reset_link)
# Always respond with the same message
return { "message": "If an account with that email exists, we have sent a password reset link." }The important detail is that you do not reveal whether the email exists.
Building the reset link
You usually combine:
- Application base URL.
- Reset route path.
- The token as a query parameter or path parameter.
Examples:
https://app.example.com/reset-password?token={{token}}
https://app.example.com/reset-password/{{token}}You must not put any sensitive data such as passwords or hashes in this link.
Sending the email (simplified Python example)
Assuming you already have an send_email helper that can send HTML and plaintext:
from jinja2 import Template
RESET_EMAIL_SUBJECT = "Reset your password"
PLAINTEXT_TEMPLATE = Template("""
Hi {{ user_name }},
We received a request to reset the password for your {{ app_name }} account.
To reset your password, click the following link:
{{ reset_link }}
For your security, this link will expire in 30 minutes and can be used only once.
If you did not request a password reset, you can ignore this email.
Best regards,
The {{ app_name }} Team
""".strip())
def send_password_reset_email(user_email: str, user_name: str, reset_link: str) -> None:
app_name = "MyCoolApp"
text_body = PLAINTEXT_TEMPLATE.render(
user_name=user_name or "there",
app_name=app_name,
reset_link=reset_link,
)
# You could also render an HTML template here
send_email(
to=user_email,
subject=RESET_EMAIL_SUBJECT,
text_body=text_body,
html_body=None, # or your HTML content
)This keeps your email logic separate from your password reset logic, which makes it easier to test.
Security Best Practices for Password Reset Emails
This is the most critical part of this chapter. Small mistakes in password reset flows can compromise the entire application.
1. Do not reveal whether an email exists
When a user submits an email to reset their password, your response must be the same in both cases:
- Email is associated with an account.
- Email is not associated with any account.
For example:
{
"message": "If an account with that email exists, we have sent a password reset link."
}This prevents attackers from using the password reset form to enumerate valid email addresses.
2. Use secure random tokens
Use a cryptographically secure random number generator, not simple random functions meant for games or UI.
In Python, good choices are:
secrets.token_urlsafeos.urandomcombined with base64 encoding
Do not use random.random for security tokens.
3. Short expiration times
Tokens should have a limited lifetime. Common values:
| Token type | Typical lifetime |
|---|---|
| Password reset token | 15 minutes to 1 hour |
| Email verification token | 1 to 24 hours |
Shorter lifetimes reduce the risk if an email inbox is compromised or a link is leaked.
4. Single use tokens
Once the user successfully resets their password, you must:
- Delete the token from the database, or
- Mark it as used and reject further use.
Even if the token is still within its time window, it must not be accepted again.
Pseudocode:
function reset_password(token, new_password):
hashed_token = hash(token)
record = find_reset_token_record_by_hash(hashed_token)
if record is None:
return error("Invalid or expired token")
if record.expires_at < now:
delete_record(record)
return error("Invalid or expired token")
user = find_user_by_id(record.user_id)
user.password_hash = hash_password(new_password)
save_user(user)
delete_record(record) # invalidate token
return success()5. Avoid sensitive data in URLs
The token itself is already sensitive because it allows password change. You must not add extra sensitive information such as:
- Plain user ids.
- Password hashes.
- Email verification secrets.
If you include a user id for convenience, make sure it is not the only thing you check. The token must still be necessary and verified on the server.
6. Use HTTPS everywhere
Reset links must only be served over HTTPS. If users click a reset link that goes to HTTP, someone on the network could steal the token.
In your emails, always use https:// URLs in the reset link.
7. Notification for password change
Consider sending a separate email when the password actually changes:
Subject: Your password was changed
Hi {{user_name}},
The password for your {{app_name}} account was changed.
If you made this change, you can ignore this email.
If you did not change your password, please reset your password immediately
and contact our support team.This helps users detect suspicious activity.
8. Limit password reset requests
To reduce abuse, you can:
- Limit how often a user can request a reset.
- Rate limit by IP address.
- Require a short cooldown period between emails to the same address.
Example rules:
- At most 3 reset emails per hour per user.
- At most 10 reset requests per IP per hour.
Rule of thumb: Treat the password reset flow as a login equivalent action. Any protection you add to login, you should also consider here.
Good UX Practices for Password Reset Emails
Security is critical, but user experience is also important. A confusing reset process will cause support requests and frustration.
Make the email recognizable
Use:
- Your application name clearly.
- A consistent sender address, for example
no-reply@example.comorsupport@example.com. - Branding elements in HTML emails if possible, like your logo or colors.
Users often ignore emails that look generic or suspicious.
Make the reset link obvious
The link or button should look clearly clickable. In HTML:
- Use a button style or a large colored link.
- Add enough spacing around it, especially on mobile.
In plaintext:
- Place the link on its own line.
- Avoid line breaks in the middle of the URL if possible.
Explain the next steps
Tell users what to expect:
- "After clicking this link, you will be able to choose a new password."
- "If you close this window, you can always request a new reset email."
This removes confusion and helps non-technical users.
Handle expired links gracefully
If a user clicks an expired link, example behavior:
- Show a clear message: "This link has expired."
- Provide a button to request a new reset email directly.
- Do not show technical error messages.
Example UX on the web page:
This password reset link has expired.
For security reasons, password reset links are only valid for 30 minutes.
You can request a new link by clicking the button below.
[ Request new password reset link ]Implementation Example: Combining the Pieces
To see how everything fits together, consider a simplified Python style example that uses functions you might implement in a web backend.
Data model example
You might have a password_reset_tokens table like:
| Column | Type | Description |
|---|---|---|
| id | integer (PK) | Internal id |
| user_id | integer (FK) | Id of the user |
| token_hash | string | Hash of the token |
| expires_at | datetime | Expiration time |
| created_at | datetime | Creation time |
You store a hash of the token, not the plain token.
Forgot password endpoint (pseudocode)
from datetime import datetime, timedelta
RESET_TOKEN_TTL_MINUTES = 30
def request_password_reset(email: str):
user = find_user_by_email(email)
if user is not None:
token = generate_reset_token()
token_hash = hash_token(token)
expires_at = datetime.utcnow() + timedelta(minutes=RESET_TOKEN_TTL_MINUTES)
save_reset_token(user_id=user.id, token_hash=token_hash, expires_at=expires_at)
reset_link = f"https://app.example.com/reset-password?token={token}"
send_password_reset_email(user_email=user.email, user_name=user.name, reset_link=reset_link)
# Always same response
return {
"message": "If an account with that email exists, we have sent a password reset link."
}Reset password endpoint (pseudocode)
def perform_password_reset(token: str, new_password: str):
token_hash = hash_token(token)
record = find_reset_token_by_hash(token_hash)
if record is None:
return error_response("Invalid or expired reset link", status_code=400)
if record.expires_at < datetime.utcnow():
delete_reset_token(record.id)
return error_response("Invalid or expired reset link", status_code=400)
user = find_user_by_id(record.user_id)
user.password_hash = hash_password(new_password)
save_user(user)
delete_reset_token(record.id)
# Optionally notify user
send_password_changed_notification(user.email, user.name)
return { "message": "Password has been reset successfully." }This example leaves out details that are covered in other chapters, such as:
- How to hash passwords correctly.
- How to implement
send_email. - How to handle errors in a specific framework.
The goal here is to understand the specific responsibilities connected to the password reset emails themselves.
Common Mistakes and How to Avoid Them
Finally, look at typical mistakes related to password reset emails and how to prevent them.
| Mistake | Risk | Better approach |
|---|---|---|
| Revealing if email exists | Account enumeration by attackers | Always return generic message |
| Long lived tokens (days or weeks) | Higher chance of token theft use | Use short lifetimes (15 to 60 minutes) |
| Reusing the same token multiple times | Anyone with link can change repeatedly | Invalidate after first successful use |
| Storing tokens in plaintext | DB leak lets attacker reset any password | Store only token hashes |
| Using HTTP links in emails | Token can be intercepted on network | Use HTTPS URLs only |
| No rate limiting on reset requests | Easy abuse for spam or enumeration | Add per user and per IP limits |
| Cryptographically weak random generator | Predictable tokens | Use dedicated secure random functions |
| Complex or unclear email text | Users ignore or misunderstand email | Short, clear language and simple instructions |
If you avoid these common mistakes, your password reset email flow will already be much safer than many real-world applications.
By now you should be able to:
- Design clear and user friendly password reset emails.
- Build secure reset links that use random tokens.
- Connect your backend logic with email sending for password reset flows.
- Apply key security and UX best practices specific to password reset emails.
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!