31.5. Shopping Cart
Table of Contents
Overview
In an e‑commerce backend, the shopping cart connects browsing to buying. It temporarily stores what the user wants, lets them adjust quantities, and feeds data into pricing, discounts, inventory checks, and order creation.
This chapter focuses on how to design and implement the backend side of a shopping cart for a typical REST API, assuming other chapters will cover authentication, products, and orders in detail.
Core Responsibilities of a Shopping Cart
At minimum, your cart must:
- Track which user owns the cart
- Store items, each linked to a product and a quantity
- Allow adding, updating, and removing items
- Calculate totals (subtotal, taxes, discounts, final total)
- Validate products and quantities against business rules
- Be robust to concurrent changes like inventory updates or price changes
You will often expose it through endpoints such as:
GET /cartPOST /cart/itemsPATCH /cart/items/{item_id}DELETE /cart/items/{item_id}
Later, the order creation process will typically use the current cart contents to build an order.
Cart Data Model
Choosing a Cart Ownership Model
There are two common ownership models:
| Model | Description | Pros | Cons |
|---|---|---|---|
| User‑based cart | Cart belongs to an authenticated user | Simple, persists across devices, easy to link | Guests need a temporary user or token |
| Anonymous / session cart | Cart belongs to a session or device identifier | Works for guests, no signup needed | Harder to merge carts when user later logs in |
A practical approach:
- For logged‑in users: use a
user_idto own the cart. - For guests: use a
cart_tokenstored in a cookie or local storage, and later merge into a user cart on login.
Basic Relational Schema
A typical relational model uses two tables: carts and cart_items.
CREATE TABLE carts (
id UUID PRIMARY KEY,
user_id UUID UNIQUE, -- nullable if guest
guest_token VARCHAR(255) UNIQUE, -- nullable if user
currency VARCHAR(3) NOT NULL, -- e.g. 'USD'
created_at TIMESTAMP NOT NULL,
updated_at TIMESTAMP NOT NULL
);
CREATE TABLE cart_items (
id UUID PRIMARY KEY,
cart_id UUID NOT NULL REFERENCES carts(id) ON DELETE CASCADE,
product_id UUID NOT NULL,
quantity INTEGER NOT NULL,
unit_price NUMERIC(10, 2) NOT NULL,
currency VARCHAR(3) NOT NULL,
added_at TIMESTAMP NOT NULL
);Key points:
user_idis usuallyUNIQUEso each user has at most one active cart.- For guests,
guest_tokenidentifies the cart. unit_priceis stored at the time the item is added. This helps with price stability and auditing, even if product prices later change.currencyis stored to avoid mixing currencies in a single cart.
Important rule: Never trust client‑side prices. Always calculate totals on the server, using prices from the database or trusted service.
Capturing More Business Data
Depending on your business rules, you may extend the model:
cart_itemsvariant_id(size, color)max_quantity_per_orderis_gift,notecartscoupon_codediscount_amountexpires_at
Do not prematurely add every field you can imagine. Start with the essentials and extend as needed.
Cart Operations
Adding Items to the Cart
A typical add‑item request:
POST /cart/items
Content-Type: application/json
{
"product_id": "c0b7a50c-...",
"quantity": 2
}Backend workflow:
- Identify the cart (by authenticated user or guest token).
- Validate product:
- Product exists and is active.
- Product is purchasable (not deleted or out of catalog).
- Validate quantity:
quantityis a positive integer.- Optional: respects per‑product max/min.
- Check inventory (depending on when you reserve stock).
- If the product is already in the cart, either:
- Increase existing quantity, or
- Replace quantity with the requested one, depending on API contract.
- Calculate and store current
unit_price. - Recalculate cart totals if you store aggregate fields.
Example business logic in Python‑style pseudocode:
def add_item_to_cart(cart, product_id, quantity):
if quantity <= 0:
raise ValueError("Quantity must be positive")
product = get_product(product_id)
if not product or not product.is_active:
raise ValueError("Product not available")
# Optional inventory check
if product.stock is not None and quantity > product.stock:
raise ValueError("Not enough stock")
item = find_cart_item(cart.id, product_id)
if item:
item.quantity += quantity
item.unit_price = product.price # update to current price or keep old
save_cart_item(item)
else:
item = CartItem(
cart_id=cart.id,
product_id=product_id,
quantity=quantity,
unit_price=product.price,
currency=cart.currency
)
save_cart_item(item)
update_cart_totals(cart.id)
return itemDecide and document whether adding the same product again increments or overwrites quantity.
Updating Item Quantities
Example request:
PATCH /cart/items/{item_id}
Content-Type: application/json
{
"quantity": 3
}Backend workflow:
- Load item by
item_idand cart. - If
quantity == 0, either: - Remove the item, or
- Reject the request. Choose one behavior and document it.
- Validate quantity, product state, and inventory.
- Update the item and recalculate totals.
You can also support partial updates like:
PATCH /cart/items/{item_id}
{
"increment_by": 1
}But that requires a carefully defined API, especially in concurrent environments.
Removing Items
Example request:
DELETE /cart/items/{item_id}Steps:
- Ensure the item belongs to the current cart.
- Delete the item.
- Update cart totals or mark cart as empty if no items remain.
You can also support:
DELETE /cart/itemsTo clear the entire cart.
Retrieving the Cart
Typical endpoint:
GET /cartExample response:
{
"id": "9d6c0d21-...",
"currency": "USD",
"items": [
{
"id": "item-1",
"product_id": "prod-1",
"name": "Red T‑Shirt",
"quantity": 2,
"unit_price": 19.99,
"line_total": 39.98
},
{
"id": "item-2",
"product_id": "prod-2",
"name": "Blue Jeans",
"quantity": 1,
"unit_price": 49.50,
"line_total": 49.50
}
],
"subtotal": 89.48,
"discounts": 5.00,
"tax": 7.56,
"shipping": 0.00,
"total": 92.04
}Separation of concerns:
- The cart backend knows how to compute
subtotal,tax,total. - The frontend only displays what the backend decides.
Calculating Totals
Basic Price Calculations
The simplest model:
- Line total: $line\_total = quantity \times unit\_price$
- Cart subtotal: $subtotal = \sum line\_totals$
- Total: $total = subtotal - discounts + tax + shipping$
Key pricing formula:
$$total = \left(\sum_i quantity_i \times unit\_price_i\right) - discounts + tax + shipping$$
Always compute this on the server.
A small example:
| Item | Quantity | Unit price | Line total |
|---|---|---|---|
| Red T‑Shirt | 2 | 19.99 | $2 \times 19.99 = 39.98$ |
| Blue Jeans | 1 | 49.50 | $1 \times 49.50 = 49.50$ |
Subtotal:
$$subtotal = 39.98 + 49.50 = 89.48$$
If discount is $5.00, tax is $7.56, shipping is $0.00:
$$total = 89.48 - 5.00 + 7.56 + 0 = 92.04$$
When to Recalculate
You can recalculate totals:
- On every cart modification (add, update, remove)
- On explicit request (for example when user clicks "Recalculate")
Most applications recalculate automatically with every write operation so GET /cart always returns up‑to‑date totals.
Handling Price Changes
Two typical strategies when product prices change:
| Strategy | Behavior | Pros | Cons |
|---|---|---|---|
| Sticky cart prices | Keep unit_price as stored in cart_items | Predictable for user | May sell at outdated price |
| Dynamic cart prices | Refresh unit_price from product table periodically | Always uses current price | User total can change unexpectedly |
A common compromise:
- Use sticky prices during a short cart lifetime.
- Refresh prices at checkout and inform the user if any item changed.
Implementation idea:
- Store
unit_priceandprice_checked_atper item. - When user goes to checkout, compare with current product prices.
- If difference is above a threshold, require user confirmation.
Inventory and Availability
When to Reserve Inventory
You must decide when to reduce stock:
- On add to cart
- On order creation
- On payment success
Reserving on add to cart can lead to "stock locked in carts" that never turn into orders. Most systems:
- Only check stock at add to cart and update quantity limits.
- Deduct stock when the order is placed or when payment is confirmed.
Example soft check on add:
if product.stock is not None and quantity > product.stock:
# Limit the item quantity to available stock
quantity = product.stockWhen user proceeds to checkout, do a final inventory validation.
Handling Out‑of‑Stock Items in Cart
Several strategies if an item becomes unavailable:
- Mark the item as unavailable and show a warning.
- Remove the item automatically and notify the user.
- Limit the quantity to the maximum available.
Data model addition:
ALTER TABLE cart_items
ADD COLUMN is_available BOOLEAN NOT NULL DEFAULT TRUE;During cart retrieval:
def refresh_cart_item_availability(cart):
for item in cart.items:
product = get_product(item.product_id)
item.is_available = bool(product and product.is_active and product.stock > 0)Frontends can then disable checkout for unavailable items.
Guest Carts and Merging
Identifying Guest Carts
Typical approach:
- Server generates a
cart_tokenlike a UUID. - The token is stored in an HTTP‑only cookie or local storage.
- Each request includes this token so the backend can find the cart.
Example cookie:
Set-Cookie: cart_token=bd4c...; Path=/; Max-Age=2592000; HttpOnly; SameSite=LaxBackend flow:
- Check authenticated user.
- If no user, look for
cart_token. - If none, create a new cart and return a token.
Merging Carts on Login
When a guest with a cart logs in and they also have an existing user cart, you must decide how to merge.
Strategies:
- Combine quantities for same product.
- Prefer the latest cart and ignore the old one.
- Ask the user which cart to keep (more complex for backend).
Example merge logic:
def merge_carts(user_cart, guest_cart):
for guest_item in guest_cart.items:
user_item = find_cart_item(user_cart.id, guest_item.product_id)
if user_item:
user_item.quantity += guest_item.quantity
save_cart_item(user_item)
else:
move_item_to_cart(guest_item, user_cart.id)
delete_cart(guest_cart.id)
update_cart_totals(user_cart.id)Be explicit about how you handle:
- Different prices in the two carts.
- Out‑of‑stock items.
- Different currencies (usually you do not allow this).
Currency and Tax Considerations
Single Currency vs Multi‑Currency Carts
Simplest approach: one currency per store and cart. The currency field is fixed.
For multi‑currency:
- Store
currencyon the cart and each item. - All prices must be in the same currency for one cart.
- Conversions happen before an item is added to the cart, not inside the cart logic.
If a user changes currency, often you create a new cart in the new currency and discard or convert the old one.
Basic Tax Handling
Tax rules are complex and vary across regions, so only simple logic should be inside the cart service. For example:
- A flat tax rate, like 10 %:
$$tax = subtotal \times 0.10$$
- Or per‑product tax category, resolved by a pricing service.
The cart might delegate tax calculation:
tax = tax_service.calculate_tax(
items=cart.items,
shipping_address=user.shipping_address
)
You then store tax on the cart or compute it on the fly.
API Design for Shopping Cart
Example REST Endpoints
A basic RESTful API design:
| Method | Path | Description |
|---|---|---|
| GET | /cart | Get current cart |
| POST | /cart/items | Add item to cart |
| PATCH | /cart/items/{id} | Update item quantity or options |
| DELETE | /cart/items/{id} | Remove item |
| DELETE | /cart/items | Clear cart |
Sample OpenAPI‑style schema for a cart item:
CartItem:
type: object
properties:
id:
type: string
format: uuid
product_id:
type: string
format: uuid
quantity:
type: integer
minimum: 1
unit_price:
type: number
format: float
currency:
type: string
minLength: 3
maxLength: 3
line_total:
type: number
format: floatExample FastAPI‑Style Models
You might implement these models in Python with Pydantic:
from pydantic import BaseModel, conint, constr
from typing import List
class CartItemCreate(BaseModel):
product_id: str
quantity: conint(gt=0)
class CartItemRead(BaseModel):
id: str
product_id: str
quantity: int
unit_price: float
currency: constr(min_length=3, max_length=3)
line_total: float
class CartRead(BaseModel):
id: str
currency: constr(min_length=3, max_length=3)
items: List[CartItemRead]
subtotal: float
discounts: float
tax: float
shipping: float
total: floatAnd endpoints:
from fastapi import APIRouter, Depends
router = APIRouter(prefix="/cart")
@router.get("", response_model=CartRead)
def get_cart(current_cart = Depends(get_current_cart)):
return build_cart_response(current_cart)
@router.post("/items", response_model=CartItemRead)
def add_cart_item(payload: CartItemCreate,
current_cart = Depends(get_or_create_cart)):
item = add_item_to_cart(current_cart, payload.product_id, payload.quantity)
return build_cart_item_response(item)Consistency and Concurrency
Dealing with Concurrent Updates
Examples of conflicts:
- User A and user B both adjust quantities in the same cart (for example shared account).
- Inventory changes while the user is modifying the cart.
- Price updates while items are being changed.
Common safeguards:
- Database transactions to ensure atomic operations.
- Row‑level locks on
cart_itemsorcartsduring updates. - Optimistic locking using a
versioncolumn.
Simple optimistic locking schema:
ALTER TABLE carts
ADD COLUMN version INTEGER NOT NULL DEFAULT 0;Every update:
- Read current
version. - Update with
WHERE id = ? AND version = ?. - If no rows are updated, someone else changed the cart. Client must reload.
Cart Expiration
Carts can grow without limit if you never remove them. Simple approach:
- Add
expires_atto cart. - If
expires_at < now, treat the cart as expired and create a new one. - Background job that deletes expired carts periodically.
Example field:
ALTER TABLE carts
ADD COLUMN expires_at TIMESTAMP;Expiration strategy:
- Set
expires_at = now() + interval '30 days'on each cart update. - A daily job removes carts where
expires_at < now()and that are not linked to orders.
Putting It All Together
A typical cart lifecycle in your e‑commerce backend:
- User visits the site.
- Backend looks for user or
cart_token. - Returns existing cart or creates new one.
- User adds items.
- Backend validates product and quantity.
- Saves item, recalculates totals.
- User updates or removes items.
- Backend applies changes atomically.
- Prices and availability are rechecked as needed.
- User logs in (if previously a guest).
- Backend merges guest cart into user cart.
- User proceeds to checkout.
- Backend validates prices, stock, discounts.
- Cart contents are transformed into an order.
Throughout this process, the cart acts as a temporary, consistent, server‑trusted representation of the user’s purchase intent, ready to be turned into an order in the next steps of your e‑commerce 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!