6.10. Static Files
Table of Contents
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:
my_project/
app/
routes.py
templates/
base.html
index.html
static/
css/
main.css
js/
app.js
images/
logo.png
banner.jpgCommon conventions:
| Type | Typical Folder | Examples |
|---|---|---|
| Stylesheets | static/css | main.css, reset.css |
| JavaScript | static/js | app.js, analytics.js |
| Images | static/images | logo.png, avatar.jpg |
| Fonts | static/fonts | Roboto.woff2, icons.ttf |
| Other assets | static/ | 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:
<!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.cssmaps tostatic/css/main.csson disk/static/images/logo.pngmaps tostatic/images/logo.pngon disk/static/js/app.jsmaps tostatic/js/app.json disk
How Static File Serving Works
At a high level, serving a static file follows this flow:
- Client requests a URL
Example:GET /static/css/main.css HTTP/1.1 - Server maps the URL to a file path
Example mapping rule: - URL prefix
/static/ - Filesystem directory
/app/static/
So/static/css/main.cssbecomes/app/static/css/main.css - Server checks if file exists and is allowed
- If yes, it reads the file and sends it
- If no, it returns 404 Not Found
- Server sets headers such as:
Content-Type: text/cssContent-Length: 1234- Maybe caching headers like
Cache-Control - 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:
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.csshttp://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:
| URL | File path on disk |
|---|---|
/assets/css/main.css | static/css/main.css |
/assets/js/app.js | static/js/app.js |
/assets/logo.png | static/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
/staticfor 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:
| Part | Responsibility |
|---|---|
| Nginx (or similar) | Serve /static/, /media/, handle HTTPS |
| Backend app | Serve /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:
- Set long cache lifetimes for static files
For example:
Cache-Control: public, max-age=31536000This tells the browser it can cache the file for a year.
- 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- 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:
<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:
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:
- Map
/static/to a directory on the server - Proxy other URLs to the backend app
Simplified Nginx configuration example:
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:
- Keep all public static assets in a dedicated directory, for example
static/. - Use clear URL prefixes such as
/static/or/assets/. - Never store secrets or private data in your static folder.
- Avoid user uploads in the same folder as your own static files.
- Use caching for static assets and change URLs when files change.
- 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
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!