5.9.2. File Validation
Table of Contents
Why File Validation Matters
Whenever a user uploads a file to your backend, you are trusting data that you did not create. This is always risky. A file might be:
- Too large and fill your disk.
- Of an unexpected type and break your application.
- Malicious, such as a script disguised as an image.
File validation is the process of checking that an uploaded file matches your expectations before you store it or process it.
Always validate uploaded files on the server side, even if you have client-side checks. Never trust the client.
File validation is not only about security. It is also about correctness and user experience. If your API expects a PDF, it should reject images instead of failing later in a background job.
What To Validate
When a file arrives at your backend, there are several things you typically want to validate. Common checks include:
| Check type | Examples | Why it matters |
|---|---|---|
| Size | Max 5 MB, min 1 KB | Avoid resource exhaustion, enforce limits |
| Type / MIME type | Only image/jpeg, application/pdf | Ensure correct processing and basic safety |
| Extension | .jpg, .png, .pdf | User feedback, simple filtering |
| Content / magic bytes | File really is an image, not a script | Prevent disguised files |
| Dimensions | Image width and height limits | Control layout and storage cost |
| Page count | PDF with max 10 pages | Business rules |
| Name / path | No path traversal, no strange characters | Prevent directory tricks |
| Count | Max N files per request | Protect from abuse |
You rarely need all of these, but you should consciously choose which ones your API needs.
File Size Validation
Validating file size is usually the first and simplest check.
You can apply limits in three places:
- At the reverse proxy or web server (for example Nginx, Traefik).
- At the application server or framework level.
- In your application code.
The best practice is to enforce limits as early as possible, then verify again in your application logic.
Request-level vs file-level limits
- Request size limit: Maximum total size of the HTTP request body. For example, at most 10 MB in a single request, no matter how many files.
- Per-file size limit: Limit for each individual file, for example each file must be at most 2 MB.
Both are useful:
- Request limit protects your server from very large uploads.
- File limit enforces business rules.
Example: Checking file size in code (Python-like pseudocode)
Imagine an API that accepts a single image file with a 2 MB limit.
MAX_FILE_SIZE = 2 * 1024 * 1024 # 2 MB
def validate_file_size(uploaded_file):
# Many frameworks expose file size directly
size = uploaded_file.size # or len(uploaded_file.read()) in a streaming manner
if size > MAX_FILE_SIZE:
raise ValueError("File too large (max 2 MB).")In a streaming environment you might read chunks and track the total. If the limit is exceeded, you stop reading and return an error.
Never read a huge file fully into memory without limits. Always enforce maximum sizes for uploads.
Validating File Type
Most web clients will send two hints about file type:
- MIME type (also called content type), for example
image/jpeg,application/pdf. - File extension, for example
.jpg,.pdf.
These are only hints from the client. Both can be forged easily.
Using MIME types
Common patterns:
- Check the MIME type matches a whitelist.
- Reject everything that is not in the allowed list.
Example whitelist:
Allowed MIME types:
- image/jpeg
- image/png
- application/pdfIn code you might see:
ALLOWED_MIME_TYPES = {
"image/jpeg",
"image/png",
"application/pdf",
}
def validate_mime_type(uploaded_file):
if uploaded_file.content_type not in ALLOWED_MIME_TYPES:
raise ValueError("Unsupported file type.")This is a first line of defense, not your only check.
Checking file extensions
File extensions are useful for:
- Giving quick feedback to users.
- Organizing storage by type.
However, never rely solely on extensions.
Example check:
ALLOWED_EXTENSIONS = {".jpg", ".jpeg", ".png"}
def validate_extension(filename):
import os
_, ext = os.path.splitext(filename.lower())
if ext not in ALLOWED_EXTENSIONS:
raise ValueError("Unsupported file extension.")Combine extension checks with MIME type and content checks to increase reliability.
Validating File Content (Magic Bytes)
The only way to be reasonably sure what a file really is, is to look at its content, especially the first bytes. These are often called magic bytes or file signatures.
For example:
| File type | Magic bytes (hex) |
|---|---|
| JPEG | FF D8 FF at the start |
| PNG | 89 50 4E 47 0D 0A 1A 0A |
%PDF- (ASCII) | |
| ZIP | 50 4B 03 04 |
Many languages and libraries can guess the type from these bytes.
Example: Checking magic bytes in Python style
def is_jpeg(file_obj):
# Remember current position
pos = file_obj.tell()
header = file_obj.read(3)
# Restore position
file_obj.seek(pos)
return header == b"\xFF\xD8\xFF"This can be generalized or replaced by a library that reads headers and recognizes common formats.
Never trust the MIME type or extension without at least a minimal content check for critical file types, such as user avatars or document uploads.
Image-specific Validation (Dimensions, Format)
Images are a very common upload type. They have special validation needs.
Typical checks:
- Allowed formats, for example JPEG and PNG only.
- Maximum width and height in pixels.
- Minimum width and height.
- Maximum aspect ratio if required, for example no extremely tall images.
Example rules for profile pictures
You might require:
- Formats: JPEG, PNG.
- Size: at most 2 MB.
- Dimensions: between 256×256 and 2000×2000 pixels.
Example logic (pseudocode):
MAX_SIZE = 2 * 1024 * 1024
MIN_WIDTH, MIN_HEIGHT = 256, 256
MAX_WIDTH, MAX_HEIGHT = 2000, 2000
def validate_profile_image(file):
if file.size > MAX_SIZE:
raise ValueError("Image too large (max 2 MB).")
image = load_image(file) # Use an image library like Pillow
width, height = image.size
if width < MIN_WIDTH or height < MIN_HEIGHT:
raise ValueError("Image too small.")
if width > MAX_WIDTH or height > MAX_HEIGHT:
raise ValueError("Image too big.")Many backends also resize images after validation. Validation and transformation are related but should be considered separate steps.
Validating File Names and Paths
Even if you never store the original filename, you should treat it carefully.
Risks include:
- Path traversal, for example
../../etc/passwd. - System-sensitive characters, such as slashes, backslashes, colons.
- Very long filenames.
Never use a user-provided filename as a filesystem path directly.
Safe handling approach
- Ignore the directory part of the filename.
- Extract only the last component.
- Generate your own internal name, for example a UUID.
Example approach:
import os
import uuid
def sanitize_filename(original_name):
# Get only the base name (strip directories)
base_name = os.path.basename(original_name)
# Replace spaces and risky characters if you intend to keep it
safe_name = base_name.replace(" ", "_")
return safe_name
def generate_storage_name(original_name):
_, ext = os.path.splitext(original_name)
return f"{uuid.uuid4().hex}{ext.lower()}"
Use generate_storage_name to name files on disk or object storage, not the original user filename.
Never trust user-provided file paths or directory names. Always control where files are written.
Validating Number of Files
If your endpoint accepts multiple files, validate:
- How many files are allowed.
- Possibly, limits by type category, for example 1 identity document and up to 5 attachments.
Example rules:
- At most 10 files in a single request.
- Combined size at most 20 MB.
Pseudocode:
MAX_FILES = 10
MAX_TOTAL_SIZE = 20 * 1024 * 1024 # 20 MB
def validate_multiple_files(files):
if len(files) > MAX_FILES:
raise ValueError("Too many files.")
total_size = sum(f.size for f in files)
if total_size > MAX_TOTAL_SIZE:
raise ValueError("Total upload size too large.")This limit helps protect your backend and keeps your storage predictable.
Business Rule Validation
Besides technical checks, you often need business-specific rules. Some examples:
- Only one profile picture per user.
- Only PDF format for invoices.
- Maximum number of documents per account.
- File names must match a pattern, for example
invoice-YYYY-MM-DD.pdf.
Example pattern-based validation:
import re
INVOICE_PATTERN = re.compile(r"^invoice-\d{4}-\d{2}-\d{2}\.pdf$")
def validate_invoice_filename(filename):
if not INVOICE_PATTERN.match(filename):
raise ValueError("Filename must be like invoice-YYYY-MM-DD.pdf")These checks are specific to your project and belong in your application logic.
Error Handling and User Feedback
Good file validation is not only about rejecting bad files. It is also about returning clear, specific error messages.
Bad feedback:
"Invalid file."
Good feedback:
"File too large. Maximum allowed size is 5 MB.""Only PDF files are allowed.""Image too wide. Maximum width is 2000 pixels."
Typically you want to:
- Use appropriate HTTP status codes.
- Return structured error information.
For example, a JSON error response:
{
"error": "validation_error",
"field": "file",
"message": "File too large. Maximum allowed size is 5 MB.",
"limit": 5242880
}This makes it easy for the frontend to show meaningful messages to the user.
Security Considerations in File Validation
File validation is an important part of backend security, but it is not enough on its own. You should combine it with:
- Safe file storage strategy, such as storing files outside the application directory.
- Serving files through a separate domain or object storage.
- Avoiding execution of uploaded files as code.
- Virus scanning for sensitive use cases.
Some specific points related to validation:
- Never execute uploaded files. This includes scripts, binaries, or code in templates.
- Treat all content as untrusted. Even validated images can contain malicious payloads for image parsers.
- Sanitize any data extracted from files before using it elsewhere.
Validation reduces risk but does not eliminate it. Combine validation with safe storage, strict permissions, and defense in depth.
Designing a File Validation Policy
To make file validation consistent in your backend, define a clear policy per use case. For each type of upload, specify:
- Allowed MIME types and extensions.
- Maximum file size.
- Maximum and minimum dimensions or pages if relevant.
- Maximum number of files.
- Whether you will inspect magic bytes and how.
- Any business rules, such as naming conventions.
Put this policy into configuration so it is easy to change without editing core logic. For example, a configuration structure:
profile_image:
max_size: 2097152 # 2 MB
allowed_mime_types:
- image/jpeg
- image/png
min_width: 256
min_height: 256
max_width: 2000
max_height: 2000
invoice_pdf:
max_size: 5242880 # 5 MB
allowed_mime_types:
- application/pdf
max_pages: 20Then implement generic validators that read from this configuration.
By doing so, you keep file validation predictable, testable, and easy to maintain as your backend grows.
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!