13.13. Logout
Table of Contents
Why Logout Matters
Logout looks very simple to the user, but it is a critical security feature.
A user clicks “Logout,” and you must make sure that:
- Their current session or token can no longer be used.
- Any sensitive data is cleared from the browser and the server.
- They cannot accidentally stay logged in on a shared computer.
If logout is weak or incomplete, attackers can reuse old cookies or tokens and access accounts.
Rule: Logout is not “just hide the UI.”
You must invalidate authentication credentials (session, token, etc.) on the server side.
In this chapter you will see how logout works with sessions, tokens, and common backend patterns.
Logout in Session-Based Authentication
In session-based systems, the browser stores a session cookie like:
Cookie: session_id=abc123
The server stores session data for abc123 in memory, Redis, or a database.
To log out, you must do two things:
- Remove or invalidate the server-side session.
- Remove the cookie in the browser.
Server-Side Session Invalidation
For a typical web framework, logout might:
def logout(request):
session_id = request.cookies.get("session_id")
if session_id:
delete_session_from_store(session_id) # remove from DB / Redis
response = redirect_to_login()
response.delete_cookie("session_id") # tell browser to drop cookie
return response
The key part is delete_session_from_store. After this, even if the cookie is stolen or not deleted yet, the server will not find a valid session.
Common mistakes:
- Only deleting the cookie and leaving the session in the database.
- Only clearing session data in memory and not removing the record.
If your session store is Redis, logout might be as simple as:
redis_client.delete(f"session:{session_id}")or in SQL:
DELETE FROM sessions WHERE id = 'abc123';Rule: With sessions, logout must destroy or invalidate the server-side session record, not just rely on the browser.
Clearing the Session Cookie
The backend tells the browser to remove the cookie by setting it again with an expiration in the past:
Set-Cookie: session_id=deleted; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT; HttpOnly; SecureFrameworks usually provide helpers like:
response.delete_cookie("session_id")Important details:
- Use the same
Path,Domain, andSecure/HttpOnlysettings as when you set the cookie. - If they differ, the browser might keep an old cookie.
Logout Flow Example (Sessions)
- User clicks “Logout” link that sends
POST /logoutwith cookiesession_id=abc123. - Backend handler:
- Reads session id from cookie.
- Deletes session from store.
- Returns response that clears cookie and redirects to
/login. - Any future request with
session_id=abc123will fail, since the session is gone.
Logout in Token-Based Authentication
In token-based systems (for example JWTs) the browser or client stores an access token, sometimes a refresh token too.
A typical Authorization header:
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...Basic idea
- The token itself is the proof of authentication.
- The server often does not store each access token in a database.
- Token expiry is embedded in the token, for example
$exp$claim in JWT.
So how do you “logout” if the server does not store tokens?
You have two jobs:
- On the client, remove the token.
- On the server, optionally prevent reuse of some tokens (especially refresh tokens).
Client-Side Token Removal
For a single-page application:
function logout() {
localStorage.removeItem('access_token');
localStorage.removeItem('refresh_token');
window.location.href = '/login';
}
Or, if you used HttpOnly cookies for tokens, the backend must send Set-Cookie headers that clear those cookies, just like with session cookies.
Example response on logout:
Set-Cookie: access_token=; HttpOnly; Secure; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT
Set-Cookie: refresh_token=; HttpOnly; Secure; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMTServer-Side Token Revocation
If tokens are short-lived (for example 5 minutes) and only access tokens exist, many systems do not store them. Logout is basically:
- Client forgets the token.
- Server just waits for the token to expire.
However, when you use refresh tokens, you typically store them in a database. Logout must revoke or delete them.
Example data:
| user_id | refresh_token_id | token_value | expires_at |
|---|---|---|---|
| 5 | 1 | 9f21... | 2026-12-01 12:00:00 |
On logout:
def logout(current_user, refresh_token_id):
db.execute(
"DELETE FROM refresh_tokens WHERE id = %s AND user_id = %s",
(refresh_token_id, current_user.id)
)
response = Response(status_code=204)
response.delete_cookie("refresh_token")
response.delete_cookie("access_token")
return responseNow that refresh token can never be used to get a new access token.
Rule: In token-based systems with refresh tokens, logout must revoke or delete the refresh token on the server.
Logout Endpoints and HTTP Methods
A logout is not a simple “view” of data, it changes authentication state. Because of that, you should not use GET /logout with no protection.
A safer design:
- Use
POST /logout(orDELETE /sessions/current). - Require a valid access token or session.
- Remove server-side credentials.
- Clear cookies.
- Return 204 No Content or 200 OK.
Example REST design:
| Action | Method | Path | Description |
|---|---|---|---|
| Login | POST | /auth/login | Create session / token |
| Logout | POST | /auth/logout | Destroy current session |
| Logout all | POST | /auth/logout-all | Invalidate all sessions |
Example FastAPI style logout handler (session-based):
from fastapi import APIRouter, Response, Depends
router = APIRouter()
@router.post("/logout")
def logout(response: Response, current_user=Depends(get_current_user)):
# remove user sessions from store, example:
delete_sessions_for_user(current_user.id)
response.delete_cookie("session_id")
return {"detail": "Logged out"}You typically want CSRF protection for logout if it is cookie-based, since a POST request can be triggered from another site.
Logout from All Devices
Sometimes the user clicks “Logout from all devices” or “Log out everywhere.” This is especially important for security after password change.
The implementations differ for sessions vs tokens.
Sessions: Invalidate All User Sessions
Your session store may link sessions to users:
| session_id | user_id | created_at |
|---|---|---|
| abc123 | 42 | 2026-01-01 10:00:00 |
| def456 | 42 | 2026-01-02 13:00:00 |
To logout from all devices:
DELETE FROM sessions WHERE user_id = 42;Every device that tries to use an old cookie will fail.
Tokens: Invalidate All Refresh Tokens
If you store refresh tokens:
| id | user_id | token_value | expires_at |
|---|---|---|---|
| 1 | 42 | aaaa... | 2026-02-01 00:00:00 |
| 2 | 42 | bbbb... | 2026-02-15 00:00:00 |
Logout all devices:
DELETE FROM refresh_tokens WHERE user_id = 42;Optionally, for access tokens, many systems rely on short lifetimes and do not store them. After logout-all:
- All refresh tokens are invalid.
- Remaining access tokens die naturally after a short time.
Handling Logout in Single-Page Applications (SPAs)
In SPAs, the frontend often controls navigation and state. Backend still controls security.
A typical SPA logout flow:
- User clicks “Logout” button.
- Frontend sends
POST /auth/logoutto backend with the current credentials. - Backend:
- Deletes session or revokes refresh token.
- Clears cookies if used.
- Returns 204.
- Frontend:
- Clears any local storage tokens.
- Clears any user state in memory (like React context or Vuex).
- Redirects to
/loginor a public page.
Example (React-ish pseudocode):
async function handleLogout() {
try {
await api.post('/auth/logout'); // backend invalidates
} catch (e) {
// ignore errors, still clear local state
}
localStorage.removeItem('access_token');
localStorage.removeItem('refresh_token');
setUser(null);
navigate('/login');
}Rule: Frontend must clear its own copy of authentication data, but real logout security depends on what the backend does.
Security Considerations and Common Pitfalls
Logout is part of your security design. Done poorly, it gives a false feeling of safety.
Using GET /logout Without Protection
If logout is triggered by a simple GET /logout, any site can embed an image:
<img src="https://your-app.com/logout" />This would log users out without their intention. While this is not as bad as logging them in or changing data, it can be annoying and may break flows.
A better design:
- Use
POST /logout. - Use CSRF protection for cookie-based authentication.
Not Invalidating Server-Side State
Common mistake:
- Only deleting the cookie.
- Or only clearing localStorage.
If sessions or refresh tokens remain valid, an attacker who already has a copy can keep using them.
Always:
- Destroy sessions.
- Revoke refresh tokens.
Not Handling Multiple Devices
Users may log in from:
- Laptop
- Phone
- Shared computer
Profile actions like “Change password” or “Report stolen phone” should often:
- Trigger “logout all devices”.
- Maybe create a different “logout all devices except this one”.
This means your data model must support finding all active sessions or tokens for a user.
Long-Lived Tokens Without Revocation
If access tokens live for many days and you do not have any revocation list, logout becomes weak. An attacker who steals the token can keep using it until it expires.
Safer approach:
- Use short-lived access tokens, for example 5 to 15 minutes.
- Use longer-lived refresh tokens with server-side storage and revocation on logout.
Implementing Token Blacklists
If you must be able to immediately revoke access tokens before they expire, you can keep a blacklist or a “version” strategy.
Blacklist example
- On logout, store the token id (for example JWT
jticlaim) in a blacklist store with its expiry. - On every request, check if
jtiis blacklisted.
This adds overhead, but allows instant logout.
Version (token version) example
- Add a
token_versionto the user record. - Include
token_versionin the JWT when issuing it. - On logout-all, increment
token_versionin the database. - When validating a token, check that the token’s
token_versionmatches the user’s current one.
Any old tokens with the previous version are automatically invalid.
Example table:
| user_id | token_version |
|---|---|
| 100 | 5 |
On logout-all:
UPDATE users SET token_version = token_version + 1 WHERE id = 100;Token payload:
{
"sub": 100,
"token_version": 5,
"exp": 1735707600
}
If token_version in DB becomes 6, all old tokens with token_version: 5 are invalid.
User Experience Around Logout
While security is the main goal, UX also matters.
Good practices:
- Clear feedback: Show a “You have been logged out” message or redirect to a known page.
- Idempotent behavior: If a user hits logout twice, do not show scary errors; just treat second logout as success again.
- Safe redirects: After logout, redirect only to safe URLs:
- Do not trust arbitrary
next=query parameters from external sites. - Instead, validate redirect targets or use a fixed one like
/login.
Example response:
{
"detail": "Logged out successfully"
}Even if the session did not exist, returning success is usually fine. Do not leak information about whether the user was logged in or not.
Summary
You have seen how logout works for different authentication styles:
- Sessions: Delete the session in the store and clear the cookie.
- Tokens: Remove tokens from client storage and revoke refresh tokens (and maybe access tokens).
- Logout endpoints: Use
POST /logout, not unprotectedGET /logout. - Logout all devices: Delete all sessions or tokens for a user.
- Security: Proper logout must invalidate credentials on the server side, not just hide the UI or clear local state.
With these patterns, you can implement logout that is both user friendly and secure.
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!