2.14. Sessions
Table of Contents
Why Sessions Exist
HTTP is a stateless protocol. Each request is independent. The server does not remember that the same browser sent a previous request.
Yet, most web apps need to remember things across requests, for example:
- Which user is logged in
- What is in a shopping cart
- User preferences like language or theme
- Multi-step forms or wizards
A session is a way to store data on the server and connect it to a particular client across multiple requests.
You can think of it as:
- Session data: a small dictionary of key-value pairs stored on the server, for example:
{"user_id": 42, "cart_items": [1, 5, 7]} - Session ID: a random unique identifier, for example:
f3a7c9b2e1... - Session token in client: the browser stores only the Session ID, often in a cookie, then sends it with every request
So the pattern is:
- Server creates a session and assigns it a session ID
- Server sends the session ID to the client (usually via a cookie)
- Client sends the session ID back with every request
- Server looks up session data using that ID
A session allows a stateless protocol (HTTP) to support stateful interactions by storing state on the server and identifying it with a session ID from the client.
Sessions vs Cookies
Sessions and cookies often appear together, but they are not the same thing.
- Cookies are a browser feature
- Sessions are an application / server concept
Core Difference
| Feature | Cookies | Sessions |
|---|---|---|
| Stored where | In the browser | On the server |
| Who controls data | Mainly the client (but set by server) | The server |
| What is stored | Small pieces of text | Any server data (objects, lists, flags, etc.) |
| Security | Visible to the user | Hidden from user, more secure |
| Typical usage | Preferences, session IDs, simple flags | User login, shopping cart, temporary state |
With sessions:
- The session ID is sent to the browser, usually in a cookie
- The session data stays on the server
Example:
- Cookie in browser:
session_id=abc123xyz - On server (in memory, DB, Redis, etc.):
abc123xyz => {
"user_id": 10,
"role": "admin",
"cart": [101, 202]
}The browser never sees the actual data. It only knows the ID.
How Sessions Work in the Request-Response Cycle
Let us walk through a typical login flow using sessions.
Step 1: User Logs In
- User submits login form:
POST /loginwith username and password. - Server checks credentials.
- If valid:
- Create a new session record on the server
- Generate a random
session_id, for example:d8a2f117-5e5a-4c0a-9a8f - Store session data on the server:
sessions["d8a2f117-5e5a-4c0a-9a8f"] = {
"user_id": 42,
"username": "alice"
}- Server sends a response with a Set-Cookie header:
HTTP/1.1 200 OK
Set-Cookie: session_id=d8a2f117-5e5a-4c0a-9a8f; HttpOnly; Secure; Path=/;- Browser stores this cookie.
Step 2: Browser Sends Session Cookie on Each Request
Next request, for example GET /profile:
GET /profile HTTP/1.1
Host: example.com
Cookie: session_id=d8a2f117-5e5a-4c0a-9a8fOn the server:
- Read
session_idfrom cookies - Look it up in session storage:
session = sessions.get("d8a2f117-5e5a-4c0a-9a8f")- If found, server knows the user is logged in as
user_id=42 - Server can then load the profile for user 42
If there is no session for that ID (for example expired or invalid), the server treats the request as from an anonymous user.
Step 3: Modifying Session Data
On POST /cart/add:
- Server gets
session_idfrom cookie - Looks up session:
session = sessions.get("d8a2f117-5e5a-4c0a-9a8f")
session["cart"].append(new_item_id)- Saves updated session back to storage
From the browser side, nothing changes. It still only sends session_id.
Step 4: Logging Out and Session Destruction
On POST /logout:
- Server reads the
session_idcookie - Deletes the session from storage:
sessions.pop("d8a2f117-5e5a-4c0a-9a8f", None)- Optionally tells browser to delete the cookie:
Set-Cookie: session_id=deleted; Max-Age=0; Path=/;
From then on, the session_id no longer points to valid data, so the user is effectively logged out.
Session Storage Options
Sessions can be stored in different places on the server side. Each option has tradeoffs.
| Storage Type | Where it lives | Pros | Cons |
|---|---|---|---|
| In memory | RAM of the app server | Very fast, simple | Lost on restart, hard with multiple servers |
| File based | Local disk | Simple, persists across restarts | Slower, not good for many servers |
| Database | Relational / NoSQL DB | Persistent, scalable | Adds DB load and some latency |
| Cache store | Redis, Memcached | Very fast, good for scaling | Extra infrastructure, sessions might be lost |
For a single small app:
- In memory or file-based sessions are often acceptable
For production apps with many users and multiple servers:
- Centralized storage such as Redis or a database is common
Example of how mapping works conceptually:
| session_id | session data |
|---|---|
d8a2f117-5e5a-4c0a-9a8f | {"user_id": 42, "cart": [101, 202]} |
5d44ec83-d163-476b-b658-7c8fbfb6 | {"user_id": 19, "theme": "dark"} |
This table can live in memory, Redis, PostgreSQL, etc.
Session IDs and Security
The entire security of sessions depends on the session ID. If an attacker gets it, they can act as that user.
So session IDs must be:
- Random and unpredictable, not simple counts like
1,2,3 - Long enough to prevent guessing
- Protected in transit using HTTPS
- Stored securely in cookies with security flags
The session ID is as sensitive as a password for the lifetime of the session. If someone steals it, they can hijack the session and impersonate the user.
Common protections:
- Use a cryptographically secure random generator for IDs
- Use HTTPS so session cookies cannot be easily sniffed
- Use cookie security flags such as:
HttpOnlyto prevent JavaScript from reading the cookieSecureto only send cookie over HTTPS- Regenerate session IDs on login or role change to reduce fixation attacks
- Set session expiration so old sessions eventually die
Session Lifetime and Expiration
Sessions should not live forever.
Types of expiration
- Absolute expiration
- Session expires after a fixed time, for example 24 hours from creation
- Even if user is active, session eventually ends
- Idle timeout
- Session expires if there is no activity for a period, for example 30 minutes
- Each request can reset the timer
- Manual invalidation
- The server can invalidate sessions explicitly
- For example on logout, password change, admin action
On the server, you might store timestamps:
session = {
"user_id": 42,
"created_at": 1724700000, # Unix timestamp
"last_seen": 1724706000
}Then on each request:
- Check
created_atandlast_seen - If too old, delete session and force login
Example rule:
A common policy:
- Absolute expiration: $24 \text{ hours}$
- Idle timeout: $30 \text{ minutes}$
Whichever limit is hit first ends the session.
Stateless vs Stateful Sessions
There are two broad approaches to sessions.
1. Stateful Sessions
This is what we have described so far:
- Server keeps session data
- Client only has a session ID
Characteristics:
- Stateful server, because it must remember sessions
- Easy to invalidate a session by deleting it server side
- Can store arbitrary data in session
- Harder to scale if stored in only one server, needs shared storage
Most classic web frameworks (Django, Rails, etc.) use stateful sessions.
2. Stateless Sessions
Here, the session data itself is stored on the client side, typically in a signed or encrypted token such as a JSON Web Token (JWT).
- Server does not store session state
- Server only verifies token and reads data from it
Characteristics:
- Server is stateless concerning sessions
- Easier to scale horizontally, no shared session storage
- Harder to invalidate a token before it expires, because server might not keep a list of them
- Token size and content must be carefully designed
For this chapter, the main idea is the contrast:
| Aspect | Stateful sessions | Stateless sessions |
|---|---|---|
| Data lives | On the server | In token on client |
| Client stores | Session ID | Whole session token |
| Scaling | Needs shared store or stickiness | Easier to scale, no shared store needed |
| Invalidation | Easy, delete on server | Harder, often requires blacklists |
You will see more details when you study tokens and JWTs later.
Session Use Cases and Examples
To solidify the concept, here are some typical session uses.
Example 1: Remembering Login State
Without sessions:
- After login, the server would not know who you are on the next request
With sessions:
- After successful login:
session["user_id"] = user.id
session["username"] = user.username- On any route requiring authentication:
if "user_id" not in session:
return redirect("/login")
The framework hides the cookie and lookup details from you. You work with the session object.
Example 2: Shopping Cart
You can implement a simple cart without requiring the user to log in.
- When a new visitor arrives without a session, create one and assign an ID.
- Store cart items in session:
session.setdefault("cart", [])
session["cart"].append(product_id)- When displaying cart:
cart_items = session.get("cart", [])If the user closes the browser and returns before session expiration, the cart is still there.
Example 3: Flash Messages
Some frameworks use sessions for one-time messages, for example:
- "Your profile has been updated"
- "Invalid password"
Implementation idea:
- On POST /profile/update success:
session["flash"] = "Profile updated successfully."- On next page load:
message = session.pop("flash", None) # read and remove- Show
messageif it exists
This uses the session as temporary storage between two requests.
Common Pitfalls with Sessions
Beginners often make similar mistakes when working with sessions.
1. Storing Too Much Data
Sessions are for small pieces of data. Avoid storing:
- Large objects
- Files
- Big lists or query results
Problems:
- Memory or storage growth
- Slower lookups
- More network traffic if using a remote session store
Keep it small:
- User ID, not full user object
- Product IDs, not full product details
2. Relying Only on Sessions for Security
Session checks are important, but you still need:
- Proper authorization checks
- Input validation
- Protection against CSRF and other attacks
A valid session does not mean the request is safe.
3. Forgetting to Clear Sessions on Sensitive Changes
If a user:
- Changes password
- Disables their own account
- Changes permissions or role
You might want to:
- Invalidate existing sessions
- Force re-login
Otherwise, old sessions might still be valid.
4. Not Using HTTPS with Session Cookies
Sending session cookies over plain HTTP exposes them to eavesdropping.
Always protect real user sessions with HTTPS and the Secure cookie flag.
Summary
- HTTP is stateless, so it does not remember users across requests.
- Sessions allow the server to remember data across multiple requests from the same client.
- A session typically uses:
- Session data on the server
- A session ID stored in a cookie on the client
- Cookies are the delivery mechanism, sessions are the data model on the server.
- Sessions can be stored in memory, files, databases, or cache stores like Redis.
- Session security focuses on protecting the session ID, using randomness, HTTPS, and cookie flags.
- Sessions have lifetimes and timeouts to limit risk and resource use.
- There are stateful and stateless approaches to sessions, each with tradeoffs.
- Sessions power common features like login, carts, and flash messages.
Understanding sessions gives you the missing piece for building web applications that feel persistent and personalized on top of a stateless protocol.
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!