13.5. Login
Table of Contents
Understanding Login in Backend Systems
Login is the process where a user proves who they are to your backend so that your system can create an authenticated session or issue tokens. In this chapter you will focus on what is unique about login compared to registration, and how to implement a secure login flow in a typical backend.
You will see examples in a style similar to Python and FastAPI, but the ideas apply to any backend stack.
What Makes Login Different From Registration
Registration creates an account. Login uses an existing account.
During registration, you:
- Check that an email or username is not already used.
- Validate password strength.
- Hash the password and store the hash.
- Possibly send verification emails.
During login, you:
- Verify that a user exists.
- Verify that the provided password matches the stored password hash.
- Decide what to return on success, for example:
- Start a session, or
- Return an access token (for example a JWT).
- Handle incorrect credentials without leaking information.
Never store or compare plain text passwords. Always compare the password using a secure password hashing function against the stored hash.
Typical Login Flow
Here is the high-level login flow you will usually implement:
- Client sends credentials to
POST /login. - Backend validates input structure, for example email format.
- Backend finds the user record from the database by email or username.
- Backend verifies the password using a password hashing library.
- Backend performs additional checks, for example:
- Is email verified?
- Is the account disabled or locked?
- Backend issues:
- A session cookie, or
- An access token (and maybe a refresh token), or
- Both tokens and cookies.
- Backend returns a response that indicates success or failure.
Here is a simple pseudo-code example:
@app.post("/login")
def login(data: LoginRequest):
user = get_user_by_email(data.email)
if not user:
raise InvalidCredentialsError()
if not verify_password(data.password, user.password_hash):
raise InvalidCredentialsError()
if not user.is_active:
raise InactiveUserError()
# For token-based auth:
access_token = create_access_token({"sub": user.id})
return {"access_token": access_token, "token_type": "bearer"}
The details of verify_password, create_access_token, and how tokens work are covered in other chapters, so here you focus on how to use them in the login process.
Designing the Login Endpoint
Choosing the HTTP Method and Path
Login is almost always:
- Method:
POST - Path: For example
/login,/auth/login, or/api/v1/login.
You use POST because you are sending sensitive data that should not appear in URLs. Also, you are creating server-side state, like a session, or returning new tokens.
Request Body vs Query Parameters
Credentials should be sent in the request body, not in query parameters.
Bad:
POST /login?email=alice@example.com&password=secret123 HTTP/1.1Good:
POST /login HTTP/1.1
Content-Type: application/json
{
"email": "alice@example.com",
"password": "secret123"
}Using the body makes it easier to avoid logging credentials accidentally, and many HTTP clients treat bodies more securely than query strings.
Request Model Example
You can define a simple request model like:
class LoginRequest(BaseModel):
email: EmailStr
password: strYou might also accept username instead of email, or both:
class LoginRequest(BaseModel):
username_or_email: str
password: strValidating Login Input
Even for login, validate the input structure before trying to authenticate.
Some examples:
- Ensure email is a valid email format, if you accept email.
- Enforce minimal password length for efficiency; do not attempt to hash obviously invalid values like blank strings.
- Limit field sizes to protect against very large requests.
Example with basic validation:
class LoginRequest(BaseModel):
email: EmailStr
password: constr(min_length=8, max_length=128)If validation fails, you respond with a 400 Bad Request, not with an "invalid credentials" error, because this is not an authentication failure, it is an invalid request format.
Looking Up the User
Once the input is valid, you need to find the user record.
Example:
def authenticate_user(email: str, password: str) -> User | None:
user = db.query(User).filter(User.email == email).first()
if not user:
return None
if not verify_password(password, user.password_hash):
return None
return userYou typically:
- Query by a unique identifier, for example email or username.
- Do not reveal in the error whether the email or username exists.
Do not return different error messages for "user does not exist" and "wrong password". Use a single generic error for both.
Verifying the Password
The verification step uses a password hashing function. From the login perspective, there are only two key operations:
hash_password(plain_password)used at registration or password change.verify_password(plain_password, stored_hash)used at login.
Example pattern:
def verify_password(plain_password: str, password_hash: str) -> bool:
return pwd_context.verify(plain_password, password_hash)You never compare the plain password string directly with anything from the database.
Timing and Security Considerations
An attacker might try to measure how long different responses take. To reduce information leaks:
- Use constant-time comparison functions provided by the password library.
- For non-existent users, perform a fake password verification step so that time is similar to the "user exists" case.
Simplified example:
DUMMY_PASSWORD_HASH = "$2b$12$dummy..."
def authenticate_user(email: str, password: str) -> User | None:
user = db.query(User).filter(User.email == email).first()
if not user:
# Fake verification to match timing.
verify_password(password, DUMMY_PASSWORD_HASH)
return None
if not verify_password(password, user.password_hash):
return None
return userHandling Additional Login Checks
Once the password is correct, you may need to enforce other business rules.
Common checks:
- Account is active:
user.is_activeis true. - Email is verified: if you require verification before login.
- Account is not locked: for example after too many failed attempts.
- User has necessary roles: for special login portals such as an admin panel.
Example:
def login(data: LoginRequest):
user = authenticate_user(data.email, data.password)
if not user:
raise InvalidCredentialsError()
if not user.is_active:
raise HTTPException(status_code=403, detail="Account is disabled")
if settings.REQUIRE_EMAIL_VERIFIED and not user.is_email_verified:
raise HTTPException(status_code=403, detail="Email not verified")
# passed all checks, issue tokens or sessionWhat to Return on Successful Login
The exact response depends on your chosen authentication method. Common patterns:
1. Session Cookie Based Login
Used heavily in traditional web apps:
- On login, you create a session record in your database or cache, for example in Redis.
- You set a secure, HTTP-only cookie like
session_idthat references that session. - The client sends this cookie with each request.
Example response:
HTTP/1.1 200 OK
Set-Cookie: session_id=abc123; HttpOnly; Secure; SameSite=Lax
Content-Type: application/json
{
"message": "Logged in successfully"
}From the login chapter viewpoint, your key task is to:
- Create the session.
- Attach the cookie to the response.
- Return a meaningful status code and optional user info.
2. Token Based Login
Often used for APIs and mobile apps:
- On login, you generate an access token that encodes or references the user.
- Often, you also generate a refresh token.
- Client stores the tokens and sends the access token in the
Authorizationheader.
Example response body:
{
"access_token": "eyJhbGciOiJIUzI1NiIs...",
"refresh_token": "eyJhbGciOiJIUzI1NiIs...",
"token_type": "bearer",
"expires_in": 3600
}From the login perspective:
- You call some
create_access_tokenfunction with user info. - You return the token(s) to the client.
- You do not store the plain tokens in the database unless you have a specific reason.
3. Hybrid Approach
You might:
- Use cookies for browser based flows.
- Use tokens for API calls.
The login endpoint can vary based on client type, for example /web/login vs /api/login.
Handling Incorrect Logins Securely
How you handle failures is crucial for security.
Status Code
For incorrect credentials use:
- 401 Unauthorized or
- 400 Bad Request for malformed requests.
- 403 Forbidden when access is denied for an otherwise authenticated or known user, for example disabled account.
A common pattern:
raise HTTPException(
status_code=401,
detail="Invalid email or password"
)Do Not Reveal Which Field Was Wrong
You should never reveal:
- Whether the email exists.
- Whether the account is active or not.
- Whether the password is close to correct.
Instead, use a generic message:
- "Invalid email or password"
- "Invalid credentials"
Limit Information in Error Messages
Avoid sending too much information in errors. For example, do not include:
- User IDs.
- Internal database queries.
- Stack traces.
Those details belong in your server logs, not in API responses.
Preventing Brute Force Attacks at Login
Login endpoints are a common target for attackers who try many passwords.
You can reduce risk by:
- Rate limiting: limit the number of login attempts per IP or per user.
- Progressive delays: add small delays after repeated failures for a specific user or IP.
- Temporary account lock: lock the account after several failed attempts.
Example logic:
def login(data: LoginRequest):
if too_many_attempts(data.email, client_ip):
raise HTTPException(status_code=429, detail="Too many login attempts")
user = authenticate_user(data.email, data.password)
if not user:
record_failed_login(data.email, client_ip)
raise HTTPException(status_code=401, detail="Invalid email or password")
clear_failed_logins(data.email, client_ip)
# continue with success flowDetails of rate limiting and tracking failed attempts are covered in other security related chapters, but you should keep the pattern in mind as part of login design.
Example End to End Login Endpoint
Here is a more complete example that puts the pieces together for a token based login:
class LoginRequest(BaseModel):
email: EmailStr
password: constr(min_length=8, max_length=128)
class LoginResponse(BaseModel):
access_token: str
token_type: str
expires_in: int
@app.post("/login", response_model=LoginResponse)
def login(data: LoginRequest, request: Request):
client_ip = request.client.host
# 1. Rate limiting
if too_many_attempts(data.email, client_ip):
raise HTTPException(status_code=429, detail="Too many login attempts")
# 2. Authenticate user
user = authenticate_user(data.email, data.password)
if not user:
record_failed_login(data.email, client_ip)
raise HTTPException(status_code=401, detail="Invalid email or password")
# 3. Additional checks
if not user.is_active:
raise HTTPException(status_code=403, detail="Account is disabled")
# 4. Clear failed attempts on success
clear_failed_logins(data.email, client_ip)
# 5. Create access token
expires_in = settings.ACCESS_TOKEN_EXPIRE_SECONDS
access_token = create_access_token(
{"sub": str(user.id)},
expires_delta=timedelta(seconds=expires_in),
)
# 6. Return response
return LoginResponse(
access_token=access_token,
token_type="bearer",
expires_in=expires_in,
)This example shows how login coordinates:
- Input validation.
- User lookup.
- Password verification.
- Security checks such as rate limiting.
- Token issuance.
Testing the Login Endpoint
You should test login carefully, because small mistakes can open serious vulnerabilities.
Create tests for:
| Scenario | Expected Outcome |
|---|---|
| Correct email and password | 200 OK, valid token or session |
| Wrong email | 401, generic error, no detail about unknown email |
| Correct email, wrong password | 401, same generic error |
| Inactive or disabled user | 403, clear but non-revealing message |
| Too many failed attempts | 429, "Too many login attempts" |
| Invalid email format | 400, validation error |
| Very short password input | 400, validation error if you enforce min length |
Example unit style test in Python:
def test_login_success(client, user_factory):
user = user_factory(email="user@example.com", password="StrongPass123!")
response = client.post("/login", json={
"email": "user@example.com",
"password": "StrongPass123!"
})
assert response.status_code == 200
data = response.json()
assert "access_token" in data
assert data["token_type"] == "bearer"Summary
In login you:
- Accept credentials via a secure
POSTendpoint. - Validate input without leaking information.
- Look up the user and verify the password using secure hashing.
- Apply additional business and security checks.
- On success, issue a session or tokens.
- On failure, return generic errors and limit information exposure.
- Consider rate limiting and account lock mechanisms to protect against brute force attacks.
Registration, password hashing details, tokens, sessions, and security are explained in their own dedicated chapters, but you now know how all of them come together in the specific case of user login.
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!