13.2. Password Storage
Table of Contents
Why Password Storage Matters
When users create an account, they trust you with their passwords. If you store those passwords incorrectly, a database leak can instantly expose every account.
A backend developer must never store passwords in plain text. Even storing them with "simple encryption" is not enough. Proper password storage uses strong one‑way hashing with additional protections.
NEVER store plain text passwords. NEVER be able to read users' passwords.
In this chapter, you will see how to store passwords safely, what can go wrong, and how to use hashing correctly.
Plain Text Storage and Why It Is Dangerous
What Is Plain Text Storage?
Plain text storage means you keep the password exactly as the user typed it.
Example table in your database:
| user_id | password | |
|---|---|---|
| 1 | alice@example.com | mysecret123 |
| 2 | bob@example.com | 123456 |
| 3 | charlie@example.com | qwerty |
If an attacker gets a copy of this table, they immediately know every user’s password.
Dangers of Plain Text Passwords
Plain text passwords are dangerous because:
- Any data leak reveals all passwords immediately.
- Developers, admins, or support staff can see user passwords.
- Users reuse passwords. Attackers will try the same password on:
- Email accounts
- Social media
- Other websites
- Your service loses trust. If users know you stored plain text, your reputation is damaged.
Even if you think your database is "internal" or "safe," you must assume it can be stolen one day.
If you can tell a user their current password, your storage is already wrong.
Why Encryption Is Not Enough
What Is Encryption?
Encryption is a two‑way process:
- You encrypt data with a key to hide it.
- You can decrypt it with the same key (symmetric) or a related key (asymmetric).
Example idea (not real code):
encrypted_password = encrypt("mysecret123", key)
plain_password = decrypt(encrypted_password, key)Encryption is used for:
- Securing data in transit (HTTPS, TLS)
- Securing data at rest where you need to read it again (stored credit card numbers in some systems, secrets, etc.)
Why Encryption Is Wrong for Password Storage
For login, you never need to know the original password, you only need to verify "does the user know the password?"
If you use encryption:
- Anyone who gets the key can decrypt every password.
- The backend itself must keep the key available to verify logins.
- Malicious insiders or attackers who get server access can read all passwords.
So encryption turns password storage into "hidden plain text." It does not remove the danger.
Passwords must be stored using one‑way hashing, not reversible encryption.
One‑Way Hashing
What Is a Hash Function?
A hash function turns any input into a fixed‑length output.
Example idea:
hash("mysecret123") = "e99a18c428cb38d5f260853678922e03"
hash("hello") = "5d41402abc4b2a76b9719d911017c592"Characteristics of a cryptographic hash function:
- Deterministic: same input, same output.
- One‑way: you cannot easily find the original input from the hash.
- Sensitive to changes: small change in input produces a very different hash.
- Resistant to collisions: hard to find two inputs with same hash.
Common cryptographic hash functions:
| Algorithm | Type | Notes |
|---|---|---|
| MD5 | Hash | Obsolete, insecure |
| SHA‑1 | Hash | Obsolete, insecure |
| SHA‑256 | General hash | Secure for many uses, not ideal alone for passwords |
| SHA‑512 | General hash | Same as above |
These general hash functions are too fast for password storage.
Basic Hashing Example
Naive idea:
- When user registers:
- Store
hash(password)in database. - When user logs in:
- Compute
hash(input_password)and compare with stored hash.
Example data:
| user_id | password_hash | |
|---|---|---|
| 1 | alice@example.com | e99a18c428cb38d5f260853678922e03 |
This is better than plain text, but still unsafe on its own. Attackers can use rainbow tables and brute force attacks.
Salting: Defending Against Rainbow Tables
What Is a Salt?
A salt is a random string that you generate for each password.
You then compute:
$$
\text{stored\_hash} = H(\text{salt} \;||\; \text{password})
$$
Here, $H$ is a hash function and $||$ means "concatenate".
Example:
- Password:
mysecret123 - Salt:
K9n3!aZ@2# - Hash input:
K9n3!aZ@2#mysecret123 - Hash output:
5f16b8...(some long string)
You store both the salt and the hash.
Table example:
| user_id | salt | password_hash | |
|---|---|---|---|
| 1 | alice@example.com | K9n3!aZ@2# | 5f16b8... |
Why Salting Helps
Without salt, many users share the same hash for the same password:
| user_id | password_hash | |
|---|---|---|
| 1 | alice@example.com | e10adc3949ba59abbe56e057f20f883e |
| 2 | bob@example.com | e10adc3949ba59abbe56e057f20f883e |
If e10adc... is known to mean 123456, the attacker instantly knows both passwords.
With salts:
| user_id | salt | password_hash | |
|---|---|---|---|
| 1 | alice@example.com | abcd1234 | AAAA... |
| 2 | bob@example.com | xyz9876 | BBBB... |
Even if both users chose 123456, their stored hashes are different. There is no single "hash for 123456" anymore, because the salt is different each time.
This prevents precomputed rainbow table attacks, where attackers use large tables of precomputed hash values.
Salt Requirements
A good salt must be:
- Random: generated with a secure random generator.
- Unique per password.
- Long enough, for example 16 bytes or more (often encoded as 32+ characters in hex or Base64).
You do not need to keep salts secret. You can store them in the same table as the hash.
Why Fast Hashes Are Not Enough
Even with salts, using a fast hash algorithm like SHA‑256 is not enough.
Reason: attackers can try billions of guesses per second with GPUs and specialized hardware.
Example idea:
- Attacker steals database with salted SHA‑256 hashes.
- They write a program that:
- Takes a guess "password123".
- Computes H(salt || "password123") for every user.
- Compares with each stored hash.
- Because SHA‑256 is very fast, they can run this millions or billions of times per second.
So although salts prevent precomputed rainbow tables, they do not stop mass brute‑force attempts if the hashing is too cheap.
You need functions that are:
- Slow on purpose.
- Memory‑hard or configurable.
- Designed for passwords, not for general hashing.
Password Hashing Algorithms
Key Idea: Make Hashing Expensive
For password storage, you intentionally make hashing expensive. Not too slow for your users, but slow enough that guessing millions of passwords becomes impractical.
You use special functions called password hashing functions or key derivation functions.
Common choices:
| Algorithm | Type | Status / Recommendation |
|---|---|---|
| bcrypt | Password hashing | Very common, good choice |
| scrypt | Password hashing, memory‑hard | Strong, good choice |
| Argon2id | Password hashing, memory‑hard | Modern recommended standard |
| PBKDF2 | Key derivation, slower | Widely used, acceptable with enough iterations |
Any of these is far better than a raw hash like SHA‑256 alone.
Do not design your own password hashing algorithm. Use a well tested, standard one like bcrypt, scrypt, Argon2, or PBKDF2.
bcrypt
- Adds its own salt automatically.
- Has a cost factor (also called work factor) that controls speed.
- Output includes:
- Algorithm version
- Cost
- Salt
- Hash
Example bcrypt hash string:
$2b$12$9C8p4pY/.gQ1qrnOZwZQBuTVqYsZQkUpY..sh1BfXZ4VtaxGE7C2qYou do not manage the salt manually. The library handles it.
scrypt and Argon2
- Designed to be memory‑hard.
- These make attacks harder even with GPUs.
- You can configure:
- Time cost
- Memory cost
- Parallelism
They are considered very strong for password storage.
How Password Verification Works
The main idea:
- At registration or password change:
- Take the plain text password.
- Use a password hashing algorithm (argon2, bcrypt, etc.).
- Store only the hash output (which also encodes the salt and parameters).
- At login:
- Take the user’s input password.
- Run the same hashing algorithm with the stored parameters.
- Compare the resulting hash with the stored hash.
- If they match, the password is correct.
You never decrypt anything. You only recompute and compare.
Example: Using bcrypt in Practice
The exact code depends on the language and framework. This is a conceptual example in Python style, which you can adapt.
Registration Flow
- User sends:
{
"email": "alice@example.com",
"password": "MySuperSecret!"
}- Your backend:
- Generates a bcrypt hash:
import bcrypt
plain_password = "MySuperSecret!".encode("utf-8")
hashed = bcrypt.hashpw(plain_password, bcrypt.gensalt()) # gensalt chooses salt and cost
print(hashed) # something like b"$2b$12$9C8p4pY/.gQ1qrnOZwZQBuTVqYsZQkUpY..sh1BfXZ4VtaxGE7C2q"- Stores the hash in the database:
| user_id | password_hash | |
|---|---|---|
| 1 | alice@example.com | $2b$12$9C8p4pY/.gQ1qrnOZwZQBuTVqYsZQkUpY..sh1BfXZ4VtaxGE7C2q |
You store only this string, not the plain password and not a separate salt.
Login Flow
- User sends:
{
"email": "alice@example.com",
"password": "MySuperSecret!"
}- Your backend:
- Looks up
password_hashin the database. - Verifies:
stored_hash = b"$2b$12$9C8p4pY/.gQ1qrnOZwZQBuTVqYsZQkUpY..sh1BfXZ4VtaxGE7C2q"
plain_password = "MySuperSecret!".encode("utf-8")
if bcrypt.checkpw(plain_password, stored_hash):
# Password correct
else:
# Password incorrectbcrypt extracts the salt and cost from the stored hash, then compares in a safe way.
Handling Password Changes
When a user changes their password:
- Verify current password using the existing stored hash.
- If correct, hash the new password using your password hashing function.
- Replace the old hash with the new one.
Old password is gone forever. You cannot retrieve it.
Upgrading Hash Algorithms
You might start with one algorithm and later choose a stronger one. For example:
- Old: PBKDF2
- New: Argon2id
You cannot convert old hashes directly, because hashing is one‑way. Instead, you upgrade gradually.
Typical strategy:
- Store information about which algorithm and parameters were used, usually encoded in the hash string.
- On login:
- Verify using the appropriate algorithm for the stored hash.
- If login succeeds and the hash uses an old algorithm or weak parameters:
- Rehash the password with the new algorithm.
- Store the new hash.
Example flow:
- User has an old PBKDF2 hash stored.
- They log in successfully.
- Backend:
- Checks: "This hash uses old parameters."
- Recomputes hash using Argon2id.
- Replaces stored hash with new Argon2 hash.
Over time, as users log in, their password hashes get upgraded without forcing everyone to reset passwords at once.
Common Mistakes in Password Storage
Here are patterns to avoid.
1. Storing Plain Text or Reversible Encryption
Bad:
password = "MySecret123"password_encrypted = encrypt("MySecret123", key)
If someone has database + key, they have every password.
2. Using Fast Hashes Alone
Bad patterns:
hash = SHA256(password)hash = MD5(salt + password)
Even if salted, fast hashes are easy to brute force.
3. Custom or Obscure Algorithms
Bad idea:
- Designing your own hash algorithm.
- Chaining multiple general hash functions, for example:
SHA1(SHA256(SHA512(password)))
Security is hard. Use standard, tested algorithms implemented by experts.
4. Short or Non‑Random Salts
Avoid:
- Using user ID as salt.
- Using the same salt for all users.
- Using predictable salts such as "abc123" or current timestamp without randomness.
Use secure random salts, unique per password, and let libraries manage them when possible.
Practical Recommendations
For beginner backend developers, follow these simple rules.
Password Storage Rules
- Never store plain text passwords.
- Never use reversible encryption for passwords.
- Always use a password hashing function such as bcrypt, scrypt, Argon2, or PBKDF2.
- Always use salts. Prefer libraries that manage salts for you.
- Configure hashing to be slow enough to resist brute force, but still fast enough for users.
- Plan for algorithm upgrades over time.
Suggested Algorithms
If your environment supports it:
- Prefer Argon2id where available.
- Otherwise, use bcrypt with a reasonable cost factor.
For example:
- bcrypt with cost 10 to 12, depending on your server performance.
- Test by measuring how long hashing takes on your servers. Aim for perhaps 50 to 250 milliseconds per hash for login.
Example: Data Model for User Passwords
A typical users table might have:
| Column | Type | Description |
|---|---|---|
| id | integer PK | User identifier |
| string | Unique email address | |
| password_hash | string | Full password hash (algorithm + params + salt) |
| created_at | timestamp | Creation time |
| updated_at | timestamp | Last update time |
You do not need separate columns for salt or algorithm if you use formats that encode them inside the hash string, such as bcrypt or Argon2.
How This Fits With Other Authentication Topics
In the broader authentication system you will:
- Use these hashed passwords for login and registration.
- Combine password verification with:
- Sessions or tokens (JWT, etc.).
- Additional features such as multi factor authentication.
But all of that depends on this fundamental step: store passwords correctly and safely.
Once your password storage is secure, you can build the rest of your authentication system with much more confidence.
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!