31.1. Architecture
Table of Contents
Big Picture of the E‑Commerce Backend
Before writing any code, you need a clear mental picture of how the e‑commerce backend fits together. Architecture is that picture. In this chapter you will design the structure of the project at a high level so that later chapters (users, products, cart, orders, payments, caching, background jobs) can plug into it in a clean way.
We will not go deep into syntax or specific frameworks here. Instead, you will learn how to split the e‑commerce domain into modules, layers, and services that are easy to understand, test, and extend.
Goal: Design a clear, modular, layered architecture for an e‑commerce backend so that every feature (user, product, cart, orders, payments) has an obvious place to live.
High‑Level System Overview
At a high level, your e‑commerce backend will look like this:
- Clients
- Web frontend (React, Vue, plain HTML, etc.)
- Mobile app
- Admin dashboard
- Third‑party integrations (for example payment provider webhooks)
- API Backend
- HTTP REST API
- Authentication and authorization
- Validation and business logic
- Background job dispatch (send email, update inventory, etc.)
- Datastores and Infrastructure
- PostgreSQL (main database)
- Redis (caching, sessions, rate limiting, background queues)
- Object storage (for example S3) for product images and invoices
- Message broker / queue (often Redis) for background jobs
- External services (payment provider, email provider)
You can imagine the data and control flow in a simple sequence:
- Client sends HTTP request to API Gateway / Reverse Proxy (for example Nginx).
- Request is passed to Application Server (for example FastAPI + Uvicorn).
- Request enters API layer (routing, authentication, validation).
- API layer calls Service layer (business logic).
- Service layer uses Repository / ORM layer to talk to PostgreSQL and Redis.
- Service layer may enqueue background tasks (for example send email).
- Response bubbles back through API layer to the client.
The details of web servers, Docker, etc. are covered in other chapters, so here you only need to know how these pieces conceptually talk to each other.
Choosing an Architectural Style for This Project
There are many possible architectures. For this project, we will keep it simple and realistic:
- Monolithic backend
One deployable backend application that contains all features (users, products, orders, payments, etc.). - Layered architecture with modular structure
You will organize code into: - Presentation layer (HTTP / API)
- Service / domain layer (business logic)
- Persistence layer (repositories / ORM)
- Infrastructure (email, payments, background jobs, storage)
- Domain‑oriented modules
Even in a monolith, you can group code by features such as: usersproductscategoriescartorderspaymentsinventoryadmincommonorcoreutilities
This gives you a modular monolith. Everything runs in one process and one database, but the code is organized as if they were separate services. This makes future refactoring easier.
Core Domain Modules for an E‑Commerce System
You will use later chapters (User Management, Product Management, etc.) to build each feature. Here you decide what your main domain modules are and how they interact.
A reasonable module breakdown:
| Module | Responsibility |
|---|---|
users | Registration, login, profiles, addresses, roles (customer vs admin) |
products | Products, SKUs, attributes, pricing, stock information |
categories | Organizing products into categories and subcategories |
cart | Shopping carts per user or per session, line items, discounts at cart level |
orders | Converting carts to orders, order statuses, order history |
payments | Payment intents, payment provider integration, capturing and refunds |
inventory | Stock reservations, stock changes after orders, backorders |
background | Email notifications, async tasks, cleanup jobs |
admin | Admin‑only operations (manage products, orders, discounts) |
common | Shared utilities, custom exceptions, base models |
You will not fully design each module here, but you must understand the dependencies between them.
A simplified dependency view:
ordersdepends on:cart(to create an order from a cart)users(customer)productsandinventorypaymentscartdepends on:productsusers(if authenticated carts)- possibly
discountsif you introduce them paymentsdepends on:orders- external payment provider
inventorydepends on:productsordersandcart(for stock reservations and deductions)
Rule: Domain modules should depend on each other in a clear, one‑directional way. Avoid circular dependencies like orders importing payments and payments importing orders in the same layer.
Layered Architecture Inside the Monolith
To keep your codebase maintainable, you will use a layered architecture. The specific names may vary, but at minimum you have:
- API / Presentation Layer
- Routers / controllers
- Request and response models (DTOs)
- HTTP concerns (status codes, headers, query params)
- Service / Domain Layer
- Business rules
- Use cases such as "add item to cart", "place order", "refund payment"
- Transactions and consistency across operations
- Persistence Layer (Repositories / ORM)
- Data access logic
- Database models
- Queries, inserts, updates
- Infrastructure Layer
- Email client
- Payment provider client
- Cache (Redis) adapter
- Background job dispatcher
- File storage client
A simple illustration for the "place order" use case:
POST /orders(API layer) receives the request.- API layer calls
OrderService.place_order(user_id, request_data). OrderService:- Reads the current cart through
CartRepository. - Validates stock through
InventoryService. - Creates an
OrderthroughOrderRepository. - Initiates payment through
PaymentService. OrderServicereturns a result that the API layer converts to a HTTP response.
The API layer does not talk directly to the database or the payment provider. It only talks to services. The services decide which repositories and infrastructure components to use.
Rule: API routes should be very thin. All real business logic goes into service classes or functions.
Example Project Structure
Exact naming will depend on your framework, but you can use a structure similar to this:
app/
main.py # App entrypoint
config.py # Settings and configuration
db/
base.py # DB session / engine setup
models/ # SQLAlchemy models
user.py
product.py
category.py
cart.py
order.py
payment.py
inventory.py
api/ # Presentation layer
deps.py # Common dependencies (auth, DB session, etc.)
v1/
users.py
products.py
categories.py
cart.py
orders.py
payments.py
admin.py
services/ # Business logic / use cases
users.py
products.py
categories.py
cart.py
orders.py
payments.py
inventory.py
repositories/ # Database access layer
users.py
products.py
categories.py
cart.py
orders.py
payments.py
inventory.py
infrastructure/ # External services and technical concerns
email.py
payments.py
storage.py
cache.py
background_tasks.py
schemas/ # Pydantic models (request / response DTOs)
users.py
products.py
categories.py
cart.py
orders.py
payments.py
core/ # Shared utilities and cross‑cutting concerns
security.py
exceptions.py
logging.py
pagination.pyThis is just an example, not a strict template. The key idea is that each feature has:
- Database models
- Repositories
- Services
- API routes
- Schemas
and that these are grouped clearly by feature.
Typical Request Flows in E‑Commerce
To design architecture, it helps to walk through common user actions and ask: Where does each step belong?
Example 1: Browsing Products
Use case: A user wants to see a list of products in a category.
Flow:
GET /products?category_id=10&page=2hits the API layer.- API layer:
- Validates query parameters.
- Converts them to domain types, for example
CategoryId,Page. - Calls
ProductService.list_products(category_id, pagination). ProductService:- Uses
ProductRepositoryto load products from the database. - Applies business rules such as excluding hidden or deleted products.
- Possibly uses cache through
CacheService. - Data is mapped to response schema and returned to the client.
Responsibility separation:
- No SQL in
products.pyrouter. - No HTTP logic (status codes, headers) in
ProductService. - No product filtering rules inside database setup files.
Example 2: Adding to Cart
Use case: User adds a product to their cart.
Flow:
POST /cart/itemswith{"product_id": 123, "quantity": 2}.- API layer:
- Authenticates user.
- Validates request body with a request schema.
- Calls
CartService.add_item(user_id, product_id, quantity). CartService:- Retrieves or creates current cart with
CartRepository. - Checks product existence and price through
ProductRepositoryor aProductService. - Optionally checks inventory with
InventoryService. - Updates cart items, recalculates cart total.
- Persists changes with
CartRepository. - Returns updated cart or success information.
Note that CartService is the main actor here. If you ever move to microservices, this service logic can move to a dedicated cart service, but the API route remains thin.
Example 3: Checkout and Order Creation
Use case: User checks out and creates an order.
Flow:
POST /orders/checkoutwith address, delivery method, and payment method.- API layer:
- Authenticates user.
- Validates request data.
- Calls
OrderService.checkout(user_id, checkout_data). OrderService.checkout:- Reads cart via
CartRepository. - Validates cart (not empty, prices still valid, etc.).
- Starts a database transaction.
- Interacts with
InventoryServiceto reserve stock. - Creates an
OrderandOrderItemrecords viaOrderRepository. - Calls
PaymentServiceto create a payment intent with external provider. - Commits the transaction.
- Schedules background tasks such as "send order confirmation email".
- Returns order summary and payment information.
Here the OrderService coordinates multiple modules: cart, inventory, payments, and background jobs. That is exactly what the service / domain layer is for.
Handling Cross‑Cutting Concerns
Some features do not belong to a single module. They should be designed as cross‑cutting concerns and encapsulated in reusable components.
Examples:
| Concern | Where to put it | Used by modules |
|---|---|---|
| Authentication | core.security, API dependencies | users, orders, cart, admin |
| Authorization | API dependencies / decorators | admin, orders, products |
| Logging | core.logging, middleware | All |
| Caching | infrastructure.cache | products, categories, orders |
| Pagination | core.pagination utilities | products, orders, admin listings |
| Error handling | exceptions + global handlers | All |
| Validation rules | domain services and schemas | All |
For example, you might have a core.exceptions file with custom exceptions:
class DomainError(Exception):
pass
class OutOfStockError(DomainError):
pass
class PaymentFailedError(DomainError):
passThen global exception handlers in your API layer transform these into consistent HTTP error responses.
Rule: Cross‑cutting concerns should live in shared modules, not be re‑implemented in each endpoint or service.
Transactions and Data Consistency
E‑commerce needs strong consistency around orders, payments, and inventory. Your architecture needs a clear policy:
- When do you start a database transaction?
- Which operations must happen atomically?
Typical approach in a monolith:
- Each service method that performs a critical business operation is responsible for the transaction.
Example pattern (pseudocode):
def place_order(user_id: int) -> Order:
with db_session() as session:
cart = cart_repo.get_active_cart_for_user(session, user_id)
inventory_service.reserve_stock(session, cart.items)
order = order_repo.create_from_cart(session, cart)
payment = payment_service.create_payment_intent(session, order)
cart_repo.mark_as_converted(session, cart)
session.commit()
return orderHere you:
- Use a single session / transaction for:
- Reserving stock
- Creating order
- Recording payment intent
- Updating cart
- Commit once at the end.
Background tasks like sending an email are triggered after the transaction commits, or are designed to be idempotent.
Working with External Services
Your e‑commerce backend will talk to services like:
- Payment gateways (Stripe, PayPal, etc.)
- Email providers (SendGrid, SES)
- Storage (S3)
You should not call these external APIs directly from your service or API layer. Instead, you build adapters in the infrastructure layer.
Example idea:
# infrastructure/payments.py
class PaymentGatewayClient:
def create_payment_intent(self, amount_cents: int, currency: str, metadata: dict) -> PaymentIntent:
# Call external API, handle errors, map response
...
# services/payments.py
class PaymentService:
def __init__(self, payment_client: PaymentGatewayClient, payment_repo: PaymentRepository):
self.payment_client = payment_client
self.payment_repo = payment_repo
def create_payment_for_order(self, order: Order) -> Payment:
intent = self.payment_client.create_payment_intent(
amount_cents=order.total_cents,
currency=order.currency,
metadata={"order_id": order.id},
)
return self.payment_repo.save_intent(order, intent)This separation lets you:
- Swap payment providers with minimal changes.
- Mock the
PaymentGatewayClientin tests.
The same pattern works for email and storage clients.
Caching Strategy at the Architectural Level
You will see caching in detail in later chapters, but here you define where caching lives.
Typical caching targets in e‑commerce:
- Product lists and details
- Category trees
- Frequently accessed order summaries (for example on account dashboard)
- Rate limiting and sessions
Where to place caching:
- Implement technical Redis access in
infrastructure.cache. - Implement high‑level caching logic in services, for example
ProductServicedecides when to cache products.
Example idea:
# services/products.py
class ProductService:
def __init__(self, repo: ProductRepository, cache: CacheService):
self.repo = repo
self.cache = cache
def get_product(self, product_id: int) -> Product:
cache_key = f"product:{product_id}"
cached = self.cache.get(cache_key)
if cached is not None:
return cached
product = self.repo.get_by_id(product_id)
self.cache.set(cache_key, product, ttl_seconds=300)
return productThe API layer does not know if the product came from cache or the database.
Synchronous vs Background Work
Not all work should happen in the request‑response cycle. Some tasks are better handled as background jobs:
- Sending order confirmation emails
- Generating invoices
- Updating search indexes
- Cleaning up abandoned carts
Architecturally:
- Services create commands or messages that describe jobs.
- A background worker process subscribes to a queue and performs these jobs.
For this project you can use Redis as a simple queue and something like Celery or a custom worker loop.
Example flow when an order is placed:
OrderService.checkoutcompletes and commits transaction.OrderServicecallsBackgroundTasksService.enqueue("send_order_email", order_id).- Worker receives the job later and calls
EmailService.send_order_confirmation(order_id).
This keeps the checkout response fast and isolates failures in email sending from the main business transaction.
Handling Growth and Future Microservices
You are building a monolith, but you should design with future growth in mind.
Which modules could become microservices one day?
productsandcategoriesas a catalog servicecartandordersas an order servicepaymentsas a payment serviceinventoryas an inventory service
If you follow the patterns in this chapter:
- Clear service boundaries
- Thin controllers
- Separated infrastructure
then you can later move, for example, the order and payment logic to a separate service and expose it via REST or messaging with limited code changes.
You do not need to implement microservices now. You only need to avoid tight coupling that would make that move impossible.
Summary of Architectural Guidelines
To close this chapter, here are the key rules you will follow while building the e‑commerce backend:
- Use a modular monolith with domain‑oriented modules (users, products, cart, orders, payments, inventory, admin).
- Organize code in layers: API, services, repositories, infrastructure.
- Keep API routes thin and put all real business rules into services.
- Implement repositories for database access and avoid SQL in services and routes.
- Put cross‑cutting concerns like auth, logging, pagination, and error handling into shared modules.
- Use transactions around critical operations like checkout and payment.
- Access external systems (payments, email, storage, cache) through infrastructure adapters, not directly.
- Use background jobs for slow or non‑critical tasks, such as emails and cleanups.
With this architecture in mind, you are ready to design and implement the individual parts of your e‑commerce backend in the following chapters.
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!