What are Sessions?
Sessions store user state on the server between requests. A session ID (usually in a cookie) links the client to its server-side session data.
How Sessions Work
1. User logs in
POST /api/login { username, password }
2. Server creates session
session_id = generate_uuid()
store.set(session_id, { userId: 123, role: "admin" })
3. Server sends session cookie
Set-Cookie: session_id=abc-123; HttpOnly; Secure
4. Subsequent requests include cookie
Cookie: session_id=abc-123
5. Server looks up session
session = store.get("abc-123")
user = session.userId // 123
Session Storage Options
| Storage | Speed | Persistence | Scalability |
|---|---|---|---|
| Memory | Fastest | Volatile | Single server |
| Redis | Fast | Persistent | Distributed |
| Database | Slow | Persistent | Distributed |
| File | Slow | Persistent | Single server |
Session vs JWT
Session-Based Auth:
Client --> Cookie(session_id) --> Server
|
+--> Lookup session in store
+--> Return user data
JWT-Based Auth:
Client --> Header(Authorization: Bearer <token>) --> Server
|
+--> Decode token
+--> Extract user data
| Aspect | Session | JWT |
|---|---|---|
| Storage | Server-side | Client-side |
| State | Stateful | Stateless |
| Scalability | Harder (shared store) | Easier |
| Revocation | Easy (delete session) | Hard (expire token) |
| Size | Small (ID only) | Can grow with claims |
Session Management
Session Security
- Generate cryptographically random IDs
- Set appropriate timeout
- Implement session fixation protection
- Use secure cookie flags
Configuration
HttpOnly: true
Secure: true
SameSite: Lax/Strict
Path: /
Max-Age: appropriate timeout
Best Practices
- Invalidate on logout
- Implement concurrent session limits
- Monitor session anomalies
Key Points
- Understanding Sessions is essential for production systems
- Always consider scalability and maintainability
- Test thoroughly before deploying to production
- Monitor performance and set up alerting
Common Patterns
- Validation: Always validate input at the boundary
- Error Handling: Use structured error responses
- Logging: Log key events for debugging
- Testing: Unit, integration, and load tests
- Documentation: Keep docs updated with code changes
Practice Problems
Design and implement a solution for Sessions in a backend system. Consider scalability, error handling, and production readiness.
Solution
// Sessions implementation
// Key aspects: validation, error handling, logging, testing
public class Sessions {
// Production-ready implementation
} Identify and handle edge cases for Sessions. What happens under high load, with invalid input, or during failures?
Solution
// Edge case handling:
// 1. Null/empty input -> validation
// 2. High load -> rate limiting, queuing
// 3. Failures -> retries, circuit breaker
// 4. Concurrent access -> locks, idempotency Write a testing strategy for Sessions. Include unit tests, integration tests, and performance tests.
Solution
// Test plan:
// - Unit: 80% coverage target
// - Integration: API contracts
// - Performance: latency, throughput
// - Chaos: failure injection Quiz
1. Where is session data stored?
2. What is the main advantage of sessions over JWT?
3. What is a common mistake when implementing Sessions?
Flashcards
Question
What is a session?
Click to reveal answer
Answer
Server-side storage of user state, linked to client via session ID
Question
Session vs JWT?
Click to reveal answer
Answer
Session=server-side (revocable), JWT=client-side (stateless)
Question
Sessions best practices
Click to reveal answer
Answer
Follow SOLID principles, write clean code, test thoroughly, document decisions, and monitor in production.
Revision Notes
Key Takeaways
- 1. Sessions store user state on the server
- 2. Session ID in cookie links client to server data
- 3. Redis is the most popular session store
- 4. Sessions are revocable; JWTs are not (by default)
Interview Tips
- • Compare session-based and JWT-based auth
- • Know session storage trade-offs
Cheat Sheet
Sessions
- How: Server stores state, client holds session ID (cookie)
- Storage: Redis (best), Database, Memory
- vs JWT: Session=stateful+revocable, JWT=stateless
- Security: HttpOnly, Secure, SameSite cookies