13.15. Email Verification
Table of Contents
Why Email Verification Matters
When a user signs up to your application, you usually want to confirm that:
- The email address actually exists.
- The person signing up controls that inbox.
- You can safely use that email for password resets, notifications, and security alerts.
This is what email verification solves.
Typical goals of email verification:
- Prevent fake or mistyped email addresses.
- Reduce spam and malicious signups.
- Protect account recovery flows that rely on email.
- Improve deliverability, since you send mail only to valid addresses.
In most systems, email verification is optional for basic browsing, but required for high risk actions like changing password, making payments, or accessing personal data.
Important: Never treat an unverified email as a trusted way to prove identity. Only a verified email can be used for password reset or other sensitive actions.
Common Email Verification Flow
Although implementations differ, most backends follow this basic flow:
- User registers
- User submits
email,password, and maybename. - Backend creates a user record with
is_email_verified = false. - Backend generates a verification token
- Token is random and unpredictable.
- Token is associated with the user and has an expiration time.
- Backend sends a verification email
- Email contains a unique link with the token in it, something like:
https://example.com/verify-email?token=XYZ - User clicks the link
- Browser sends a request to your backend with the token.
- Backend validates the token, checks expiry, and finds the user.
- Backend marks email as verified
- Set
is_email_verified = trueon the user. - Invalidate or delete the token so it cannot be reused.
- Optionally redirect to a “Email verified” page or auto log in.
- Optional: enforce verification checks
- Block login, or restrict actions, if
is_email_verifiedis false.
Here is a very high level sequence:
| Step | Actor | Action |
|---|---|---|
| 1 | Client | POST /register with email and password |
| 2 | Server | Create user, generate token, save token |
| 3 | Server | Send email with /verify-email?token=... |
| 4 | User | Clicks link in email |
| 5 | Client | Browser GET /verify-email?token=... |
| 6 | Server | Validate token, mark email verified, redirect/show page |
Verification Tokens
The core of email verification is the token. This token proves that whoever clicked the link had access to the email inbox.
What the Token Should Be
A verification token must be:
- Random: Hard to guess.
- Unique: Not reused across users or emails.
- Short lived: Expires after some time.
- Bound to a specific user: So you know which email to mark as verified.
There are two common styles:
- Opaque random token
- Example:
c31f5a8d6b854f92a1b7db9a69d9b33 - Stored in the database, usually hashed.
- Signed token (like a JWT or a signed string)
- Contains user info and an expiry timestamp.
- Backend can verify it without a database lookup for the token itself.
Random Token Example
In Python (conceptual example, not full code):
import secrets
def generate_verification_token() -> str:
return secrets.token_urlsafe(32) # e.g. 'aK8...'You could store it in a table like:
| Column | Type | Example |
|---|---|---|
| id | int (PK) | 1 |
| user_id | int (FK) | 42 |
| token_hash | text | sha256(token) |
| created_at | timestamp | 2026-08-27 10:00:00 |
| expires_at | timestamp | 2026-08-27 11:00:00 |
| used_at | timestamp | null or 2026-08-27 10:30:00 after verification |
You never store the token itself, only a hash of it:
import hashlib
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
Rule: Treat email verification tokens like passwords.
Never log them, never expose them to analytics, and if you store them, store only a hash, not the raw token.
Signed Token Example
Instead of saving tokens in a table, you can sign the data and verify the signature when the user clicks:
- Token contains fields like:
user_idemailexp(expiration timestamp)- Token is signed with a secret key.
At verification time:
- Decode and verify the signature.
- Check expiry.
- Find the user and verify the email.
You still may want to store some state in your database (for example, when the user was verified), but you do not need a separate token table.
Designing the Database Fields
You need at least one field on your user table for verification status.
Typical user fields:
| Field | Type | Description |
|---|---|---|
| id | int (PK) | User ID |
| text | Unique email | |
| password_hash | text | Hashed password |
| is_email_verified | boolean | True if email is verified |
| email_verified_at | timestamp | When the email was verified |
Where to store tokens:
- Option A: Dedicated table
email_verification_tokens. - Option B: Store token info on the user itself (simpler, less flexible).
- Option C: Use signed tokens without a token table.
For beginners, a dedicated table is easy to understand and secure.
Generating and Sending Verification Emails
When to Send the Email
You usually send a verification email:
- Immediately after registration.
- When a user changes their email address.
- When a user requests that you resend the verification email.
Each of these flows should:
- Generate a new token.
- Invalidate or mark previous tokens related to the same email.
- Send a fresh email with the new link.
What the Email Should Contain
A typical verification email includes:
- A friendly greeting: “Hi Alice,”
- A short explanation: “Please confirm your email address.”
- The verification link: A button or link to your frontend or backend URL.
- Expiration info: “This link will expire in 60 minutes.”
- A hint if they did not sign up: “If you did not create an account, ignore this email.”
Example text:
Subject: Confirm your email for ExampleApp
Hi Alice,
Thank you for creating an account on ExampleApp.
Please confirm your email by clicking this link:
https://example.com/verify-email?token=XYZ
This link will expire in 60 minutes.
If you did not create this account, you can safely ignore this email.
Constructing the Verification Link
The link usually contains the token as:
- A query parameter:
https://example.com/verify-email?token=XYZ
Or
- A path parameter:
https://example.com/verify-email/XYZ
Query parameter style is more common and easier to copy and paste.
Backend route examples:
GET /verify-email?token=XYZGET /api/auth/verify-email?token=XYZ
In a real app, that route might:
- Call your API.
- Show a confirmation page in the browser.
- Or redirect to a SPA (single page app) that displays the result.
Important: Never put sensitive data such as passwords or password hashes into the verification link. The link should contain only the token and maybe non sensitive data like a redirect URL.
Verifying the Token
When a request arrives at your verification endpoint:
- Read the token from the request.
- From query:
token=.... - From path:
/verify-email/{token}. - Validate the token format.
- If the token is missing or too short, return an error.
- Look up the token.
- If using a token table, hash the token and search for the hash.
- If using a signed token, verify the signature and parse its data.
- Check token state:
- Not expired.
- Not already used.
- Matches the right user and email.
- Mark user as verified:
- Set
is_email_verified = true. - Set
email_verified_at = now. - Optionally set
used_at = nowon the token or delete the token. - Respond to the client:
- Redirect to a success page.
- Or return a JSON response like
{ "detail": "Email verified" }.
Example JSON responses:
- Success:
{
"detail": "Email successfully verified."
}- Token invalid:
{
"detail": "Invalid or already used verification token."
}- Token expired:
{
"detail": "Verification link has expired. Please request a new one."
}You can use different HTTP status codes:
| Situation | Status code |
|---|---|
| Successful verification | 200 or 302 |
| Missing or invalid token | 400 |
| Expired or used token | 400 or 410 |
| Internal server error | 500 |
Token Expiration and Resending
Choosing an Expiration Time
If the token never expires, anyone who gains access to the email at any time can verify the account. Also, old links floating around are not great for security.
Common expiration choices:
| Expiration | When it makes sense |
|---|---|
| 15 minutes | Highly sensitive apps, banking, security heavy |
| 1 hour | Most typical web apps |
| 24 hours | Very low friction needed, less strict |
Rule: Email verification tokens must have an expiration time.
A common choice is 1 hour.
Resending the Verification Email
You must allow users to ask for a new verification email, especially if:
- They never received the first one.
- The token expired.
- They deleted the email.
A typical endpoint might be:
POST /resend-verification
Behavior:
- Check if the user is already verified.
- If yes, respond with
"Email already verified."and do nothing. - Generate a new token.
- Invalidate or mark older verification tokens as used or expired.
- Send a new email.
To avoid abuse:
- Rate limit how often the user can request a new email.
For example, one email every 5 or 10 minutes. - Log attempts for monitoring suspicious patterns.
Returning a neutral response is often better:
"If there is an unverified account with this email, a new verification email has been sent."
This avoids revealing whether an email is registered.
Linking Email Verification With Registration
Typically, the backend does this directly after a successful registration:
- Create the user with
is_email_verified = false. - Generate a token.
- Send a verification email.
Example pseudo-steps:
- Endpoint:
POST /register - Input:
email,password, etc. - Workflow:
- Validate inputs.
- Create user record.
- Generate verification token for
user.id. - Enqueue a background job to send the email.
- Return a response, for example:
{
"detail": "Registration successful. Please check your email to verify your account."
}
Login should then check is_email_verified:
- If unverified, you might:
- Block login completely, or
- Allow login but restrict certain actions and keep reminding user to verify.
You must design this based on your product requirements.
Security Considerations
Email verification looks simple, but there are common security pitfalls.
1. Token Strength
Tokens must be sufficiently random and long. Using secrets.token_urlsafe(32) or equivalent is a safe baseline.
Avoid:
- Short tokens like 6 digits, unless you combine them with extra protection and rate limiting.
- Tokens derived from predictable data like
user_idand timestamps without a secure signature.
2. Token Storage
Storing tokens in plain text is risky:
- If your database is leaked, attackers can verify other users’ emails.
- Even if limited, this is unnecessary risk.
Better approach:
- Store a hash of the token, similar to how passwords are handled.
- On verification, hash the provided token and compare.
3. One Time Use
A verification link should be usable once.
After a successful verification:
- Delete the token.
- Or set
used_atand check thatused_at IS NULLon further attempts.
Even if someone copies the link from an old email, it should not work again after it has been used.
4. No Account Enumeration
Your responses should not reveal whether an email is registered.
Cases:
- Registration: “If this email is not already used, we will create an account and send a verification email.”
- Resend verification: “If there is an unverified account with this email, a verification email has been sent.”
This prevents attackers from using your API as an “email check” service.
5. Protecting the Verification Endpoint
Even though the endpoint is not as sensitive as login, you still need:
- Rate limiting: To stop automated attempts to guess tokens.
- Logging: To detect unusual spikes and possible abuse.
- TLS (HTTPS): So tokens are not visible in transit.
Important: Always use HTTPS on verification links.
Sending a token over plain HTTP lets attackers on the network intercept and hijack accounts.
User Experience Considerations
Good UX around email verification reduces user frustration and support tickets.
Clear Messages
On registration:
- Tell users clearly that they must verify their email.
- Show the address where the email was sent.
- Mention that it may take a few minutes to arrive.
- Suggest checking spam or promotions folders.
On verification pages:
- Success: “Your email is confirmed. You can now log in.”
- Already verified: “This email was already verified. You can log in.”
- Expired: “This link has expired. Request a new verification email.”
Automatic Login After Verification
Some apps automatically log the user in after the email is verified. Others ask for login again.
Options:
- Auto login: Use a short lived token in the same link to create a session.
- No auto login: Redirect to login page with a success message.
Both are valid; pick what matches your security and UX goals.
Mobile and Email Clients
Consider that:
- Some users click links on mobile devices.
- Some email clients break long URLs or add tracking parameters.
- Some email clients prefetch links, which can trigger the verification before the user clicks.
To mitigate prefetch issues:
- Use verification pages that still ask the user to confirm in the browser.
- Or design your workflow so that prefetching does not finalize the verification without some user action.
Handling Edge Cases
Real systems must handle scenarios that are not part of the “happy path”.
User Changes Email Address
When a user changes their email:
- Keep
is_email_verified = falsefor the new email. - Clear
email_verified_at. - Generate a new verification token.
- Send a new verification email to the new address.
You might also want to:
- Notify the old email that the change happened.
- Allow a grace period where some features still work.
Multiple Verification Attempts
What if the user clicks the same link twice?
- First time: Success, mark email verified.
- Second time: Show a friendly message like, “This email is already verified.”
Do not treat it as an error to avoid confusing users.
Token Stolen
If you suspect a token might be compromised:
- Invalidate all existing tokens for that user.
- Require them to request a new verification email.
- If they already used it, the attacker cannot use it again because it is one time use.
Putting It All Together: Example Flow
Here is a simple end to end example of how the main endpoints could interact, in a backend agnostic way.
1. Register
- Endpoint:
POST /register - Request body:
{
"email": "alice@example.com",
"password": "supersecret"
}- Backend:
- Create user with
is_email_verified = false. - Generate token
T. - Save
hash(T)inemail_verification_tokens. - Send email to
alice@example.comwith:
https://app.example.com/verify-email?token=T
- Response:
{
"detail": "Registration successful. Please check your email to verify your account."
}2. Verify Email
- Endpoint:
GET /verify-email?token=T - Backend:
- Read token
T. - Compute
hash(T)and look up token. - Check not expired, not used.
- Mark user’s
is_email_verified = true,email_verified_at = now. - Mark token as used.
- Redirect to frontend or return success JSON.
- Response (JSON case):
{
"detail": "Email successfully verified."
}3. Resend Verification
- Endpoint:
POST /resend-verification - Request body:
{
"email": "alice@example.com"
}- Backend:
- Find user by email.
- If user not found: still respond success message.
- If
is_email_verifiedis true: respond neutral success message. - If not verified:
- Invalidate old tokens.
- Generate new token and send new email.
- Enforce rate limiting.
- Response:
{
"detail": "If an unverified account exists with this email, a new verification email has been sent."
}Summary
Email verification connects your registration system with a real user identity channel, the email inbox. A solid implementation:
- Creates users as unverified at registration time.
- Generates secure, short lived, one time tokens.
- Sends a clear verification email with a tokenized link.
- Verifies and invalidates tokens securely when the user clicks.
- Allows safe resending without leaking which emails exist.
- Integrates neatly with login and account management flows.
By designing tokens, storage, and flows carefully, you avoid common pitfalls and create a safer, more reliable backend for your users.
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!