13.10. OAuth 2.0
Table of Contents
Why OAuth 2.0 Exists
Traditional login systems expect users to create an account and password for every application. This causes several problems:
- Users must trust every app with their password.
- Password reuse becomes common and dangerous.
- External services cannot easily allow third‑party apps to act on a user’s behalf with limited permissions.
OAuth 2.0 is an authorization framework that solves this. It lets one application request limited access to a user’s data or actions in another system, without seeing the user’s password.
Example:
- Your app wants to access a user’s Google Calendar.
- Instead of asking for the user’s Google password, you redirect them to Google.
- Google asks the user to approve access.
- Google sends your app an access token which your app uses to call Google APIs.
Your app never sees the password, only a token with specific, limited permissions.
Key idea: OAuth 2.0 is about authorization, not authentication.
It answers: “Can this app do X on behalf of this user?”
It does not define how to verify identity, even though it is often (incorrectly) used “for login”.
Core Roles in OAuth 2.0
OAuth 2.0 defines four main roles:
| Role | Also called | Description | Example |
|---|---|---|---|
| Resource Owner | User | Entity that owns the data or account | The Google account owner |
| Client | Third‑party app | Application that wants access on behalf of the user | Your calendar integration app |
| Resource Server | API server | Server that hosts the protected resources (APIs) | Google Calendar API |
| Authorization Server | Auth server / IdP | Server that issues tokens after user authorization | accounts.google.com OAuth server |
Sometimes the authorization server and resource server are the same application, sometimes not.
Tokens in OAuth 2.0
OAuth 2.0 works with tokens instead of passwords.
Access Tokens
An access token is a credential that represents authorization to access specific resources.
Properties:
- Short‑lived, for example 5 to 60 minutes.
- Presented with each request, usually in the
Authorizationheader:
GET /user/profile HTTP/1.1
Host: api.example.com
Authorization: Bearer ACCESS_TOKEN_HERE- Attached to scopes, which define what actions are allowed.
You usually treat access tokens as opaque strings in your backend unless you use something like JWT, which you can decode.
Refresh Tokens
Access tokens expire quickly to limit damage if they leak. Refresh tokens allow the client to obtain new access tokens without re‑prompting the user.
- Long‑lived, for example hours or days.
- Never sent to resource APIs, only to the authorization server.
- Kept very secure, usually only in a backend or “confidential client”.
Example token flow:
- User signs in and approves the client.
- Authorization server returns:
- access token (short life)
- refresh token (longer life)
- When the access token expires, the client exchanges the refresh token for a fresh access token.
Rule: Never send refresh tokens to the browser or to untrusted client code.
Keep refresh tokens only in secure environments such as server‑side storage.
Scopes
Scopes represent what the client is allowed to do.
Examples:
read:user= read user profilewrite:tasks= create and update tasksemail= read email address
The client requests scopes during authorization:
GET /oauth/authorize?response_type=code
&client_id=YOUR_CLIENT_ID
&redirect_uri=https://your-app.com/callback
&scope=read:user write:tasks
&state=xyzThe authorization server shows these scopes to the user:
“This app wants to:
- read your profile
- create and edit your tasks”
The user can approve or deny.
Scopes then become part of the access token, and the resource server uses them to allow or deny API calls.
Examples in your own API:
- Route:
GET /tasksrequirestasks:read. - Route:
POST /tasksrequirestasks:write.
Your backend checks that the access token includes the right scope before performing the operation.
OAuth 2.0 Grant Types
A grant type describes how the client gets an access token.
Modern OAuth 2.0 mostly uses:
- Authorization Code grant (with PKCE for public clients)
- Client Credentials grant (for server to server)
The older Implicit grant is considered insecure and should not be used in new systems.
Authorization Code Grant (with PKCE)
Best for:
- Web apps with a backend server
- Single Page Applications (SPAs)
- Native mobile apps (Android, iOS, desktop) with PKCE
High level flow:
- Client redirects user to authorization server.
- User signs in and approves access.
- Authorization server redirects back with a short‑lived
code. - Client sends this
code(plus client credentials and PKCE data) to the authorization server. - Authorization server returns access token (and optionally refresh token).
This keeps client secrets and tokens off the browser when possible.
Example Flow (Authorization Code)
- Your app redirects the user:
GET https://auth.example.com/oauth/authorize?
response_type=code&
client_id=calendar-app&
redirect_uri=https://myapp.com/oauth/callback&
scope=read:calendar&
state=abc123- User signs in at
auth.example.comand approves. - Authorization server redirects back:
GET /oauth/callback?code=AUTH_CODE_HERE&state=abc123 HTTP/1.1
Host: myapp.com- Your backend exchanges the code:
POST https://auth.example.com/oauth/token
Content-Type: application/x-www-form-urlencoded
grant_type=authorization_code&
code=AUTH_CODE_HERE&
redirect_uri=https://myapp.com/oauth/callback&
client_id=calendar-app&
client_secret=YOUR_CLIENT_SECRET- Authorization server returns:
{
"access_token": "ACCESS_TOKEN_HERE",
"token_type": "Bearer",
"expires_in": 3600,
"refresh_token": "REFRESH_TOKEN_HERE",
"scope": "read:calendar"
}Your backend then stores the tokens securely, for example in a database or session tied to the user.
PKCE (Proof Key for Code Exchange)
PKCE enhances the Authorization Code flow when you cannot keep a client secret private (for example SPA or mobile app).
Idea:
- Client generates a random string
code_verifier. - It hashes it to
code_challengeand sends the challenge when redirecting the user to authorize. - Later, when exchanging the code for tokens, client must present the original
code_verifier. - Authorization server verifies that the verifier matches the initial challenge.
This prevents attackers that steal the authorization code from being able to exchange it for tokens, because they do not have the code_verifier.
Example:
import os, base64, hashlib
# generate code_verifier
code_verifier = base64.urlsafe_b64encode(os.urandom(32)).rstrip(b'=').decode()
# generate code_challenge
code_challenge = base64.urlsafe_b64encode(
hashlib.sha256(code_verifier.encode()).digest()
).rstrip(b'=').decode()You:
- Send
code_challengein the initial/authorizerequest. - Send
code_verifierin the/tokenrequest.
Rule: Use Authorization Code with PKCE for SPAs and native apps.
Use Authorization Code with client secret for traditional server‑side web apps.
Client Credentials Grant
Used when there is no user, only machine to machine communication.
Examples:
- Your backend calls a payment provider’s API.
- A background worker calls another microservice.
Flow:
- Client authenticates with its
client_idandclient_secret. - Authorization server returns an access token that represents the client itself, not a specific user.
Example:
POST https://auth.example.com/oauth/token
Content-Type: application/x-www-form-urlencoded
grant_type=client_credentials&
client_id=service-a&
client_secret=SERVICE_A_SECRET&
scope=orders:readResponse:
{
"access_token": "ACCESS_TOKEN_HERE",
"token_type": "Bearer",
"expires_in": 3600,
"scope": "orders:read"
}You then send this access token in calls from Service A to Service B.
Important: Client Credentials tokens do not represent a user.
Do not use them when you need user identity or per‑user permissions.
Redirect URIs and Security
Redirect URIs are critical in OAuth 2.0 flows that involve a browser.
Rules:
- You must register allowed redirect URIs in the authorization server.
- Authorization server must only redirect to allowed URIs.
- Do not allow wildcards like
https://myapp.com/*if possible. - In development, you can use something like
http://localhost:8000/oauth/callback.
Example configuration:
| Environment | Redirect URI |
|---|---|
| Dev | http://localhost:8000/oauth/callback |
| Staging | https://staging.myapp.com/oauth/callback |
| Prod | https://myapp.com/oauth/callback |
This prevents open redirect vulnerabilities where an attacker tricks the system into sending tokens to a malicious domain.
State Parameter and CSRF Protection
The state parameter protects against CSRF and some redirect attacks.
Flow:
- Before redirecting the user to the authorization server, your app generates a random string and stores it in the session.
- It includes that string as
statein the authorization URL:
GET https://auth.example.com/oauth/authorize?
response_type=code&
client_id=myapp&
redirect_uri=https://myapp.com/oauth/callback&
scope=read:user&
state=RANDOM_STRING- The authorization server returns the same
state:
GET /oauth/callback?code=AUTH_CODE&state=RANDOM_STRING- Your app verifies that the
stateit receives matches the stored value.
If it does not match, it rejects the request.
Rule: Always use state in browser based OAuth flows and always verify it when handling the callback.
Using OAuth 2.0 in Your Own Backend
So far we have talked about OAuth 2.0 as a way to integrate with external providers like Google or GitHub.
You can also use OAuth 2.0 as the foundation of your own authentication and authorization system.
There are two main scenarios:
- Your API as a resource server that validates access tokens.
- Your backend as an OAuth 2.0 client that calls other APIs using OAuth tokens.
Your API as a Resource Server
In this setup, clients send access tokens with API requests and your backend must:
- Validate the token.
- Extract scopes and user identity.
- Apply authorization rules before processing the request.
Example with a Bearer token:
GET /tasks HTTP/1.1
Host: api.example.com
Authorization: Bearer ACCESS_TOKEN_HEREYour FastAPI backend (pseudocode):
from fastapi import Depends, HTTPException, status
from typing import List
class TokenData:
user_id: int
scopes: List[str]
def verify_access_token(token: str) -> TokenData:
# 1. Verify signature / lookup token in DB
# 2. Check expiration
# 3. Extract user_id and scopes
# 4. Raise error if invalid
...
def require_scopes(required_scopes: List[str]):
def dependency(token_data: TokenData = Depends(verify_access_token)):
if not set(required_scopes).issubset(set(token_data.scopes)):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Insufficient scope"
)
return token_data
return dependency
@app.get("/tasks")
def list_tasks(token_data: TokenData = Depends(require_scopes(["tasks:read"]))):
# You have token_data.user_id and validated scopes
return get_tasks_for_user(token_data.user_id)Your token validation might:
- Decode a JWT and check its signature, or
- Look up an opaque token in your database or cache.
Your Backend as an OAuth 2.0 Client
Example: Your backend integrates with GitHub on behalf of users.
High level:
- Provide a “Connect GitHub” button that redirects to GitHub’s OAuth authorization URL.
- Handle the callback from GitHub.
- Exchange the code for tokens.
- Store the tokens for that user.
- Use the access token when calling GitHub APIs.
Pseudo FastAPI example:
from fastapi import APIRouter, Request
from fastapi.responses import RedirectResponse
import httpx
import os
router = APIRouter()
GITHUB_CLIENT_ID = os.getenv("GITHUB_CLIENT_ID")
GITHUB_CLIENT_SECRET = os.getenv("GITHUB_CLIENT_SECRET")
GITHUB_REDIRECT_URI = "http://localhost:8000/auth/github/callback"
@router.get("/auth/github")
def github_login():
url = (
"https://github.com/login/oauth/authorize"
f"?client_id={GITHUB_CLIENT_ID}"
f"&redirect_uri={GITHUB_REDIRECT_URI}"
"&scope=read:user"
"&state=random_csrf_token"
)
return RedirectResponse(url)
@router.get("/auth/github/callback")
async def github_callback(code: str, state: str, request: Request):
# TODO check state for CSRF protection
async with httpx.AsyncClient() as client:
token_resp = await client.post(
"https://github.com/login/oauth/access_token",
headers={"Accept": "application/json"},
data={
"client_id": GITHUB_CLIENT_ID,
"client_secret": GITHUB_CLIENT_SECRET,
"code": code,
"redirect_uri": GITHUB_REDIRECT_URI,
},
)
token_data = token_resp.json()
access_token = token_data["access_token"]
# Use token to get user info
async with httpx.AsyncClient() as client:
user_resp = await client.get(
"https://api.github.com/user",
headers={"Authorization": f"Bearer {access_token}"}
)
user_data = user_resp.json()
# Here you would:
# - find or create a local user linked to user_data["id"]
# - store access_token (and refresh_token if provided) securely
# - create a session or JWT for your own app
...This is a typical pattern when you see “Sign in with X” buttons.
Common Pitfalls and Best Practices
Confusing OAuth 2.0 with Authentication
OAuth 2.0 by itself does not tell you how to:
- Get a user’s identity reliably.
- Standardize claims like email, name, etc.
That is what OpenID Connect adds on top of OAuth. It introduces an ID token and standardized user info.
Use:
- OAuth 2.0 for authorization and API access.
- OAuth 2.0 + OpenID Connect when you need login and identity.
Storing Tokens Unsafely
Bad practices:
- Saving access or refresh tokens in plain localStorage or in JavaScript accessible cookies.
- Logging tokens in server logs.
- Sending tokens to third‑party analytics.
Better practices:
- Keep refresh tokens only on backend.
- Use secure, HTTP‑only cookies for session tokens.
- Minimize where tokens are stored and for how long.
- Mask tokens in logs.
Overbroad Scopes
Do not request more scopes than you need. This:
- Increases damage if tokens leak.
- Makes users less likely to approve.
Design small, focused scopes:
profile:read,tasks:read,tasks:write,admin:users.
Not Revoking Tokens
Implement ways to:
- Revoke tokens on user logout if possible.
- Immediately revoke tokens after password change or suspicion of compromise.
- Use short expiration times on access tokens and track refresh tokens to allow revocation.
Summary
- OAuth 2.0 is an authorization framework that lets applications access resources on behalf of a user without handling passwords.
- Main roles: Resource Owner, Client, Authorization Server, Resource Server.
- Main artifacts: access tokens, refresh tokens, scopes.
- Common grants:
- Authorization Code with PKCE for browser and mobile apps.
- Authorization Code with client secret for server‑side web apps.
- Client Credentials for machine to machine communication.
- Use secure redirect URIs,
statefor CSRF protection, and keep secrets and refresh tokens on the server side. - Your backend will often act as:
- A resource server that validates tokens and enforces scopes.
- A client that calls external APIs using OAuth 2.0.
In the next related topics, you will connect OAuth 2.0 with OpenID Connect and JWTs to implement full authentication systems for your backend.
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!