30.2. JWT Authentication
Table of Contents
Why JWTs for Authentication?
JWT authentication is a way to let clients prove who they are without keeping session state on the server. Instead of storing a “logged in” flag in a database or memory, the server issues a digitally signed token that the client sends with each request.
You will use JWTs heavily in modern backend APIs, especially for:
- Single Page Applications (React, Vue, etc.)
- Mobile apps
- Distributed systems and microservices
JWTs give you:
- Stateless authentication, no server-side session store required.
- Self-contained tokens, they carry user ID and other claims inside.
- Easy integration with API gateways and other services.
You should already know what authentication is and how tokens generally work from earlier chapters. Here we focus on what is unique to JWTs.
What Is a JWT?
A JSON Web Token (JWT) is a compact string that encodes three parts:
- Header
- Payload
- Signature
A JWT looks like this:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0IiwidXNlcm5hbWUiOiJhbm4iLCJyb2xlIjoiYWRtaW4ifQ.
VJtPRd28T0p1ZFQG4EVbP8PvHqYfOBgqv1SQfZs3pqsIt is three Base64URL-encoded strings, separated by dots.
JWT Structure
Header
The header usually has:
{
"alg": "HS256",
"typ": "JWT"
}algis the algorithm used to sign the token, for exampleHS256.typis the type, usually"JWT".
Payload
The payload contains claims, which are statements about the user and the token.
Example:
{
"sub": "1234",
"username": "ann",
"role": "admin",
"exp": 1725026885,
"iat": 1725026585
}subis usually the subject, often your user ID.usernameandroleare custom claims.expis the expiration time, as a Unix timestamp.iatis the issued-at time.
Signature
The signature ensures the token has not been tampered with.
For a token using HMAC SHA-256 (HS256), the signature is:
HMACSHA256(
base64urlEncode(header) + "." + base64urlEncode(payload),
secret_key
)Important rule: If an attacker can guess or obtain your secret key, they can create valid tokens for any user. Keep your JWT secret key truly secret.
JWT Claims
Claims describe properties of the token or the user. There are three main types.
Registered Claims
Standardized claim names. You do not have to use all of them, but they have special meanings.
Common registered claims:
| Claim | Meaning | Example |
|---|---|---|
iss | Issuer, who created the token | "https://api.example.com" |
sub | Subject, usually user ID | "user_123" |
aud | Audience, who the token is for | "mobile-app" |
exp | Expiration time (Unix timestamp) | 1725026885 |
iat | Issued at (Unix timestamp) | 1725026585 |
nbf | Not before (token valid from this time) | 1725026600 |
You will almost always use at least sub, iat, and exp.
Always include an exp claim and reject expired tokens. Never accept tokens without expiration for authentication.
Public Claims
These are custom claims that are not standardized but are publicly defined so they do not conflict with others. In practice, most beginner projects do not use official public claims.
Private Claims
Private claims are custom fields you define for your own application.
Examples:
{
"sub": "user_123",
"username": "ann",
"role": "admin",
"permissions": ["read:orders", "write:orders"],
"plan": "pro"
}Use private claims for things like:
roleorrolespermissionstenant_idis_email_verified
Be careful not to put sensitive data in the payload. JWT payloads are encoded, not encrypted. Anyone who has the token can read the payload.
Rule: Do not store secrets such as passwords, credit card numbers, or personal identifiers inside JWT payloads. JWTs are easily decodable.
Creating and Signing JWTs
The basic steps to create a JWT:
- Build the header.
- Build the payload.
- Encode both to Base64URL.
- Create the signature using your secret key and the algorithm.
- Concatenate the three parts with dots.
In practice you will use libraries to do this.
Algorithm Choices
Two broad types of JWT signing algorithms:
| Type | Example alg | Secret / Key | Typical use |
|---|---|---|---|
| Symmetric | HS256 | Single shared secret key | Simple backends, same app verifies token |
| Asymmetric | RS256 | Private key to sign, public key to verify | Microservices, external verification |
For most beginner APIs:
- Use HS256 with a strong random secret key.
- Store the secret in an environment variable.
Example environment variable:
JWT_SECRET="p9l3-VERY-LONG-RANDOM-SECRET-STRING-3fk29"
JWT_ALGORITHM="HS256"
JWT_EXPIRES_IN_MIN=15Example: Creating a JWT in Python
Using PyJWT:
import jwt
from datetime import datetime, timedelta, timezone
SECRET_KEY = "p9l3-VERY-LONG-RANDOM-SECRET-STRING-3fk29"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 15
def create_access_token(user_id: str, username: str, role: str = "user") -> str:
now = datetime.now(timezone.utc)
expire = now + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
payload = {
"sub": user_id,
"username": username,
"role": role,
"iat": int(now.timestamp()),
"exp": int(expire.timestamp()),
}
token = jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
return tokenKey points:
- Use timezone-aware UTC times.
- Store
subas your user identifier. - Include
iatandexp.
Verifying and Decoding JWTs
When a client calls a protected API endpoint, it usually sends the token in the Authorization header:
GET /api/orders HTTP/1.1
Host: api.example.com
Authorization: Bearer <JWT_HERE>Your backend must:
- Extract the token from the header.
- Verify the signature.
- Check expiration and any other constraints.
- Use the claims (for example the user ID and role) to apply authorization.
Example: Decoding and Verifying a JWT in Python
import jwt
from jwt import InvalidTokenError, ExpiredSignatureError
SECRET_KEY = "p9l3-VERY-LONG-RANDOM-SECRET-STRING-3fk29"
ALGORITHM = "HS256"
def decode_token(token: str) -> dict:
try:
payload = jwt.decode(
token,
SECRET_KEY,
algorithms=[ALGORITHM],
options={"require": ["exp", "sub"]},
)
return payload
except ExpiredSignatureError:
# Token is expired
raise
except InvalidTokenError:
# Signature invalid, wrong algorithm, malformed token, etc.
raise
The jwt.decode call:
- Verifies the signature using
SECRET_KEY. - Verifies the
expclaim by default, unless disabled. - Ensures
expandsubare present if required.
Never decode JWTs without verifying the signature. Methods that simply decode Base64 and do not check the signature are not safe for authentication.
Access Tokens vs Refresh Tokens
In a JWT based system you often use two tokens:
- Access token
Short-lived, used on every request to access protected resources. - Refresh token
Long-lived, used only to get a new access token when it expires.
Why two tokens?
- Short-lived access tokens reduce damage if stolen.
- Long-lived refresh tokens let users stay logged in without re-entering passwords.
Typical Lifetimes
| Token type | Lifetime example | Where stored (typical) |
|---|---|---|
| Access token | 5 to 30 minutes | In memory or a secure cookie |
| Refresh token | 7 to 30 days | HttpOnly secure cookie or server-side store |
Do not store JWTs in localStorage in browser apps if you can avoid it. HttpOnly cookies are safer against XSS.
Login Flow with JWTs
Here is a simple example of how login works with JWTs.
Step 1: User Logs In
Client sends credentials:
POST /auth/login HTTP/1.1
Content-Type: application/json
{
"email": "ann@example.com",
"password": "secret-password"
}Server steps:
- Find user by email.
- Verify password (using your password hashing logic).
- If valid:
- Create an access token.
- Optionally create a refresh token.
- Return them to the client.
Example JSON response:
{
"access_token": "<ACCESS_JWT>",
"refresh_token": "<REFRESH_JWT>",
"token_type": "bearer",
"expires_in": 900
}Or you can send the refresh token as an HttpOnly cookie instead of in the JSON body.
Step 2: Client Calls Protected APIs
For each API call:
GET /api/me HTTP/1.1
Authorization: Bearer <ACCESS_JWT>Server:
- Reads the
Authorizationheader. - Extracts the token after
Bearer. - Decodes and verifies it.
- Uses
subto get user info or load user from database. - Returns data if authorized.
Step 3: Refreshing the Access Token
When the access token expires:
- Client calls a refresh endpoint with the refresh token.
Example request:
POST /auth/refresh HTTP/1.1
Content-Type: application/json
{
"refresh_token": "<REFRESH_JWT>"
}Server:
- Verifies refresh token (signature and expiration).
- Optionally checks if the refresh token is still active in a database.
- Issues a new access token (and possibly a new refresh token).
- Returns the new tokens.
This lets users stay logged in without logging in again.
Stateless vs Stateful JWT Authentication
JWTs are often described as stateless, meaning the server does not have to store any session data.
In a fully stateless approach:
- Server only needs the secret key to verify tokens.
- No database lookup is required to know who the user is if you trust the claims.
However, many real applications mix stateless JWTs with some stateful elements.
Common Options
| Approach | Description | Pros | Cons |
|---|---|---|---|
| Pure stateless | Only verify JWT, no token storage | Simple, scalable | Hard to revoke tokens early |
| Stateful refresh tokens | Store refresh tokens or their IDs in database | Can revoke sessions, track devices | Extra database operations |
| Blacklist / denylist | Keep a list of revoked access tokens or IDs | Fine-grained revocation | Can grow large, maintenance needed |
| Versioned tokens | Include a token version in payload, check against DB | Simple revocation per user | Still needs DB lookup on each request |
For beginners:
- Use short-lived access tokens.
- Use stateful refresh tokens stored in your database.
- Optionally load user from database on each request to verify they are active.
Authorization with Claims
JWTs are for authentication (who the user is). You can also store some authorization information in them.
Common patterns:
- A
roleclaim:"user","admin","manager". - A
permissionsclaim:["read:orders", "write:orders"].
Example payload:
{
"sub": "user_123",
"username": "ann",
"role": "admin",
"permissions": ["read:orders", "write:orders"],
"exp": 1725026885
}On each request:
- Verify token.
- Read
roleorpermissions. - Decide if user can access the endpoint.
Example pseudo-code:
def require_admin(claims: dict):
if claims.get("role") != "admin":
raise PermissionError("Admin role required")Do not trust role/permission claims blindly if they can become outdated. If roles change often, consider checking the database or using short token lifetimes so changes apply quickly.
Common JWT Security Pitfalls
JWTs are powerful, but many systems become insecure because of simple mistakes.
1. Not Validating Algorithm Properly
Some libraries support "alg": "none" for unsigned tokens.
You must make sure your verification code:
- Explicitly specifies the expected algorithm.
- Does not accept tokens that change the algorithm to
"none".
In Python jwt.decode, always set algorithms=[ALGORITHM].
2. Weak or Hardcoded Secrets
A short or guessable secret is dangerous.
Bad example:
SECRET_KEY = "secret"Better:
- Use a long random string.
- Load it from an environment variable.
- Do not commit it to Git.
3. No Expiration
Tokens without exp can be valid forever if you do not enforce expiration.
Always:
- Add
expwhen generating tokens. - Ensure your library checks expiration, or you check it.
4. Storing Sensitive Data in the Token
Remember, JWT payloads are only Base64URL encoded. Anyone can decode them.
Do not store:
- Password hashes
- Credit card numbers
- Personal ID numbers
You can store identifiers, roles, and non-sensitive flags.
5. Not Using HTTPS
If you send JWTs over plain HTTP:
- Anyone on the network can sniff the token.
- They can then use it as that user.
Always require HTTPS in production.
Logout and Token Revocation
JWTs by themselves do not have a built-in way to log out. Once a token is issued, it is valid until it expires, unless you add extra logic.
Common approaches:
1. Short Expiration for Access Tokens
- Access tokens last only a few minutes.
- If stolen, they are useful only for a short time.
Logging out on the client:
- Client deletes its stored tokens.
- Server does not need to do anything.
2. Revoking Refresh Tokens
To truly end a session:
- Store refresh tokens or a unique ID for each token in your database.
- On logout, mark that refresh token as revoked.
- On
/auth/refresh, check that the token is active.
Example refresh token table:
| Column | Example value |
|---|---|
| id | uuid |
| user_id | user_123 |
| token_hash | Hash of refresh token value |
| created_at | DateTime |
| expires_at | DateTime |
| revoked_at | Nullable DateTime |
You can store a hash instead of the raw token for extra safety.
3. Token Versioning
Add token_version or session_version to both:
- User record in database.
- JWT payload.
When user logs out from all devices or password changes:
- Increment
token_versionin database. - Any token with an old version becomes invalid.
Example payload:
{
"sub": "user_123",
"username": "ann",
"token_version": 4,
"exp": 1725026885
}On each request:
- Load user and compare
token_versionfrom DB to the JWT. - If they differ, reject the token.
Example Endpoints for JWT Authentication
Below is a simplified set of endpoints you might build in your authentication project.
| Endpoint | Method | Purpose |
|---|---|---|
/auth/register | POST | Create new user account |
/auth/login | POST | Check credentials, return JWTs |
/auth/refresh | POST | Exchange refresh token for new access token |
/auth/logout | POST | Revoke refresh token / session |
/auth/me | GET | Get current user info using access token |
Example `/auth/me` Handler (Pseudo-code)
def get_current_user(auth_header: str, db):
if not auth_header or not auth_header.startswith("Bearer "):
raise UnauthorizedError("Missing or invalid Authorization header")
token = auth_header.split(" ", 1)[1]
try:
claims = decode_token(token) # verifies signature and exp
except ExpiredSignatureError:
raise UnauthorizedError("Token expired")
except InvalidTokenError:
raise UnauthorizedError("Invalid token")
user_id = claims.get("sub")
if not user_id:
raise UnauthorizedError("Invalid token, no subject")
user = db.get_user_by_id(user_id)
if not user or not user.is_active:
raise UnauthorizedError("User not found or inactive")
return userThis pattern is similar in many frameworks:
- Extract token
- Decode and verify
- Fetch user if needed
- Attach user to the request context for the rest of the handler logic
Summary
- A JWT has three parts: header, payload, and signature.
- You use claims in the payload to store user ID, expiration, roles, and more.
- Always:
- Use a strong secret key.
- Set and verify
exp. - Verify the expected algorithm.
- Use HTTPS.
- Access tokens are short-lived and used for each API call.
- Refresh tokens are long-lived and used to obtain new access tokens.
- JWTs work well for stateless authentication, but you often combine them with some state to support logout and revocation.
- Do not put secrets in tokens, they are not encrypted.
In the next parts of the project you will implement these ideas in code, integrating JWTs into your registration, login, and protected API endpoints.
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!