15.3. SQL Injection
Table of Contents
Understanding SQL Injection
SQL injection is one of the most dangerous and common attacks against backend applications that use relational databases. It happens when user input ends up inside an SQL query in an unsafe way, so the attacker can change what the query does.
This chapter focuses on how SQL injection works, how it is exploited, and how to defend against it in the context of backend development.
Core idea of SQL injection
User-controlled data must never be directly concatenated into SQL strings.
You must use parameterized queries or safe query builders / ORMs for all dynamic values.
A Simple Example Of SQL Injection
Vulnerable login query
Imagine a simple login endpoint:
username = request.form["username"]
password = request.form["password"]
query = (
"SELECT * FROM users "
"WHERE username = '" + username + "' "
"AND password = '" + password + "';"
)
cursor.execute(query)
user = cursor.fetchone()If the user submits:
username = alicepassword = secret
The query becomes:
SELECT * FROM users
WHERE username = 'alice'
AND password = 'secret';That looks fine. But an attacker can send:
username = alice' --password = anything
Then the query becomes:
SELECT * FROM users
WHERE username = 'alice' --'
AND password = 'anything';
In SQL, -- starts a comment to the end of the line. Everything after -- is ignored:
SELECT * FROM users
WHERE username = 'alice'
Now the password check is removed. The attacker logs in as alice without knowing her password.
How SQL Injection Works
Where the vulnerability comes from
The problem is this pattern:
"SELECT ... WHERE column = '" + user_input + "';"The application builds SQL by mixing code and data in a single string. The database cannot tell which characters are part of the data and which are part of the SQL syntax.
If the user input contains characters like ', ", ;, --, /, /, or keywords like OR, AND, UNION, DROP, it can change how the SQL is interpreted.
Typical attack payloads
Some classic malicious inputs:
| Goal | Example input | Effect |
|---|---|---|
| Bypass login check | ' OR 1=1 -- | Makes condition always true |
| Bypass numeric check | 0 OR 1=1 | Makes id = 0 OR 1=1, returns many rows |
| Terminate and add query | 1; DROP TABLE users; -- | Ends original query, runs DROP TABLE |
| Read more data | ' UNION SELECT * FROM credit_cards -- | Combines results from another table |
| Detect vulnerability | ' or " or ') | Often causes syntax errors, reveals stack traces |
Example of a login bypass payload:
username: ' OR 1=1 --
password: anythingQuery becomes:
SELECT * FROM users
WHERE username = '' OR 1=1 --'
AND password = 'anything';
OR 1=1 is always true, the password condition is commented out, so the attacker usually gets access as the first user in the table.
Types Of SQL Injection
Some useful categories for understanding how attacks work.
1. In-band SQL injection
The attacker both sends the malicious input and receives results using the same channel (the normal HTTP response).
Two common subtypes:
| Type | Description | Example effect |
|---|---|---|
| Error-based | Forces database errors to reveal information | Leaks table/column names, DB version |
| Union-based | Uses UNION SELECT to combine attacker-chosen data | Shows data from other tables in page |
Example, UNION-based:
Suppose the app runs:
SELECT id, title, body
FROM posts
WHERE id = <user_input>;
If the attacker controls id and the app prints titles and bodies directly, they can send:
id = 1 UNION SELECT 1, username, password FROM usersFinal query:
SELECT id, title, body
FROM posts
WHERE id = 1 UNION
SELECT 1, username, password FROM users;The page might now display usernames and password hashes instead of blog posts.
2. Blind SQL injection
The application does not show database errors or query results directly. But the attacker can still infer information from behavior changes, like:
- Whether a page loads normally or with an error page.
- How long the response takes.
Two main forms:
| Type | Description | Example |
|---|---|---|
| Boolean-based | Uses true/false conditions and observes differences | AND 1=1 vs AND 1=2 |
| Time-based | Uses SLEEP() or similar functions and measures time | AND IF(condition, SLEEP(5), 0) |
Boolean-based example:
The app runs:
SELECT * FROM products WHERE id = <user_input>;Attacker tests:
id = 1 AND 1=1
id = 1 AND 1=2If the first returns a normal page and the second returns an empty or error page, the attacker knows the input is inside an SQL condition and can build more complex conditions to extract data bit by bit.
3. Out-of-band SQL injection
The attacker cannot use the normal HTTP response or timing easily, but the database can reach out to external services.
For example, some databases can:
- Make DNS requests using attacker-controlled hostnames.
- Make HTTP requests or write files.
The attacker crafts SQL that triggers such behavior and then monitors their own server logs to see which data was exfiltrated.
This is rarer in typical backend apps for beginners, but it exists, especially when database features like LOAD_FILE or external functions are enabled.
Where SQL Injection Shows Up In Backends
Common vulnerable places
SQL injection can happen anywhere user input ends up in a query:
- Authentication
Login forms, "remember me" tokens, password reset tokens. - Search
Search boxes with queries like:
WHERE title LIKE '%<user_input>%'- Filtering, sorting, pagination
WHEREclauses built from filters.ORDER BYbuilt from sort fields.LIMITandOFFSETfrom user input.- Admin panels
"Export CSV" features, reporting dashboards, advanced filters. - APIs
Query parameters and JSON bodies used directly in SQL. - Hidden input sources
- HTTP headers (User-Agent, Referer).
- Cookies.
- URL path segments.
Any place where developers think "users cannot modify this" is dangerous. Attackers often can.
Example: search endpoint
Vulnerable code:
search = request.args.get("q", "")
query = f"SELECT * FROM products WHERE name LIKE '%{search}%';"
cursor.execute(query)Attacker sends:
?q=' OR 1=1 --Query becomes:
SELECT * FROM products
WHERE name LIKE '%' OR 1=1 -- %';
The OR 1=1 makes the condition always true, so the attacker sees every product, possibly including unpublished ones.
Real-World Impact Of SQL Injection
Depending on how severe the vulnerability is, SQL injection can allow attackers to:
| Impact level | Possible attacker actions |
|---|---|
| Read data | Dump users, emails, password hashes, secrets, logs, etc. |
| Modify data | Change balances, approve orders, alter permissions |
| Delete data | Drop tables, truncate logs, erase users |
| Escalate privileges | Promote self to admin, create backdoor accounts |
| Execute system commands | On some setups, run OS commands through DB functions |
| Persist further access | Install malicious triggers, store webshells, change config |
For a backend developer, even "just" reading the users table can be catastrophic, because passwords, tokens, etc, may be leaked.
Defending Against SQL Injection
1. Use parameterized queries
This is the most important protection.
With parameterized queries (also called prepared statements), you write SQL with placeholders, and pass user values separately:
# Python with psycopg2 (PostgreSQL)
username = request.form["username"]
password = request.form["password"]
query = """
SELECT * FROM users
WHERE username = %s
AND password_hash = crypt(%s, password_hash);
"""
cursor.execute(query, (username, password))
user = cursor.fetchone()The driver:
- Sends the SQL structure with placeholders to the database.
- Sends the values separately.
- The database always treats values as data, not SQL code.
Even if username is:
alice' OR 1=1 --The driver will escape it correctly and the query will still have the same structure:
WHERE username = 'alice'' OR 1=1 --'The attacker cannot break out of the string literal.
Examples in different languages / libraries
| Environment | Placeholder style | Example |
|---|---|---|
| psycopg2 (Python) | %s | cursor.execute("... WHERE id = %s", (id_val,)) |
| sqlite3 (Python) | ? | cursor.execute("... WHERE id = ?", (id_val,)) |
| Node, pg | $1, $2, ... | client.query("... WHERE id = $1", [idVal]) |
| Java, JDBC | ? | PreparedStatement ps = con.prepareStatement("...") |
| Go, database/sql | ? | db.Query("... WHERE id = ?", idVal) |
Rule: Always use parameterized queries
Any time you include user-controllable values in SQL, you must use parameters, never string concatenation or manual interpolation.
2. Use an ORM or safe query builder
ORMs and query builders usually parameterize values for you.
Example with SQLAlchemy (Python):
user = db.query(User).filter(User.username == username).first()Example with SQLAlchemy Core:
from sqlalchemy import select
stmt = select(User).where(User.id == user_id)
result = session.execute(stmt)The ORM converts this to parameterized SQL under the hood.
However:
- If you pass raw SQL strings directly to the ORM, you can still create vulnerabilities.
- When using raw fragments like
text("..."), you must still use parameters.
Unsafe:
stmt = text(f"SELECT * FROM users WHERE username = '{username}'")
session.execute(stmt)Safe:
stmt = text("SELECT * FROM users WHERE username = :username")
session.execute(stmt, {"username": username})3. Never build queries by concatenating strings
Avoid this pattern:
query = "SELECT * FROM users WHERE username = '" + username + "';"Or:
query = f"SELECT * FROM users WHERE username = '{username}';"Or:
query = "SELECT * FROM users WHERE username = '%s';" % usernameEven if you "sanitize" the input, this pattern is hard to make safe and easy to get wrong.
A few exceptions may exist, for example when constructing dynamic parts that cannot be parameterized, like column names or sort directions. We will cover that later.
4. Whitelist identifiers for dynamic SQL
Sometimes you need to build queries with dynamic:
- Column names in
ORDER BY. - Table names.
- Sort directions like
ASCorDESC.
Most database drivers do not let you parameterize these, only values. In these cases, use whitelisting.
Example: safe sorting
# User provides sort field and direction
sort_field = request.args.get("sort", "created_at")
sort_dir = request.args.get("dir", "desc")
allowed_fields = {
"created_at": "created_at",
"price": "price",
"name": "name",
}
allowed_dirs = {"asc": "ASC", "desc": "DESC"}
field = allowed_fields.get(sort_field, "created_at")
direction = allowed_dirs.get(sort_dir, "DESC")
query = f"SELECT * FROM products ORDER BY {field} {direction} LIMIT %s OFFSET %s"
cursor.execute(query, (limit, offset))- The column name and direction come from fixed sets of strings defined in code.
- The values
limitandoffsetare still parameters, not interpolated.
Attacker inputs like price; DROP TABLE users; -- will not be found in allowed_fields, so they are ignored.
5. Validate and constrain input
Input validation is not a complete defense, but it helps:
- Ensure numeric fields are really numbers.
- Enforce maximum lengths.
- Restrict allowed characters for certain fields.
Examples:
# Numeric ID from path
try:
user_id = int(request.path_params["user_id"])
except ValueError:
raise HTTPException(status_code=400, detail="Invalid user id")
# Limit search length and characters
search = request.query_params.get("q", "")
if len(search) > 100:
raise HTTPException(status_code=400, detail="Search too long")Even with validation, you still must use parameterized queries.
6. Principle of least privilege for database users
Use database accounts with the minimum required permissions for the application.
For example:
- The public web application user should not have
DROP TABLEorCREATE DATABASEpermissions. - For read-only operations, consider a separate read-only database user.
Then, even if SQL injection happens, the impact is reduced.
Example table of roles:
| Role | Example permissions | Used for |
|---|---|---|
app_read_write | SELECT, INSERT, UPDATE, limited DELETE | Normal app behavior |
app_read_only | SELECT only | Analytics pages, public APIs |
db_admin | Full privileges | Migrations, maintenance only |
7. Avoid exposing raw error messages
Detailed SQL error messages can help attackers craft injection payloads:
- Syntax errors reveal where the injection is.
- Error messages show table and column names.
- Stack traces reveal library versions and code structure.
In production:
- Log detailed errors internally.
- Return generic error messages to clients.
Example:
try:
cursor.execute(query, params)
except Exception:
logger.exception("Database query failed")
raise HTTPException(status_code=500, detail="Internal server error")Examples Of Vulnerable And Safe Code
Example 1: User profile endpoint
Vulnerable
# GET /users?username=<username>
username = request.args["username"]
query = f"SELECT id, username, email FROM users WHERE username = '{username}';"
cursor.execute(query)
user = cursor.fetchone()Payload:
username = alice' OR '1'='1Query:
SELECT id, username, email FROM users
WHERE username = 'alice' OR '1'='1';Attacker gets all users.
Safe
username = request.args["username"]
query = "SELECT id, username, email FROM users WHERE username = %s;"
cursor.execute(query, (username,))
user = cursor.fetchone()Payload is safely treated as a string value.
Example 2: Search with LIKE
Vulnerable
search = request.args.get("q", "")
query = "SELECT * FROM articles WHERE title LIKE '%" + search + "%';"
cursor.execute(query)Safe
search = request.args.get("q", "")
pattern = "%" + search + "%"
query = "SELECT * FROM articles WHERE title LIKE %s;"
cursor.execute(query, (pattern,))Example 3: Numeric ID
Assume an endpoint:
# GET /product/<id>
product_id = request.path_params["id"]
query = f"SELECT * FROM products WHERE id = {product_id};"
cursor.execute(query)
product = cursor.fetchone()
Even if id is supposed to be an integer, the application might receive:
id = 1; DROP TABLE products; --Query becomes:
SELECT * FROM products WHERE id = 1; DROP TABLE products; --;Safe version
product_id = int(request.path_params["id"]) # may raise ValueError
query = "SELECT * FROM products WHERE id = %s;"
cursor.execute(query, (product_id,))Or, in an ORM:
product_id = int(request.path_params["id"])
product = db.query(Product).filter(Product.id == product_id).first()Testing For SQL Injection Vulnerabilities
As a backend developer, you should learn to spot and test for potential SQL injection issues.
Basic manual tests
- Try special characters
Fields likely used in SQL:
- Add a single quote:
' - Input:
abc' - If you get a database error like "syntax error near 'abc''", it is suspicious.
- Try OR conditions
abc' OR '1'='1- Check if you suddenly get more results than expected.
- Numeric fields
- Replace
123with123 OR 1=1 - If the response changes, it may be vulnerable.
- Time-based tests
If the database supports SLEEP, try:
1 AND SLEEP(5)- If the response slows down significantly only with the injected part, this suggests a vulnerability.
Automated tools
Security professionals often use tools like:
sqlmap- Burp Suite extensions
For learning purposes, you can:
- Set up intentionally vulnerable apps like DVWA (Damn Vulnerable Web Application).
- Observe how tools detect and exploit SQL injection.
Never run such tools against systems you do not own or do not have explicit permission to test. That is illegal.
Special Cases And Tricky Spots
Dynamic WHERE clauses
Sometimes you build complex filters based on many optional parameters:
conditions = []
if "status" in filters:
conditions.append(f"status = '{filters['status']}'")
if "category" in filters:
conditions.append(f"category = '{filters['category']}'")
where_clause = " AND ".join(conditions) if conditions else "1=1"
query = "SELECT * FROM orders WHERE " + where_clause
cursor.execute(query)This is deeply vulnerable, because multiple user-controlled values are inserted directly.
Safe approach
Build conditions and parameters together:
conditions = []
params = []
if "status" in filters:
conditions.append("status = %s")
params.append(filters["status"])
if "category" in filters:
conditions.append("category = %s")
params.append(filters["category"])
where_clause = " AND ".join(conditions) if conditions else "1=1"
query = "SELECT * FROM orders WHERE " + where_clause
cursor.execute(query, params)The SQL structure stays fixed, only values are parameterized.
Stored procedures and SQL injection
Using stored procedures does not automatically prevent SQL injection.
- If the procedure uses string concatenation with input parameters, it can still be vulnerable.
- The same rules apply inside stored procedures: use parameters, not concatenated SQL.
Example of vulnerable stored procedure:
CREATE PROCEDURE GetUser(IN p_username VARCHAR(50))
BEGIN
SET @sql = CONCAT('SELECT * FROM users WHERE username = ''', p_username, '''');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
END;
If p_username contains ' OR 1=1 --, the procedure becomes vulnerable.
Summary
Key points to remember as a backend developer:
- Never build SQL by concatenating or interpolating user input into query strings.
- Always use parameterized queries or safe ORMs / query builders for all dynamic values.
- When you must build dynamic SQL for identifiers like column names, use strict whitelisting.
- Validate input, limit privileges of your database users, and avoid exposing raw SQL errors.
If you consistently follow these rules, you will prevent almost all SQL injection vulnerabilities in your backend applications.
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!