5.9.3. Image Uploads
Table of Contents
Why Image Uploads Are Special
Working with images is different from handling plain text or PDFs. Images are:
- Binary data, not human-readable text.
- Often much larger than other files.
- Frequently displayed back to users in a browser.
- Common targets for abuse, such as malware hidden in images, or very large files.
Your backend must handle image uploads in a way that is:
- Safe.
- Efficient.
- Convenient for your frontend.
In this chapter, you will see how to accept image uploads, validate them, and prepare them for storage and later use.
Accepting Image Uploads in an API
Most image uploads in web backends arrive as part of an HTTP request using multipart/form-data, often from an HTML form or JavaScript client.
A typical HTML form for image upload might look like:
<form action="/upload-avatar" method="post" enctype="multipart/form-data">
<input type="file" name="avatar" accept="image/*">
<button type="submit">Upload</button>
</form>Key points:
enctype="multipart/form-data"tells the browser to send file content.input type="file"lets the user select a file.name="avatar"becomes the field name in the request.accept="image/*"hints to the browser to show only image files.
On the backend, your framework will usually give you an object that represents the uploaded file. For example, in a Python FastAPI backend:
from fastapi import FastAPI, File, UploadFile
app = FastAPI()
@app.post("/upload-avatar")
async def upload_avatar(avatar: UploadFile = File(...)):
return {"filename": avatar.filename, "content_type": avatar.content_type}
The UploadFile object provides:
filename: the name sent by the client.content_type: MIME type such asimage/png.file: a file-like object to read bytes from.
You will later combine this with validation and storage.
Validating Uploaded Images
You should always validate image uploads before storing or processing them.
There are several things to check.
File size limits
Large images can:
- Fill your disk.
- Slow down processing.
- Allow a user to attack your server by uploading very big files.
You should:
- Set a maximum accepted size, for example 5 MB.
- Reject files that exceed it with an appropriate HTTP status code.
You can enforce size:
- At the web server or reverse proxy level.
- In your application code by checking the length of the data.
Example in FastAPI, checking size manually:
from fastapi import FastAPI, UploadFile, File, HTTPException
MAX_IMAGE_SIZE = 5 * 1024 * 1024 # 5 MB
app = FastAPI()
@app.post("/upload-photo")
async def upload_photo(photo: UploadFile = File(...)):
content = await photo.read()
if len(content) > MAX_IMAGE_SIZE:
raise HTTPException(status_code=413, detail="Image too large")
# reset file pointer if you will reuse photo.file
await photo.seek(0)
return {"size": len(content)}Always enforce a maximum file size for image uploads, otherwise users can fill your storage or cause memory issues.
Allowed file types
You should restrict image types to a safe, known list, such as:
image/jpegimage/pngimage/gifimage/webp
Start small, and allow more later only if needed.
You can use:
- The content type reported by the client.
- A server-side check of the file header or attempt to load the image with an image library.
Using only the client-provided MIME type is not enough for security, but it is a quick first filter.
Simple MIME type validation:
ALLOWED_IMAGE_TYPES = {"image/jpeg", "image/png"}
if photo.content_type not in ALLOWED_IMAGE_TYPES:
raise HTTPException(status_code=400, detail="Unsupported image type")To be more confident, use an image library such as Pillow:
from PIL import Image
from io import BytesIO
content = await photo.read()
try:
image = Image.open(BytesIO(content))
image.verify() # basic structural check
except Exception:
raise HTTPException(status_code=400, detail="Invalid image file")Image dimensions
Sometimes you want to limit image width and height, for example to avoid extremely large resolutions.
You can open the image and inspect its size:
from PIL import Image
from io import BytesIO
MAX_WIDTH = 4000
MAX_HEIGHT = 4000
content = await photo.read()
image = Image.open(BytesIO(content))
width, height = image.size
if width > MAX_WIDTH or height > MAX_HEIGHT:
raise HTTPException(status_code=400, detail="Image dimensions too large")Later you will see that you can also resize the image instead of rejecting it.
Renaming and Storing Images
You rarely want to store user uploads with the original filename. User filenames:
- May contain unsafe characters.
- May conflict with existing files.
- Can leak personal information.
It is better to generate your own storage name.
Safe filenames and paths
A common pattern is to generate a new unique ID:
- A UUID.
- A combination of a user ID and timestamp.
- A random string.
Example using UUID:
import uuid
from pathlib import Path
UPLOAD_DIR = Path("uploads")
def generate_image_filename(original_filename: str) -> str:
ext = original_filename.split(".")[-1].lower()
unique_id = uuid.uuid4().hex
return f"{unique_id}.{ext}"You should also decide where on disk to store the file:
UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
new_name = generate_image_filename(photo.filename)
destination = UPLOAD_DIR / new_name
with destination.open("wb") as f:
f.write(content)You can keep a record in the database that links:
- User ID.
- Path or URL of the image.
- Upload timestamp.
- Any other metadata such as image type or size.
Example schema idea:
| Column | Type | Description |
|---|---|---|
| id | UUID | Primary key |
| user_id | UUID | Who owns this image |
| path | text | Storage path or key |
| width | integer | Image width |
| height | integer | Image height |
| content_type | text | MIME type |
| size_bytes | integer | Original file size |
| created_at | timestamp | When it was uploaded |
Resizing, Thumbnails, and Formats
You often do not want to serve the original image to users. Instead, you may want:
- A small avatar.
- A medium image for list pages.
- The original only for download.
This is where image processing comes in.
Creating thumbnails
You can generate a smaller version at upload time:
from PIL import Image
from io import BytesIO
THUMBNAIL_SIZE = (256, 256) # width, height
def create_thumbnail(image_bytes: bytes) -> bytes:
image = Image.open(BytesIO(image_bytes))
image.thumbnail(THUMBNAIL_SIZE)
out = BytesIO()
image.save(out, format="JPEG", quality=85)
return out.getvalue()You can store both:
- The original image.
- The thumbnail.
For example:
original_bytes = content
thumb_bytes = create_thumbnail(original_bytes)
original_path = UPLOAD_DIR / f"{unique_id}_orig.jpg"
thumb_path = UPLOAD_DIR / f"{unique_id}_thumb.jpg"
original_path.write_bytes(original_bytes)
thumb_path.write_bytes(thumb_bytes)You might also choose to discard the original or resize it to a reasonable maximum.
Converting image formats
You can standardize all images to a single format, such as JPEG or WebP.
Example, always saving as JPEG:
def save_as_jpeg(image_bytes: bytes, dest_path: Path):
image = Image.open(BytesIO(image_bytes))
rgb_image = image.convert("RGB")
rgb_image.save(dest_path, format="JPEG", quality=85)This can simplify your frontend, which then expects one consistent format.
However, remember:
- JPEG is not ideal for images with transparency.
- PNG keeps transparency and is lossless.
- WebP can offer good compression but may not be supported everywhere in older environments.
Serving Uploaded Images
After storing images, you need a way to serve them back to clients.
There are several options.
Serving from your backend
Small projects can serve images directly from the backend application.
Example in FastAPI:
from fastapi.responses import FileResponse
from pathlib import Path
UPLOAD_DIR = Path("uploads")
@app.get("/images/{image_name}")
async def get_image(image_name: str):
file_path = UPLOAD_DIR / image_name
if not file_path.is_file():
raise HTTPException(status_code=404, detail="Image not found")
return FileResponse(file_path)Then the frontend uses URLs like:
<img src="/images/1234abcd_thumb.jpg" alt="Avatar">Static file servers and CDNs
For larger projects or higher traffic:
- Put uploads on object storage, such as S3.
- Serve them through a CDN.
- Or configure your reverse proxy to serve files directly from disk, bypassing your application process.
You already saw the basics of static files and possibly S3-compatible storage in other chapters, so here you only need to connect them with image uploads:
- Application receives image, validates, maybe resizes.
- Application stores to disk or S3.
- Application saves only the storage URL or key.
- Frontend uses the URL directly to fetch the image.
This keeps your backend free from frequently repeated image transfers.
Multiple Image Uploads
Sometimes you want to accept more than one image in a single request, for example uploading several product photos at once.
In HTML:
<input type="file" name="photos" multiple accept="image/*">In your backend, your framework usually lets you accept a list of files.
Example with FastAPI:
from typing import List
from fastapi import UploadFile, File
@app.post("/products/{product_id}/photos")
async def upload_photos(
product_id: int,
photos: List[UploadFile] = File(...)
):
results = []
for photo in photos:
# validate and store each image
results.append({"filename": photo.filename})
return {"uploaded": results}You should:
- Apply the same validation rules to each image.
- Decide if you want to fail the whole request if one image is invalid, or skip only invalid ones.
A typical approach is:
- Validate all.
- If any are invalid, abort the request and delete any already stored files for that request.
- Or, for a more forgiving API, accept what is valid and list any errors separately.
Common Patterns for Image Upload APIs
To close this chapter, here is a small, realistic example endpoint that combines several ideas:
- Single avatar upload.
- Size and type checking.
- Storing with a generated name.
- Creating a thumbnail.
import uuid
from pathlib import Path
from io import BytesIO
from fastapi import FastAPI, UploadFile, File, HTTPException
from PIL import Image
app = FastAPI()
UPLOAD_DIR = Path("uploads")
THUMB_DIR = UPLOAD_DIR / "thumbs"
MAX_SIZE_BYTES = 5 * 1024 * 1024 # 5 MB
ALLOWED_TYPES = {"image/jpeg", "image/png"}
THUMB_SIZE = (256, 256)
UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
THUMB_DIR.mkdir(parents=True, exist_ok=True)
def generate_name(ext: str) -> str:
return f"{uuid.uuid4().hex}.{ext}"
def create_thumbnail(image_bytes: bytes) -> bytes:
image = Image.open(BytesIO(image_bytes))
image.thumbnail(THUMB_SIZE)
out = BytesIO()
image.save(out, format="JPEG", quality=85)
return out.getvalue()
@app.post("/users/{user_id}/avatar")
async def upload_avatar(user_id: int, avatar: UploadFile = File(...)):
if avatar.content_type not in ALLOWED_TYPES:
raise HTTPException(status_code=400, detail="Unsupported image type")
content = await avatar.read()
if len(content) > MAX_SIZE_BYTES:
raise HTTPException(status_code=413, detail="Image too large")
try:
image = Image.open(BytesIO(content))
image.verify()
except Exception:
raise HTTPException(status_code=400, detail="Invalid image file")
ext = "jpg" # decide to store as JPEG
original_name = generate_name(ext)
thumb_name = generate_name(ext)
original_path = UPLOAD_DIR / original_name
thumb_path = THUMB_DIR / thumb_name
# Save original as JPEG, converting if needed
image = Image.open(BytesIO(content)).convert("RGB")
image.save(original_path, format="JPEG", quality=90)
thumb_bytes = create_thumbnail(content)
thumb_path.write_bytes(thumb_bytes)
# Normally you would save these paths in the database
return {
"user_id": user_id,
"avatar_url": f"/images/{original_name}",
"avatar_thumb_url": f"/images/thumbs/{thumb_name}",
}This gives you a solid pattern:
- Accept image upload.
- Validate.
- Convert and resize as needed.
- Store in a controlled location with a generated name.
- Return URLs that the frontend can use.
You can adapt this pattern to:
- Product images.
- Gallery uploads.
- Banners and covers.
- Any other image type in your backend.
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!