13.7. JSON Web Tokens
Table of Contents
Why JSON Web Tokens Matter
JSON Web Tokens, usually written as JWTs and pronounced "jots", are a very popular way to implement token based authentication in backend systems.
They are used in many modern web and mobile applications, especially when you have:
- A REST API that serves JavaScript frontends or mobile apps
- Multiple services that must share authentication information
- Stateless authentication, where the server does not keep session data in memory
In this chapter you will learn what JWTs are, what problem they solve, and how to use them correctly without going deep into topics that belong in separate chapters such as Access Tokens, Refresh Tokens, or OAuth 2.0.
What Is a JWT?
A JSON Web Token is a compact string that encodes some JSON data and is cryptographically signed.
A JWT is made of three parts, separated by dots:
header.payload.signatureFor example:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
.
eyJzdWIiOiIxMjM0NTYiLCJ1c2VybmFtZSI6ImFsaWNlIiwiZXhwIjoxNzAwMDAwMDAwfQ
.
X4rnRBqcYqtwbTgBjHqQ5V9RzK0PwtH0RmL4i3Pzga0You usually see JWTs in HTTP headers:
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...The Three Parts of a JWT
1. Header
The header tells:
- Which algorithm is used to sign the token
- The type of the token (usually
"JWT")
Example header JSON:
{
"alg": "HS256",
"typ": "JWT"
}This JSON is then Base64URL encoded to a string like:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ92. Payload
The payload contains the claims. A claim is a piece of information, such as:
- Who the user is
- What roles or permissions they have
- When the token expires
Example payload JSON:
{
"sub": "123456", // subject, usually user id
"username": "alice",
"role": "admin",
"exp": 1700000000
}This JSON is also Base64URL encoded to form the second part of the token.
3. Signature
The signature makes the token tamper evident. The server signs the header and payload with a secret key.
For an HMAC algorithm like HS256, the signature is:
$$
\text{signature} = \text{HMAC\_SHA256}(\text{base64url(header)} + "." + \text{base64url(payload)}, \text{secret})
$$
The result is Base64URL encoded to become the third part of the token.
A JWT is not encrypted by default. Anyone who has the token can read its header and payload.
The signature does not hide information, it only protects integrity.
Never put passwords or other highly sensitive secrets into a JWT payload.
How JWT Authentication Works
JWTs are often used for stateless authentication. That means the server does not keep login state in memory or in a session store for each user. Instead, the client sends a JWT with every request and the server verifies it.
Typical Login Flow with JWT
- User logs in
- Client sends username and password to the backend (for example with a POST
/loginrequest). - Backend verifies the password (using secure password hashing from other chapters, not plain text).
- Server creates a token
- Backend creates a JWT that includes the user's id and maybe role or other claims.
- Backend signs the JWT with a secret or private key.
- Backend returns the JWT to the client.
Example JSON response:
{
"access_token": "<jwt-string-here>",
"token_type": "bearer"
}- Client stores the token
The client can store it:
- In memory (JavaScript variable, React state)
- In
localStorageorsessionStorage(with XSS risks) - In an HTTP-only cookie (similar to session cookies, but still a token)
- Client uses the token
For every request to a protected endpoint, the client sends:
GET /api/me HTTP/1.1
Host: api.example.com
Authorization: Bearer <jwt-string-here>- Server verifies the token
- Backend reads the Authorization header.
- Backend verifies the signature using its secret or public key.
- Backend checks if the token is expired.
- If valid, backend trusts the claims inside the token (such as
sub,role). - Server executes the request
- Backend executes business logic using the user identity from the token.
- Backend returns a response.
This flow allows the backend to not store session state for each user, which helps scalability and works well with multiple servers behind a load balancer.
Standard JWT Claims
JWT defines some common claim names. You can use custom names too, but these are typical:
| Claim | Meaning | Example value |
|---|---|---|
iss | Issuer, who created the token | "https://api.example.com" |
sub | Subject, who the token refers to | "user-123" |
aud | Audience, who the token is for | "my-frontend-app" |
exp | Expiration time, in seconds (UTC) | 1700000000 |
nbf | Not before, token valid from this time | 1699990000 |
iat | Issued at, creation time | 1699999000 |
jti | JWT ID, unique identifier | "a9f9cba6-..." |
In many simple systems you mainly use:
subfor user idexpfor expiration time- Maybe
role,is_admin, orscopesas custom claims
Example payload with typical claims:
{
"sub": "123",
"username": "alice",
"role": "admin",
"exp": 1700000000,
"iat": 1699999000,
"iss": "https://api.example.com"
}
Always include an expiration (exp) in your JWTs.
A token that never expires is very dangerous. If it is stolen, an attacker can use it forever.
Symmetric vs Asymmetric Signing
How you sign a JWT affects how your system is designed.
Symmetric Signing (HS256, HS384, HS512)
With symmetric signing, one shared secret key is used to:
- Sign tokens
- Verify tokens
Example algorithms:
HS256HS384HS512
This is simple and common in single service backends.
Example pseudocode:
jwt.encode(payload, secret_key, algorithm="HS256")
jwt.decode(token, secret_key, algorithms=["HS256"])Pros
- Simple to implement
- One secret that you keep safe
- Fast enough for most use cases
Cons
- Every service that verifies tokens must know the secret
- If the secret leaks, anybody can create valid tokens
Asymmetric Signing (RS256, ES256)
With asymmetric signing, there are two keys:
- Private key to sign tokens
- Public key to verify tokens
Example algorithms:
RS256(RSA + SHA-256)ES256(Elliptic Curve)
Example pseudocode:
jwt.encode(payload, private_key, algorithm="RS256")
jwt.decode(token, public_key, algorithms=["RS256"])Pros
- Only the authentication service needs the private key
- Other services only need the public key
- If a microservice is compromised, it cannot sign new tokens
Cons
- More complex key management
- Slightly slower than HS256 (usually still fine)
For learning and small projects, HS256 is often enough. For larger systems or multiple services, RS256 or another asymmetric algorithm is often preferred.
Example: Creating and Verifying JWTs
In practice you use a library rather than manually building the Base64 strings.
Below is an example using Python with the popular PyJWT library. It is not a complete app, only a clear demonstration.
Creating a JWT
import jwt
from datetime import datetime, timedelta, timezone
SECRET_KEY = "super-secret-key-change-me"
def create_access_token(user_id: str, username: str) -> str:
now = datetime.now(timezone.utc)
payload = {
"sub": user_id,
"username": username,
"exp": now + timedelta(minutes=15),
"iat": now,
"iss": "https://api.example.com"
}
token = jwt.encode(
payload,
SECRET_KEY,
algorithm="HS256"
)
return tokenHere:
subidentifies the userusernameis extra infoexpis 15 minutes in the futureiatis the current timeissis the API base URL
Verifying a JWT
import jwt
from jwt import InvalidTokenError, ExpiredSignatureError
def verify_access_token(token: str) -> dict:
try:
payload = jwt.decode(
token,
SECRET_KEY,
algorithms=["HS256"],
issuer="https://api.example.com"
)
return payload
except ExpiredSignatureError:
raise ValueError("Token has expired")
except InvalidTokenError:
raise ValueError("Token is invalid")In a real backend endpoint, you would:
- Read the
Authorizationheader. - Extract the token after
Bearer. - Call
verify_access_token. - Attach the user information from the payload to the request context.
Where JWTs Are Stored and Sent
JWTs are only useful if the client sends them correctly.
Common Ways to Send a JWT
| Location | Example | Notes |
|---|---|---|
| HTTP header | Authorization: Bearer <token> | Most common for APIs |
| Cookie | Set-Cookie: access_token=<token>; HttpOnly | Useful for browsers |
| Query string | /some-route?token=<token> | Not recommended |
Using the Authorization header is usually the easiest for API clients and mobile apps.
For browser based apps, using HTTP-only cookies can help protect against some attacks, but has its own details which are covered in other chapters.
Do not put tokens in URLs (query parameters) if you can avoid it.
Tokens in URLs can end up:
- In server logs
- In browser history
- In referrer headers to other sites
JWT Best Practices
Using JWTs correctly is important. Many security problems come from incorrect usage, not from the JWT standard itself.
1. Use Short Expiration Times
Use relatively short lifetimes for access tokens, for example:
- 5 to 15 minutes
If a token is stolen, a short lifetime reduces the damage.
You will later combine this with refresh tokens in the dedicated chapter.
2. Validate Algorithm and Claims
When you decode a JWT:
- Always specify allowed algorithms explicitly
- Check
exp,iss,aud, and any other important claims
Pseudocode:
payload = jwt.decode(
token,
key,
algorithms=["HS256"],
issuer="https://api.example.com",
audience="my-frontend-app"
)
Never allow the token to decide the algorithm by itself.
Always pass the accepted algorithms explicitly to the library. This protects against some known attacks.
3. Do Not Store Sensitive Data in the Payload
JWT payloads are just Base64URL encoded. Any attacker who gets the token can read it.
Avoid storing:
- Passwords
- Secret keys
- Payment card numbers
- Any data that must remain confidential
Use JWTs to store identifiers, roles, and flags, not secrets.
4. Rotate Secrets and Keys
For HS256:
- Store the secret in a secure place, such as an environment variable or a secret manager.
- Change it periodically.
For RS256:
- Rotate private / public key pairs on a schedule.
- Keep old keys around for some time to validate existing tokens.
Key and secret management is covered in depth in the security and secrets management chapters, but it is important to remember that JWT security depends directly on key security.
5. Consider Token Revocation
JWTs are stateless by default. Once a token is issued, the server cannot "take it back" without extra logic.
You might need revocation when:
- A user logs out from all devices
- A user account is disabled
- A token is known to be stolen
Common approaches:
- Maintain a token blacklist in a database or Redis and check it for every request.
- Use a
jti(JWT ID) claim and store revokedjtivalues. - Use very short lived access tokens and rely on refresh tokens with server side checks.
Token revocation in detail is usually handled together with access and refresh tokens, which are covered in other chapters.
Comparing JWTs with Server Sessions
JWTs and server side sessions are both ways to keep users authenticated.
| Feature | JWT | Server session |
|---|---|---|
| Storage location | Client stores token | Server stores session data |
| Server memory use | None for tokens | Grows with number of sessions |
| Stateless | Yes (usually) | No |
| Revocation | Harder, needs extra logic | Easier, delete session |
| Scaling across servers | Easy, any server can verify | Need shared session store |
| Token size | Usually larger | Session id is small |
JWTs are very useful when:
- You have stateless REST APIs
- You have multiple backend servers
- You have multiple clients (web, mobile, other services)
Session based authentication can still be a good choice, especially for simple server rendered web apps.
Simple End-to-End Example
To see everything together, imagine this simplified API.
Login Endpoint
POST /login HTTP/1.1
Content-Type: application/json
{
"username": "alice",
"password": "secret-password"
}Simplified backend logic:
def login(username: str, password: str):
user = find_user_in_db(username)
if not user or not verify_password(password, user.password_hash):
raise HTTPException(status_code=401, detail="Invalid credentials")
token = create_access_token(
user_id=str(user.id),
username=user.username
)
return {"access_token": token, "token_type": "bearer"}The client receives:
{
"access_token": "eyJhbGciOiJIUzI1NiIs...",
"token_type": "bearer"
}Protected Endpoint
Client request:
GET /me HTTP/1.1
Host: api.example.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...Backend logic to protect the endpoint:
def get_current_user(authorization_header: str):
if not authorization_header.startswith("Bearer "):
raise HTTPException(status_code=401, detail="Missing token")
token = authorization_header.split(" ", 1)[1]
try:
payload = verify_access_token(token)
except ValueError:
raise HTTPException(status_code=401, detail="Invalid or expired token")
user_id = payload["sub"]
user = find_user_in_db_by_id(user_id)
if not user:
raise HTTPException(status_code=401, detail="User not found")
return user
The /me endpoint can then use get_current_user:
def me_endpoint(request):
user = get_current_user(request.headers.get("Authorization", ""))
return {
"id": user.id,
"username": user.username
}This shows the complete minimal flow:
- User logs in.
- Server issues JWT.
- Client sends JWT on each request.
- Server verifies token and returns data.
Summary
- A JWT is a string that contains three parts: header, payload, and signature.
- JWTs are signed, not encrypted by default.
- JWTs are very useful for stateless authentication, especially in APIs.
- Clients typically send JWTs in the
Authorization: Bearerheader. - Always use
expfor expiration and validate important claims. - Protect your signing keys and secrets.
- Do not store sensitive data like passwords in a JWT.
In the next related chapters, you will see how JWTs are used as access tokens, how refresh tokens work together with JWTs, and how these tokens integrate into complete authentication flows.
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!