KAHIBARO Bookshelves
Discord Login Register

6.10. Static Files

Why Static Files Matter

Backend applications often need to serve files that do not change for every request. These are called static files. They are usually:

  • Images, icons, logos
  • CSS stylesheets
  • JavaScript files
  • Fonts
  • Sometimes PDFs or other documents

Your backend must know where these files live on disk and how to send them to the client efficiently and securely.

Static files are any files that are sent “as is”, without being generated for each request.

Dynamic pages are usually HTML generated by templates or code. Static files are plain files on disk that the server reads and sends.


Typical Static File Structure

Most projects use a dedicated folder for static assets, for example:

text
my_project/
    app/
        routes.py
        templates/
            base.html
            index.html
    static/
        css/
            main.css
        js/
            app.js
        images/
            logo.png
            banner.jpg

Common conventions:

TypeTypical FolderExamples
Stylesheetsstatic/cssmain.css, reset.css
JavaScriptstatic/jsapp.js, analytics.js
Imagesstatic/imageslogo.png, avatar.jpg
Fontsstatic/fontsRoboto.woff2, icons.ttf
Other assetsstatic/robots.txt, favicon.ico

The exact layout depends on the framework, but the pattern is always:

  • One or more source directories on disk
  • URLs that point to files inside those directories

Static Files vs Templates

Templates are covered in their own chapter, but it is important to understand how static files relate to them.

  • Templates are often HTML files that contain placeholders. The backend fills those placeholders before sending the result.
  • Static files are usually referenced inside templates using fixed URLs.

Example HTML template that uses a static CSS file and a static image:

html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>My Site</title>
    <link rel="stylesheet" href="/static/css/main.css">
  </head>
  <body>
    <img src="/static/images/logo.png" alt="Logo">
    <h1>Welcome</h1>
    <script src="/static/js/app.js"></script>
  </body>
</html>

Here the backend must be configured so that:

  • /static/css/main.css maps to static/css/main.css on disk
  • /static/images/logo.png maps to static/images/logo.png on disk
  • /static/js/app.js maps to static/js/app.js on disk

How Static File Serving Works

At a high level, serving a static file follows this flow:

  1. Client requests a URL
    Example: GET /static/css/main.css HTTP/1.1
  2. Server maps the URL to a file path
    Example mapping rule:
    • URL prefix /static/
    • Filesystem directory /app/static/
      So /static/css/main.css becomes /app/static/css/main.css
  3. Server checks if file exists and is allowed
    • If yes, it reads the file and sends it
    • If no, it returns 404 Not Found
  4. Server sets headers such as:
    • Content-Type: text/css
    • Content-Length: 1234
    • Maybe caching headers like Cache-Control
  5. Browser receives and uses the file
    For CSS, it applies the styles. For JavaScript, it executes the script.

You usually do not implement this logic manually. Your framework, web server, or reverse proxy will do it for you, but you need to configure:

  • The directory or directories where static files are stored
  • The URL prefix used to access them, such as /static/ or /assets/

Static Files in a Minimal Python Web App

Even before you use a full framework, you can create a simple example using a basic ASGI or WSGI app.

Here is a tiny example using the http.server module from the Python standard library. This is not production ready, but it shows the idea:

python
from http.server import SimpleHTTPRequestHandler, HTTPServer
PORT = 8000
# This handler serves files from the current directory by default.
handler_class = SimpleHTTPRequestHandler
with HTTPServer(("0.0.0.0", PORT), handler_class) as httpd:
    print(f"Serving on http://localhost:{PORT}")
    httpd.serve_forever()

If you run this in a directory that contains a static folder, you will be able to access files like:

  • http://localhost:8000/static/css/main.css
  • http://localhost:8000/static/js/app.js

In real backend applications you will configure static files explicitly in the framework or in a web server like Nginx, but the concept is the same.


Static Files and URLs

The URL path for static files does not have to match the folder name. You might have:

  • Folder: static/
  • URL prefix: /assets/

So this mapping is possible:

URLFile path on disk
/assets/css/main.cssstatic/css/main.css
/assets/js/app.jsstatic/js/app.js
/assets/logo.pngstatic/images/logo.png

You control this mapping through configuration.

Why change the URL prefix?

  • To avoid conflicts with other routes, for example if you already have /static for something else.
  • To add versioning, such as /static/v1/ vs /static/v2/.
  • For security or consistency with an existing system.

Static Files During Development vs Production

In development you might let your framework serve static files directly because it is simple.

Example pattern:

  • Run the app with a development server
  • Framework serves both:
    • Dynamic routes like /, /api/users
    • Static files like /static/css/main.css

In production, a common pattern is:

  • A reverse proxy or dedicated web server handles static files
  • The backend application only handles dynamic endpoints

A typical production setup:

PartResponsibility
Nginx (or similar)Serve /static/, /media/, handle HTTPS
Backend appServe /api/*, /login, other dynamic routes

The idea is that web servers like Nginx are very good at:

  • Reading files from disk
  • Caching them
  • Handling lots of concurrent connections

So they are more efficient for static files than application code.


Static Files and Caching

Static files usually do not change often, so they are a perfect target for caching.

Caching improves speed and reduces load by allowing the browser or intermediate caches to reuse the same file.

Common strategies:

  1. Set long cache lifetimes for static files
    For example:
http
   Cache-Control: public, max-age=31536000

This tells the browser it can cache the file for a year.

  1. Use file versioning or hashes
    When you change the file, change its name or URL, for example:
    • Old: /static/css/main.css
    • New: /static/css/main.v2.css
      or
    • /static/css/main.css?version=2
  2. Let the browser use the cached version
    As long as the URL is the same and the cache has not expired, the browser does not download the file again.

A simple example of versioned static file URLs in a template:

html
<link rel="stylesheet" href="/static/css/main.css?v=3">
<script src="/static/js/app.js?v=1"></script>

You can automate versioning during build steps, but the important concept is:

If you enable long caching for static files, you must change the URL when the file content changes.


Static Files and Security

Serving static files sounds simple, but there are important security issues.

Directory Traversal

You must prevent users from accessing files outside the static directory.

Unsafe example:

  • Static directory: /app/static/
  • User requests: /static/../app.py

If the server incorrectly converts that to /app/app.py, the user could download your source code.

Secure static file servers always:

  • Normalize the path
  • Ensure the final path is still under the allowed folder

So a safe server will reject or sanitize paths like:

  • /static/../secret.txt
  • /static/../../etc/passwd

Access to Sensitive Files

Never put secrets in your static folder:

  • .env
  • Database configuration
  • Private keys
  • Internal documentation

Anything in the static folder should be considered public.

Limiting Upload Types

Sometimes static-like files come from users, for example profile pictures or uploaded documents. These topics are covered in the file upload chapters, but keep in mind:

  • Treat user uploads very differently from your own static assets.
  • Often you will store uploads in a different folder and may use different servers.

Example: Simple Routing for Static Files

Imagine you are building a very tiny framework. You have a route for home and a route to serve static files.

Pseudo code:

python
import os
from http.server import BaseHTTPRequestHandler, HTTPServer
STATIC_DIR = os.path.join(os.path.dirname(__file__), "static")
class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path.startswith("/static/"):
            return self.serve_static()
        elif self.path == "/":
            return self.serve_home()
        else:
            self.send_error(404, "Not Found")
    def serve_home(self):
        html = b"""
        <html>
          <head>
            <link rel="stylesheet" href="/static/css/main.css">
          </head>
          <body>
            <h1>Hello</h1>
            <img src="/static/images/logo.png">
          </body>
        </html>
        """
        self.send_response(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(html)))
        self.end_headers()
        self.wfile.write(html)
    def serve_static(self):
        # remove leading "/static/"
        rel_path = self.path[len("/static/"):]
        # build absolute path under STATIC_DIR
        file_path = os.path.join(STATIC_DIR, rel_path)
        # normalize to prevent "../" attacks
        file_path = os.path.normpath(file_path)
        # ensure file is still under STATIC_DIR
        if not file_path.startswith(STATIC_DIR):
            self.send_error(403, "Forbidden")
            return
        if not os.path.isfile(file_path):
            self.send_error(404, "Not Found")
            return
        # simple content type detection
        if file_path.endswith(".css"):
            content_type = "text/css"
        elif file_path.endswith(".js"):
            content_type = "application/javascript"
        elif file_path.endswith(".png"):
            content_type = "image/png"
        else:
            content_type = "application/octet-stream"
        with open(file_path, "rb") as f:
            data = f.read()
        self.send_response(200)
        self.send_header("Content-Type", content_type)
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)
if __name__ == "__main__":
    server = HTTPServer(("0.0.0.0", 8000), MyHandler)
    print("Serving on http://localhost:8000")
    server.serve_forever()

This is not production quality, but it illustrates:

  • URL mapping to files
  • Content type detection
  • Simple security checks against directory traversal

Your real framework will provide something similar out of the box.


Static Files and Reverse Proxies

When you use a reverse proxy like Nginx, usual patterns are:

  1. Map /static/ to a directory on the server
  2. Proxy other URLs to the backend app

Simplified Nginx configuration example:

nginx
server {
    listen 80;
    server_name example.com;
    # Serve static files directly
    location /static/ {
        alias /var/www/myapp/static/;
        # Optional caching headers
        expires 30d;
        add_header Cache-Control "public";
    }
    # Proxy all other requests to the app
    location / {
        proxy_pass http://127.0.0.1:8000;
    }
}

The key ideas:

  • location /static/ is handled by Nginx, not by your application.
  • alias /var/www/myapp/static/ tells Nginx where on disk to find /static/....

This division of work is important in real deployments, but as a beginner you can focus on understanding what static files are and how URLs map to them.


Good Practices for Static Files

To finish, here are practical rules you can follow.

Static files rules to remember:

  1. Keep all public static assets in a dedicated directory, for example static/.
  2. Use clear URL prefixes such as /static/ or /assets/.
  3. Never store secrets or private data in your static folder.
  4. Avoid user uploads in the same folder as your own static files.
  5. Use caching for static assets and change URLs when files change.
  6. Let a web server or reverse proxy handle static files in production when possible.

Following these rules keeps your backend simpler, faster, and more secure while making it easier to work with templates and frontend code.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

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