31.3. Product Management
Table of Contents
Overview
In an e‑commerce backend, “product management” is everything related to storing, updating, and serving product data to clients. This includes product details, pricing, inventory links, categories, and media like images.
In this chapter you will focus on how to design and implement product management for the e‑commerce backend project. Other chapters will cover categories, inventory, and file handling in more depth, so here you will mostly connect to them and focus on product‑specific concerns.
Defining Product Requirements
Before writing any code, you should define what a “product” means in your system. Even for a simple shop, a product usually has at least:
- Basic info: name, description, SKU, slug
- Pricing: regular price, sale price, currency
- Availability: is it active, is it visible
- Categorization: primary category, possibly multiple categories or tags
- Images: main image, gallery
- Inventory: stock quantity, or a link to an inventory system
- Metadata: attributes like color, size, brand
Think in terms of API consumers:
- The storefront needs to:
- List products (with pagination and filtering).
- Show product details.
- Show corrected prices and availability.
- The admin panel needs to:
- Create products.
- Update products.
- Archive or delete products.
- Manage their relationships (categories, images, variants).
Try to write a short example of a product in JSON, which will guide your model:
{
"id": 123,
"name": "Wireless Mouse",
"slug": "wireless-mouse",
"description": "Ergonomic wireless mouse with 2.4 GHz receiver.",
"sku": "MOUSE-001-BLK",
"price": 24.99,
"currency": "USD",
"sale_price": 19.99,
"is_active": true,
"category_id": 5,
"image_url": "https://cdn.example.com/products/mouse-1.jpg"
}This JSON is not final, but it shows the core shape you will work with.
Database Model for Products
The database design of products must integrate nicely with the rest of the project’s schema. For this chapter you only need the core product table and its direct fields. Relationships like categories, inventory, and images will be refined in their own chapters, but you will still reference them here.
A simple products table can look like this:
| Column | Type | Notes |
|---|---|---|
| id | bigint, PK | Autogenerated primary key |
| name | text | Product name shown to customers |
| slug | text, unique | URL‑friendly unique identifier |
| description | text | Long description |
| short_desc | text, nullable | Short description for listings |
| sku | text, unique | Stock keeping unit, internal code |
| price_cents | integer | Price stored in smallest unit |
| sale_price_cents | integer, nullable | Optional sale price |
| currency | char(3) | ISO currency code, for example "USD" |
| is_active | boolean | Controls visibility in the shop |
| created_at | timestamptz | Record creation time |
| updated_at | timestamptz | Last update time |
| category_id | bigint, FK | Reference to categories table |
Use integer cents for pricing, not floating‑point types:
Rule: Store money as an integer number of the smallest currency unit, for example cents, not as a floating‑point type.
For example:
- $price\_cents = \text{round}(price\_dollars \times 100)$
This avoids rounding problems that can show up with float or double.
A basic SQL definition could be:
CREATE TABLE products (
id BIGSERIAL PRIMARY KEY,
name TEXT NOT NULL,
slug TEXT NOT NULL UNIQUE,
description TEXT NOT NULL,
short_description TEXT,
sku TEXT NOT NULL UNIQUE,
price_cents INTEGER NOT NULL CHECK (price_cents >= 0),
sale_price_cents INTEGER CHECK (sale_price_cents >= 0),
currency CHAR(3) NOT NULL,
is_active BOOLEAN NOT NULL DEFAULT TRUE,
category_id BIGINT REFERENCES categories(id),
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
You can add database‑side triggers or application logic to keep updated_at in sync.
Product Domain Rules
Your backend should enforce important product rules consistently, both at the API layer and in the database or domain layer.
Typical rules:
- A product must have:
- A non‑empty name.
- A unique slug.
- A unique SKU.
- A non‑negative price.
- If
sale_price_centsis set, it must be less than or equal toprice_cents. - Only
is_active = trueproducts should appear in public listings. - Currency must be from a known set, for example
{"USD", "EUR", "GBP"}.
You can enforce the sale price rule in domain logic:
def validate_prices(price_cents: int, sale_price_cents: int | None) -> None:
if price_cents < 0:
raise ValueError("Price must be non-negative")
if sale_price_cents is not None and sale_price_cents > price_cents:
raise ValueError("Sale price must be less than or equal to regular price")And optionally as a database constraint:
ALTER TABLE products
ADD CONSTRAINT sale_price_lte_price
CHECK (
sale_price_cents IS NULL
OR sale_price_cents <= price_cents
);Product Models and DTOs
In a typical Python + FastAPI + SQLAlchemy setup, you will have different layers of models:
- ORM models for database representation.
- Pydantic models for API input and output (DTOs).
Example SQLAlchemy model (simplified):
from sqlalchemy import Column, Integer, String, Boolean, Text, ForeignKey
from sqlalchemy.orm import relationship
from app.db.base_class import Base # your project’s base class
class Product(Base):
__tablename__ = "products"
id = Column(Integer, primary_key=True, index=True)
name = Column(Text, nullable=False)
slug = Column(String, unique=True, nullable=False, index=True)
description = Column(Text, nullable=False)
short_description = Column(Text, nullable=True)
sku = Column(String, unique=True, nullable=False, index=True)
price_cents = Column(Integer, nullable=False)
sale_price_cents = Column(Integer, nullable=True)
currency = Column(String(3), nullable=False)
is_active = Column(Boolean, nullable=False, default=True)
category_id = Column(Integer, ForeignKey("categories.id"), nullable=True)
category = relationship("Category", back_populates="products")Example Pydantic models:
from pydantic import BaseModel, Field, validator
from typing import Optional
class ProductBase(BaseModel):
name: str = Field(..., max_length=255)
slug: str = Field(..., max_length=255)
description: str
short_description: Optional[str] = None
sku: str = Field(..., max_length=64)
price: float = Field(..., gt=0)
sale_price: Optional[float] = Field(None, gt=0)
currency: str = Field(..., min_length=3, max_length=3)
is_active: bool = True
category_id: Optional[int] = None
@validator("sale_price")
def check_sale_price(cls, sale_price, values):
price = values.get("price")
if sale_price is not None and price is not None and sale_price > price:
raise ValueError("Sale price must be less than or equal to price")
return sale_price
class ProductCreate(ProductBase):
pass
class ProductUpdate(BaseModel):
name: Optional[str] = None
slug: Optional[str] = None
description: Optional[str] = None
short_description: Optional[str] = None
price: Optional[float] = Field(None, gt=0)
sale_price: Optional[float] = Field(None, gt=0)
currency: Optional[str] = Field(None, min_length=3, max_length=3)
is_active: Optional[bool] = None
category_id: Optional[int] = None
class ProductOut(ProductBase):
id: int
class Config:
orm_mode = TrueNotice the separation:
ProductCreatefor POST.ProductUpdatefor PATCH or PUT.ProductOutfor responses, which includesid.
In the repository or service layer you will convert between price (float or decimal in the API) and price_cents (int in the database).
Product CRUD Operations
Your product management API will at least support:
| Operation | HTTP Method | URI | Who uses it |
|---|---|---|---|
| Create product | POST | /admin/products | Admins |
| List products | GET | /products | Public |
| Get product | GET | /products/{slug} | Public |
| Update product | PUT/PATCH | /admin/products/{id} | Admins |
| Delete/archive | DELETE | /admin/products/{id} | Admins |
For the public API, prefer lookups by slug so URLs are stable and readable:
/products/wireless-mouse/products/hoodie-blue
For the admin API, using numeric id is often simpler and fine.
Example create endpoint (FastAPI style, simplified, without auth):
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from app.api.deps import get_db
from app.schemas.product import ProductCreate, ProductOut
from app import crud
router = APIRouter(prefix="/admin/products", tags=["admin:products"])
@router.post("", response_model=ProductOut, status_code=status.HTTP_201_CREATED)
def create_product(
product_in: ProductCreate,
db: Session = Depends(get_db),
):
# Check if slug or SKU already exists
existing_by_slug = crud.product.get_by_slug(db, slug=product_in.slug)
if existing_by_slug:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Slug already exists",
)
existing_by_sku = crud.product.get_by_sku(db, sku=product_in.sku)
if existing_by_sku:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="SKU already exists",
)
product = crud.product.create(db, obj_in=product_in)
return productExample public listing endpoint:
@router.get("/products", response_model=list[ProductOut])
def list_products(
db: Session = Depends(get_db),
limit: int = 20,
offset: int = 0,
):
products = crud.product.get_multi_public(
db,
limit=limit,
offset=offset,
)
return productsFor the project, you will connect these endpoints with authentication and authorization in other chapters.
Product Filtering and Pagination
In an e‑commerce store, listing products means more than just “SELECT * FROM products”. You need filters and ordering.
Common filters:
- Category
- Price range
- Search term (keyword)
- Is on sale
- Sorting (price low to high, latest, etc.)
Define query parameters like:
GET /products?category=electronics&min_price=10&max_price=100&sort=price_asc&page=1&page_size=20
Example FastAPI signature:
from typing import Optional
@router.get("/products", response_model=list[ProductOut])
def list_products(
db: Session = Depends(get_db),
category: Optional[str] = None,
search: Optional[str] = None,
min_price: Optional[float] = None,
max_price: Optional[float] = None,
on_sale: Optional[bool] = None,
sort: str = "newest",
page: int = 1,
page_size: int = 20,
):
products = crud.product.search_public(
db=db,
category_slug=category,
search=search,
min_price=min_price,
max_price=max_price,
on_sale=on_sale,
sort=sort,
page=page,
page_size=page_size,
)
return productsInside the repository, you can translate these into SQLAlchemy queries.
Example SQLAlchemy filter logic:
from sqlalchemy import select, or_, and_
from sqlalchemy.orm import Session
from app.models import Product, Category
def search_public(
db: Session,
category_slug: str | None,
search: str | None,
min_price: float | None,
max_price: float | None,
on_sale: bool | None,
sort: str,
page: int,
page_size: int,
):
query = select(Product).where(Product.is_active == True)
if category_slug:
query = (
query
.join(Product.category)
.where(Category.slug == category_slug)
)
if search:
pattern = f"%{search.lower()}%"
query = query.where(
or_(
Product.name.ilike(pattern),
Product.description.ilike(pattern),
)
)
if min_price is not None:
query = query.where(Product.price_cents >= int(min_price * 100))
if max_price is not None:
query = query.where(Product.price_cents <= int(max_price * 100))
if on_sale is True:
query = query.where(Product.sale_price_cents.isnot(None))
elif on_sale is False:
query = query.where(Product.sale_price_cents.is_(None))
if sort == "price_asc":
query = query.order_by(Product.price_cents.asc())
elif sort == "price_desc":
query = query.order_by(Product.price_cents.desc())
else:
# default sort
query = query.order_by(Product.created_at.desc())
offset = (page - 1) * page_size
query = query.limit(page_size).offset(offset)
return db.execute(query).scalars().all()Pagination and filtering will need careful performance tuning when you add indexes, but this pattern is a solid starting point.
Product Status and Soft Deletion
A real store rarely hard‑deletes products. Historical orders still reference them, and analytics need them.
There are two typical approaches:
- Use an
is_activeflag: - Keep the row.
- Hide it from public listings.
- Possibly still show it in admin and in past orders.
- Use both
is_activeand adeleted_attimestamp, often called soft deletion.
For this project, an is_active field is usually enough. Use it systematically:
- Public queries: always filter with
Product.is_active == True. - Admin queries: show both active and inactive, and maybe filter on it explicitly.
Delete endpoint example that uses soft deletion instead of actual delete:
@router.delete("/admin/products/{product_id}", status_code=204)
def archive_product(
product_id: int,
db: Session = Depends(get_db),
):
product = crud.product.get(db, id=product_id)
if not product:
raise HTTPException(status_code=404, detail="Product not found")
product.is_active = False
db.add(product)
db.commit()
returnYou can still offer a “hard delete” in admin if necessary, for example when a product has no orders.
Product Pricing and Display Logic
The API that returns a product should provide a clear “effective price” that the frontend can show without guessing.
You can either:
- Compute
effective_priceon the backend, or - Let the frontend compare
priceandsale_price.
Having the backend compute it is usually better for consistency. For example, extend the response model:
class ProductOut(BaseModel):
id: int
name: str
slug: str
description: str
short_description: Optional[str]
sku: str
price: float
sale_price: Optional[float]
currency: str
is_active: bool
category_id: Optional[int]
effective_price: float
class Config:
orm_mode = TrueAnd in your service layer:
def to_product_out(product: Product) -> ProductOut:
price = product.price_cents / 100
sale_price = (
product.sale_price_cents / 100 if product.sale_price_cents is not None else None
)
effective_price = sale_price if sale_price is not None else price
return ProductOut(
id=product.id,
name=product.name,
slug=product.slug,
description=product.description,
short_description=product.short_description,
sku=product.sku,
price=price,
sale_price=sale_price,
currency=product.currency,
is_active=product.is_active,
category_id=product.category_id,
effective_price=effective_price,
)
You can also add flags like is_on_sale:
is_on_sale = sale_price is not None and sale_price < priceThis makes it easy for clients to show sale badges.
Connecting Products with Categories and Inventory
This chapter focuses on products, but you must keep in mind how products will connect to categories and inventory, which have their own chapters.
You will typically:
- Use
category_idor a many‑to‑many table for product‑category relationships. - Use a separate
inventory_itemstable or astock_quantitycolumn.
Some common patterns:
| Concern | Minimal approach | More advanced approach |
|---|---|---|
| Categories | products.category_id | product_categories join table |
| Inventory | products.stock_quantity | inventory_items table per warehouse |
| Media | products.image_url | product_images table |
For the project:
- Start with a simple
category_idfield and a basic inventory representation. - Add more advanced structures in the separate “Categories” and “Inventory” chapters.
When designing endpoints consider both:
- Public product details may need to show:
- Category:
category_name,category_slug. - Availability: “in stock” or “out of stock”.
To avoid circular dependencies or heavy joins everywhere, you can create a “rich product” response model that includes nested objects:
class CategorySummary(BaseModel):
id: int
name: str
slug: str
class InventorySummary(BaseModel):
in_stock: bool
stock_quantity: int
class ProductDetail(ProductOut):
category: Optional[CategorySummary]
inventory: InventorySummary
Then use this model only for detail views, for example GET /products/{slug}, while list views use the lighter ProductOut model.
Typical Product Management Workflows
To wrap up, here is how a standard product management flow looks from the admin side and the customer side.
Admin workflow:
- Admin creates a product draft:
- POST
/admin/products - Fills in basic details, price, SKU, and chooses category.
- Admin uploads product images:
- Uses file upload endpoints described in the “Working with Files” and “Image Uploads” chapters.
- Admin adjusts inventory:
- Uses “Inventory” or “Stock” related endpoints.
- Admin publishes the product:
- Sets
is_active = trueif it is not already.
Customer workflow:
- Customer opens a category page:
- GET
/products?category=some-category&sort=newest&page=1 - Backend returns only
is_active = trueproducts. - Customer opens a product detail page:
- GET
/products/some-product-slug - Backend returns product with category, effective price, sale information, and availability.
- Customer adds product to cart:
- Uses endpoints described in the “Shopping Cart” chapter.
- Backend uses product and inventory info to validate the operation.
Your product management implementation must support both these workflows reliably and efficiently.
As you continue the project, you will integrate these product concepts with categories, images, inventory, cart, and orders, but the core idea remains: a clear and consistent product model, with strict domain rules, and well designed CRUD and listing APIs.
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!