13.11. OpenID Connect
Table of Contents
Why OpenID Connect Exists
OpenID Connect (OIDC) is an authentication layer built on top of OAuth 2.0.
You already learned that OAuth 2.0 is mainly about authorization. It lets an application (the client) get permission to access some resources on behalf of a user, usually through access tokens.
However, OAuth 2.0 by itself does not clearly define:
- Who the user is.
- How to get the user’s profile information.
- How to safely represent the logged-in user in a standard way.
Different providers (Google, Facebook, GitHub) all invented their own solutions on top of OAuth. This led to confusion and many custom implementations.
OpenID Connect fixes this by defining:
- How to perform user login using OAuth 2.0.
- How to get a standard identity token that says who the user is.
- How to get standard user profile data.
In short:
- OAuth 2.0: “Can this app access this resource?”
- OpenID Connect: “Who is this user?” and “Log this user in.”
Key idea: OpenID Connect = OAuth 2.0 + a standard way to authenticate users and get their identity.
This is very useful for backend developers, because you can integrate with existing identity providers and avoid storing passwords yourself.
Core Concepts
To understand OpenID Connect, you need to recognize a few core building blocks.
Parties Involved
OIDC uses the same main roles as OAuth 2.0, but adds the idea of identity:
| Role | Description in OIDC context |
|---|---|
| End-User | The human who wants to log in. |
| Relying Party (RP) | Your application, which relies on OIDC to authenticate users. |
| OpenID Provider (OP) | The identity provider that authenticates users and issues tokens. Examples: Google, Auth0, Okta, Keycloak. |
| Resource Server | Where APIs live that are protected by access tokens. Often your backend API. |
Your backend application is usually both:
- A Relying Party for login.
- A Resource Server for its own API, which accepts access tokens.
ID Token
The most important thing OIDC adds is the ID Token.
An ID token:
- Is a JWT (JSON Web Token).
- Is issued by the OpenID Provider.
- Contains information about the user, for example:
sub(subject, unique user ID)nameemailpicture- Contains information about the token itself:
iss(issuer)aud(audience, who this token is for)exp(expiration time)iat(issued at)
Your backend uses the ID token to know who the user is.
Important: In OpenID Connect, authentication is represented by the ID token, not the access token.
Access tokens are still used to call APIs, but ID tokens are used to log the user in.
UserInfo Endpoint
OpenID Connect defines a standard UserInfo endpoint on the OpenID Provider.
- You call it with a valid access token.
- It returns a JSON object with user information:
subnameemail- Others, depending on the provider and scopes.
Example response:
{
"sub": "1234567890",
"name": "Alice Example",
"email": "alice@example.com",
"email_verified": true,
"picture": "https://example.com/avatar.png"
}You can use the ID token and UserInfo endpoint together:
- ID token: quick identity information, signed, can be validated without a network call.
- UserInfo: extra profile data, fetched on demand.
Scopes
OIDC defines some standard scopes to request specific pieces of identity data:
| Scope | Meaning |
|---|---|
openid | Required for any OIDC request. Turns OAuth into OIDC. |
profile | Basic profile info (name, family_name, given_name, etc.). |
email | Email and email_verified. |
address | Postal address. |
phone | Phone number info. |
If you do not include openid scope, you are using pure OAuth 2.0, not OpenID Connect.
Example scope string:
openid profile emailHow OpenID Connect Extends OAuth 2.0
OpenID Connect does not replace OAuth 2.0. It reuses:
- Authorization endpoints
- Token endpoints
- Redirect flows
- Access tokens
Then it adds:
- ID tokens
- Standard claims
- Standard endpoints (UserInfo, discovery)
- Security rules about how to use them
Authorization Code Flow with OIDC
The most important OpenID Connect flow for web backends is:
- Authorization Code Flow, often with PKCE for extra security.
The steps look very similar to OAuth 2.0, but with OIDC-specific details.
Step-by-step Flow
- User clicks “Login with X”
Your backend (or frontend) redirects the user to the OpenID Provider’s authorization endpoint:
Example URL (wrapped for readability):
https://accounts.example.com/authorize
?response_type=code
&client_id=YOUR_CLIENT_ID
&redirect_uri=https://your-app.com/callback
&scope=openid%20profile%20email
&state=RANDOM_STRING
&code_challenge=SOME_HASH
&code_challenge_method=S256
Key OIDC detail: scope includes openid.
- User logs in at the provider
The OpenID Provider shows its login page and authenticates the user.
- Provider redirects back with an authorization code
After successful login, the OP redirects to your redirect_uri:
https://your-app.com/callback
?code=AUTHORIZATION_CODE
&state=RANDOM_STRING- Backend exchanges code for tokens
Your server sends a POST request to the OP’s token endpoint:
POST /oauth/token
Content-Type: application/x-www-form-urlencoded
grant_type=authorization_code&
code=AUTHORIZATION_CODE&
redirect_uri=https://your-app.com/callback&
client_id=YOUR_CLIENT_ID&
client_secret=YOUR_CLIENT_SECRET&
code_verifier=ORIGINAL_CODE_VERIFIERThe response includes:
{
"access_token": "ACCESS_TOKEN_VALUE",
"id_token": "ID_TOKEN_JWT",
"token_type": "Bearer",
"expires_in": 3600,
"refresh_token": "REFRESH_TOKEN_VALUE"
}
OIDC addition: the id_token.
- Backend validates the ID token
Your backend must:
- Decode the JWT.
- Verify its signature using the OP’s public keys.
- Check important claims:
issmatches expected issuer.audcontains yourclient_id.expis in the future.nonceif you used it (mostly for browser-based apps).
After validation, you can trust the sub and other user claims.
- Backend creates a local session or issues its own token
Common patterns:
- Create a local user record (if it does not exist).
- Link the OIDC
subto your local user. - Create your own session cookie or JWT that your API will use.
- Using the access token
- If your backend also needs to call APIs protected by the OP, it uses the access token.
- To get more user profile data, call the UserInfo endpoint with the access token.
OIDC vs Bare OAuth 2.0 in the Flow
| Step | OAuth 2.0 only | OAuth 2.0 + OIDC |
|---|---|---|
| Authorization request | response_type=code | Same, but scope includes openid. |
| Tokens returned | Access + optional refresh token | Access + ID token + optional refresh token. |
| Identity information | Not standardized | ID token + UserInfo endpoint with standard claims. |
So OpenID Connect is really about giving authentication a formal, interoperable shape.
Tokens in OpenID Connect
OIDC involves different kinds of tokens. As a backend developer, you must understand how to use each correctly.
ID Token
- Format: JWT.
- Intended audience: the client (your app).
- Purpose: prove the identity of the user.
Typical ID token payload example:
{
"iss": "https://accounts.example.com",
"sub": "1234567890",
"aud": "your-client-id",
"exp": 1727700000,
"iat": 1727696400,
"nonce": "abc123nonce",
"name": "Alice Example",
"email": "alice@example.com",
"email_verified": true,
"picture": "https://example.com/avatar.png"
}Important claims:
| Claim | Description |
|---|---|
iss | Issuer, must match the provider’s URL. |
sub | Subject, unique ID of the user at this provider. |
aud | Audience, must include your client_id. |
exp | Expiration time, in seconds since Unix epoch. |
iat | Issued-at time. |
nonce | Optional, used mainly in browser-based flows to prevent replay. |
Rule: Never use the ID token to directly authorize access to protected resources. Use access tokens for API authorization. Use ID tokens for who the user is.
Access Token
- Possibly a JWT, but can be opaque (provider’s choice).
- Used to access APIs (resource servers).
- OIDC does not fully define its content, but defines how it is obtained.
Your backend validates the access token whenever a client calls your API. You learned how to handle JWTs in the tokens and JWT chapters.
Refresh Token
- Optional.
- Used by your backend to get new access tokens (and sometimes new ID tokens) from the token endpoint.
- Should be stored securely on the server side, not in the browser.
Example: Login with Google using OpenID Connect
Let us look at a concrete scenario that many backends implement: “Log in with Google”.
Assume:
- Your backend is at
https://myapp.com. - You registered an OAuth 2.0 / OIDC client at Google.
- You have:
client_idclient_secretredirect_uri=https://myapp.com/auth/google/callback
1. Redirect User to Google
When the user clicks “Login with Google”, your backend sends them to:
https://accounts.google.com/o/oauth2/v2/auth
?client_id=YOUR_CLIENT_ID
&redirect_uri=https://myapp.com/auth/google/callback
&response_type=code
&scope=openid%20profile%20email
&state=RANDOM_STATE
&access_type=offline
&prompt=consent
Key OIDC detail: scope=openid profile email.
2. User Logs in and Grants Access
Google shows:
- Login form (if not already logged in).
- Consent screen asking if your app can see basic profile and email.
After acceptance, Google redirects to your callback:
https://myapp.com/auth/google/callback
?code=AUTH_CODE
&state=RANDOM_STATE
You verify state to avoid CSRF attacks.
3. Exchange Code for Tokens
Your backend sends a POST request:
POST https://oauth2.googleapis.com/token
Content-Type: application/x-www-form-urlencoded
code=AUTH_CODE&
client_id=YOUR_CLIENT_ID&
client_secret=YOUR_CLIENT_SECRET&
redirect_uri=https://myapp.com/auth/google/callback&
grant_type=authorization_codeGoogle responds:
{
"access_token": "ACCESS_TOKEN",
"expires_in": 3599,
"refresh_token": "REFRESH_TOKEN",
"scope": "openid https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email",
"token_type": "Bearer",
"id_token": "JWT_ID_TOKEN"
}4. Decode and Verify the ID Token
Your backend:
- Decodes
id_tokenas a JWT. - Fetches Google’s public keys from the discovery document (more on that below).
- Verifies:
- Signature.
issishttps://accounts.google.comoraccounts.google.com.audis yourclient_id.expis not expired.
Then you read:
sub: Google user ID.email: user email.email_verified: whether email is verified.name,picture.
You can then:
- Create or find a local user record.
- Log them in by creating a local session cookie or your own JWT.
5. (Optional) Call UserInfo Endpoint
You can also call Google’s UserInfo endpoint:
GET https://openidconnect.googleapis.com/v1/userinfo
Authorization: Bearer ACCESS_TOKENGoogle returns JSON with standard OIDC claims.
Discovery and Configuration
One of the practical benefits of OpenID Connect is discovery.
An OpenID Provider usually exposes a well-known configuration endpoint:
https://provider.com/.well-known/openid-configurationThis is a JSON document that describes:
issuerauthorization_endpointtoken_endpointuserinfo_endpointjwks_uri(JSON Web Key Set, for verifying tokens)- supported scopes, response types, etc.
Example (simplified):
{
"issuer": "https://accounts.example.com",
"authorization_endpoint": "https://accounts.example.com/authorize",
"token_endpoint": "https://accounts.example.com/oauth/token",
"userinfo_endpoint": "https://accounts.example.com/userinfo",
"jwks_uri": "https://accounts.example.com/.well-known/jwks.json",
"response_types_supported": ["code", "id_token", "code id_token"],
"scopes_supported": ["openid", "profile", "email"]
}
The JWKS document at jwks_uri contains the public keys used to sign ID tokens. Your backend loads these keys and uses them to validate JWT signatures.
This makes it easier to work with multiple providers because your backend does not need manually configured public keys.
Typical Backend Patterns with OpenID Connect
As a backend developer, you will often use OIDC in one of these patterns.
Pattern 1: Backend-Rendered Web App with OIDC Login
- Your app renders HTML pages.
- Login button redirects to the OIDC provider.
- Callback handler exchanges code for tokens and creates a server-side session.
- Session ID is stored in a secure, HTTP-only cookie.
- Backend may also store:
- OIDC
sub - ID token (short lived)
- Refresh token (for API calls on the user’s behalf)
In this pattern, the browser never sees the access or refresh tokens directly.
Pattern 2: SPA Frontend + Backend API
- Frontend (SPA) uses OIDC flow in the browser.
- SPA gets ID token and access token.
- SPA calls your backend API with access token.
- Your backend validates the access token and authorizes the user.
There are more security details here, but the general idea is similar to using JWTs for authentication.
Pattern 3: Backend API protects endpoints with OIDC tokens
- Clients (mobile apps, SPAs, other servers) obtain OIDC tokens from the provider.
- They send access tokens to your API.
- Your API validates access tokens and extracts user information (like
sub,email,scope). - You map
subto your internal user and apply authorization.
How OpenID Connect Works with Your Own Authentication
You might build both:
- A local authentication system (email + password).
- OIDC logins (“Login with Google”, “Login with GitHub”).
A common approach:
- For email/password:
- Store hashed passwords.
- Issue JWTs or session cookies.
- For OIDC:
- Never store OIDC-provider passwords.
- Store only:
- Provider name (for example
google) - Provider
sub - Some basic profile data (email, name)
- Link to local user ID.
- When a user logs in with OIDC:
- Use
sub+ provider to find or create a local user. - Issue your own local tokens or sessions as usual.
The backend logic is then unified: all authenticated users have local user IDs, no matter how they logged in.
Important Security Considerations
OpenID Connect is powerful, but you must use it correctly.
- Always validate ID tokens:
- Check signature.
- Check
iss,aud, andexp. - Never trust unsigned or unverified tokens.
- Use
stateparameter to prevent CSRF in login flow. - Use HTTPS everywhere to protect tokens in transit.
- Do not store tokens in insecure places like localStorage for high security use cases without understanding the risks.
- Use PKCE in public clients (SPA, mobile) to protect authorization codes from being stolen.
Do not implement your own OpenID Connect server from scratch as a beginner. Use well-tested identity providers or libraries. Mistakes here often lead to serious security vulnerabilities.
Summary
OpenID Connect:
- Builds on top of OAuth 2.0.
- Adds a clear way to authenticate users.
- Gives you ID tokens that describe who the user is.
- Provides a standard UserInfo endpoint and scopes to get user data.
- Uses the standard OAuth 2.0 authorization code flow, with extra rules and fields.
For backend development, OpenID Connect lets you:
- Use external identity providers like Google, Auth0, Okta, or your company’s SSO.
- Avoid handling passwords directly for those logins.
- Integrate multiple login methods into a single user system in your application.
Later, when you build real projects, you will likely use libraries or frameworks that implement the OIDC details for you, but understanding these concepts helps you configure and debug those integrations correctly.
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!