32.2. Designing the Architecture
Table of Contents
Clarifying the Goal
In this chapter you design the architecture for your final production-ready backend project.
You are not building endpoints yet. You are deciding how the system will be structured, which parts it will have, how they talk to each other, and which responsibilities each part gets.
The focus is on:
- Identifying major components (services, databases, background workers, etc.).
- Choosing an architectural style.
- Defining clear boundaries and responsibilities.
- Planning how cross-cutting concerns like logging, security, and configuration will fit in.
All later chapters in the final project will plug into this architecture.
A good architecture is about clear boundaries, simple communication, and explicit responsibilities, not about using as many fancy patterns and tools as possible.
Requirements Summary
Before you design the architecture you should restate the main requirements of the final project in technical terms. The exact project idea can vary, but a realistic production backend usually needs:
- A public REST API, consumed by a web or mobile frontend.
- Authentication and authorization.
- A relational database (PostgreSQL) for persistent data.
- Caching (Redis) for performance and some features (sessions, rate limits, etc.).
- Background workers for slow or long-running tasks.
- File storage (for images or documents).
- Observability (logging, metrics, health checks).
- CI/CD, Docker, and deployment to a server.
From these you derive system-level requirements:
| Area | Requirements example |
|---|---|
| API | JSON REST API, versioned, secure over HTTPS |
| Data | Strong consistency, transactions, relational schema, migrations |
| Performance | Fast responses for common reads, pagination, caching, connection pooling |
| Scalability | Ability to run multiple app instances, stateless API nodes |
| Security | JWT-based auth, HTTPS, secure password storage, secure secrets |
| Reliability | Graceful shutdown, health checks, background job retries, backups |
| Operability | Structured logs, metrics, alerts, environment-based config |
You will design an architecture that satisfies these requirements without overcomplicating it.
Choosing an Architectural Style
You have many options, but for a single backend application built by one person or a small team, you typically choose between:
- A simple monolith
- A modular monolith
- Full microservices
For this final project, microservices are overkill. They introduce network overhead, distributed transactions, complex deployment, and a lot of operational burden.
A modular monolith is usually the best choice.
Modular Monolith Overview
A modular monolith is:
- One deployable application.
- Internally split into modules with clear boundaries.
- Modules communicate via function calls, not over the network.
- Shared infrastructure like the database and Redis is typically used, but each module owns its part of the domain.
Example high-level modules:
usersauthproductsorderspaymentsfilesnotifications
These are logical boundaries, not separate microservices.
Use one deployable app with multiple well-defined modules. Avoid splitting into microservices unless you have strong reasons and experience to manage the added complexity.
You will also follow a layered architecture inside the monolith.
High-Level System Architecture
At the highest level, your production backend system will usually have:
- Clients
- Web frontend (React / Vue / etc.), mobile apps, or external API clients.
- Reverse proxy / load balancer
- Nginx or Traefik in front of the app.
- Terminates TLS, routes requests to app containers.
- Application server
- FastAPI app, run by Uvicorn + Gunicorn.
- Stateless HTTP API.
- Database
- PostgreSQL instance for relational data.
- Cache and message broker
- Redis for:
- Caching reads.
- Storing short-lived keys (tokens, rate limits, sessions).
- Acting as Celery broker / result backend.
- Background workers
- Celery workers (or similar) running the same codebase but executing background tasks.
- File storage
- Local filesystem for development.
- Cloud object storage (S3 or compatible) for production.
- Observability
- Logging system (to stdout, then collected by Docker / server).
- Metrics endpoint for Prometheus.
- Health check endpoints for load balancers.
You can visualize a simple request path:
Client → HTTPS → Nginx → FastAPI (app server) → PostgreSQL / Redis → Response
And a background task path:
FastAPI → push job to Redis (Celery) → Worker consumes job → DB / email / file storage
Logical Layers Inside the Application
Inside the FastAPI app you will structure code into layers. A common simple decomposition:
- API layer (FastAPI routes)
- Service / domain layer
- Repository / persistence layer
- Infrastructure / integration layer
API Layer
Responsibilities:
- Define HTTP endpoints and routes.
- Parse and validate requests (Pydantic models).
- Handle authentication / authorization for endpoints.
- Map service-layer outputs to HTTP responses.
The API layer does not:
- Talk to the database directly.
- Contain business rules.
Example structure:
app/
api/
v1/
users.py
auth.py
products.py
orders.pyEach file defines a FastAPI router for that domain.
Service Layer
Responsibilities:
- Implement business use cases.
- Orchestrate repositories, background tasks, and validations.
- Encapsulate core business logic.
Examples of service methods:
register_usercreate_orderadd_item_to_cartprocess_payment
API endpoints call service functions or classes. Services call repositories and other infrastructure.
Repository Layer
Responsibilities:
- Handle persistence for aggregates and entities.
- Use SQLAlchemy (or similar) to interact with PostgreSQL.
- Hide SQL or ORM details from services.
Example:
UserRepository.get_by_emailOrderRepository.create_with_items
The service layer should not know about SQL, just that it can save, find, or update domain objects.
Infrastructure / Integration Layer
Responsibilities:
- External services:
- Email provider.
- Payment gateway.
- Message queues.
- File storage.
- Technical utilities:
- Caching wrapper.
- Token generation.
- Password hashing.
- Logging helpers.
This layer is where you integrate third-party libraries, like:
boto3for S3.- Payment SDKs.
- Email SDKs.
Domain Modules and Boundaries
Within the layered structure you will have domain modules. Each module implements its own:
- Pydantic schemas (request / response models).
- SQLAlchemy models (database tables).
- Services.
- Repositories.
- Routers.
Example Module Breakdown
Imagine an e-commerce-like final project. A reasonable separation could be:
| Module | Responsibilities |
|---|---|
users | User profiles, basic data, account management |
auth | Registration, login, logout, tokens, password reset, email verification |
products | Product catalog, categories, pricing |
orders | Carts, orders, order items, order lifecycle |
payments | Payment initiation, status tracking, webhook processing |
files | File uploads, image resizing, links, storage paths |
notifications | Email notifications, background sending, templates |
admin | Admin-only operations, dashboards, data exports |
Each module:
- Owns its routes under a prefix, for example
/api/v1/users,/api/v1/orders. - Owns its part of the database schema.
- Exposes services that may be used by other modules.
Keep data ownership within modules. For example, only the orders module should be responsible for changing an order status. Other modules should call its services instead of directly manipulating its tables.
Example Cross-Module Communication
authneeds user data- It calls
usersrepository or service to get user records. ordersneeds product info to calculate totals- It uses a
ProductServiceinterface rather than querying the product table directly from random places. paymentsneeds order total- It calls
OrderServiceto get final amount and status.
In a modular monolith, these are function calls in the same codebase, not network requests.
Choosing the Data Flow Patterns
You will mostly use request / response for API endpoints and command-style service methods for actions.
Example flow for creating an order:
- Client calls
POST /api/v1/orderswith cart items. - API layer:
- Validates input.
- Gets current user from auth dependency.
- Calls
OrderService.create_order(user, items). OrderService:- Validates products exist using
ProductRepository. - Calculates totals, taxes, discounts.
- Creates order and order items using
OrderRepository. - Returns order DTO.
- API layer:
- Maps order DTO to response model.
- Returns
201 Createdwith order data.
For long operations, like sending emails or processing payments:
- The service layer schedules background tasks via Celery.
- Workers perform the heavy work asynchronously.
Planning for Asynchronous vs Synchronous Parts
Since you use FastAPI, you will have async capabilities. But not everything must be async.
General rules:
- Async for:
- HTTP endpoints.
- Database calls via async driver.
- External IO calls (HTTP to email provider, payment gateway, etc.).
- Background workers may stay sync if using normal Celery with sync libraries.
Structure:
- Main FastAPI app:
- Majority of endpoints are declared as
async def. - Background workers:
- Run tasks defined in same codebase, triggered via Redis.
Design decision:
- Keep core business logic independent of async when possible.
- For example,
OrderService.create_ordermay be a regular function that accepts dependencies. - The API layer uses
awaitto fetch data from repositories and then calls pure functions for business rules.
Database and Data Access Design
At architecture level you decide:
- You use PostgreSQL as your main relational database.
- You use SQLAlchemy as ORM.
- You use Alembic for migrations.
- You use connection pooling and short-lived sessions per request.
Database Integration Pattern
You can follow a typical pattern:
- One
SessionLocalfactory from SQLAlchemy. - Dependency-injected session per request in FastAPI.
- Repositories receive a session object.
Example concept:
def get_db_session():
db = SessionLocal()
try:
yield db
finally:
db.close()
Each repository method expects db: Session.
This is an example of the repository pattern, used to decouple higher layers from the ORM.
Module Ownership Over Tables
Decide table ownership:
usersmodule:userstable.- maybe
user_profiles. authmodule:refresh_tokens,email_verifications,password_resets.productsmodule:products,categories.ordersmodule:orders,order_items, maybecarts.paymentsmodule:payments,payment_attempts.filesmodule:files,file_links.
Keep foreign keys clear and avoid circular dependencies where possible.
Caching and Redis Usage Design
You need a plan for how you will use Redis, not just "we will cache things".
Typical usages:
- Application caching
- Cache common read-heavy data, such as product lists or category trees.
- Key plan example:
products:list:page:{page}:{filters_hash}product:{product_id}- Authentication-related data
- Optional session store for session-based auth.
- Blacklist or "revoked" token lists if needed.
- Rate limiting
- Keys like
rate:user:{user_id}:{window_start}. - Background processing
- Redis as Celery broker and result backend.
General caching rules:
Design cache keys with:
- A clear prefix for the feature (for example
products:,users:). - No sensitive data in the key or value.
- Expiration (TTL) to prevent stale data from living forever.
You will not implement all caching logic here, but your architecture should consider:
- A small caching service wrapper in the infrastructure layer.
- Policies on what can be cached and cache invalidation points (for example, when a product is updated or deleted).
Background Processing Design
You must plan which tasks will be executed in the background and how they are connected.
Typical background jobs:
- Send emails (welcome, reset password, order confirmation).
- Process large or slow operations:
- Generating PDFs or reports.
- Image resizing or thumbnail generation.
- Handling third-party webhooks processing.
- Cleaning up expired data.
Architecture:
- Celery workers using same codebase.
- You keep a
tasksmodule where tasks are defined: notifications.tasks.send_emailorders.tasks.recalculate_order_summariesfiles.tasks.generate_thumbnail
Communication:
- The service layer schedules a task:
send_welcome_email.delay(user_id)- Workers take jobs from Redis and run them, interacting with the same database and services.
You also plan:
- Retry strategies (automatic Celery retries for transient failures).
- Idempotency for tasks that may run more than once.
- Logging inside tasks for debugging.
File Storage Architecture
You must decide how to handle files such as images or documents.
Design decisions:
- Abstraction:
- Define a
FileStorageinterface / service with methods: save_file,delete_file,get_url.- Implementation for:
- Local storage (development).
- S3-compatible storage (production).
- Where paths are stored:
- Store only relative paths or object keys in the database.
- Example:
files/avatars/user_123.png,orders/invoices/abc123.pdf. - Access control:
- Some files may be public (for example product images).
- Some files may be private (for example invoices, user documents).
- For private files, you may use presigned URLs, not direct public URLs.
By abstracting file storage behind a service, you can:
- Switch implementations without changing business logic.
- Keep tests simple by using an in-memory or local filesystem adapter.
Configuration and Environment Separation
Your architecture must support different environments:
- Development
- Testing
- Staging
- Production
Configuration design:
- Environment variables are primary source of configuration.
- Use a settings class (for example Pydantic
BaseSettings). - Separate settings by domain:
- App config (port, debug, allowed origins).
- Database config (URL, pool size).
- Redis config (URL).
- Security config (JWT secret, algorithm, token lifetimes).
- Email config (SMTP, API keys).
- Storage config (S3 bucket, region).
Configuration is injected, not hard-coded, so you can:
- Run tests with in-memory or local resources.
- Deploy multiple environments with different credentials.
Cross-Cutting Concerns
Some parts of your architecture cross module boundaries. You must plan how to handle them centrally.
Logging
Design:
- Use structured logging with JSON or key-value pairs.
- Attach correlation / trace IDs per request, so logs from one request can be grouped.
- Use FastAPI middleware to log:
- Request method, path, status code, latency.
- Ensure logs go to stdout so Docker and your server can collect them.
Metrics and Health Checks
Design:
- A
/healthor/healthzendpoint for load balancers. - Possibly
/metricsfor Prometheus. - Consider metrics such as:
- Request rate per endpoint.
- Error rate.
- Task queue lengths.
Security
Many security features are part of other chapters but architecturally you must:
- Use JWT for stateless auth between client and API.
- Protect sensitive endpoints with authorization checks in services or dependencies.
- Centralize:
- Password hashing utilities.
- Token creation / verification.
- Security headers configuration.
- CORS configuration.
Define clear boundaries:
authmodule is responsible for:- Generating and validating tokens.
- Authentication workflows.
- Other modules simply rely on "current user" or "current admin" dependencies.
Error Handling and Validation
You need a consistent plan for how errors flow through the system.
- Validation errors at API layer:
- Use Pydantic models and FastAPI standard error responses.
- Business rule errors:
- Define custom exceptions in the service layer.
- Map them to HTTP responses using FastAPI exception handlers.
Examples:
UserAlreadyExistsError→ HTTP 409.InsufficientStockError→ HTTP 400 or 409.PermissionDeniedError→ HTTP 403.
By centralizing exception handling in a dedicated module (for example app.api.errors), your endpoints can remain clean and your architecture predictable.
Example Directory Structure
A concrete example for your final project:
app/
core/
config.py # Settings classes
security.py # JWT, password hashing
logging.py # Logging setup
exceptions.py # Base exceptions
db/
base.py # Base models, metadata
session.py # SessionLocal, engine
migrations/ # Alembic migrations
api/
deps.py # Common dependencies
errors.py # Exception handlers
v1/
users.py
auth.py
products.py
orders.py
payments.py
files.py
admin.py
users/
models.py
schemas.py
repository.py
service.py
auth/
models.py
schemas.py
repository.py
service.py
tokens.py
products/
models.py
schemas.py
repository.py
service.py
orders/
models.py
schemas.py
repository.py
service.py
tasks.py
payments/
models.py
schemas.py
repository.py
service.py
gateway.py
files/
models.py
schemas.py
storage.py
service.py
tasks.py
notifications/
email_service.py
tasks.py
tasks/
celery_app.py # Celery configuration, app instance
main.py # FastAPI app factoryThis structure shows:
- Clear separation between API, domain modules, core infrastructure, and database.
- Each module is a "slice" containing models, schemas, repositories, and services.
Architectural Trade-Offs and Constraints
Every architecture is a compromise. You should explicitly accept some trade-offs:
- Single database vs multiple databases:
- Easier to manage, but modules can interfere if not disciplined.
- Single codebase vs many:
- Faster development and refactoring, but you must keep modules separate by convention.
- Modular monolith vs microservices:
- Less operational complexity and faster iteration.
- Harder to scale specific modules independently at the infrastructure level.
- For this project, that is acceptable.
- Rich domain model vs anemic:
- You likely keep most logic in service layer functions instead of deep domain object hierarchies, to keep code simpler and more approachable.
Make sure your design supports:
- Running multiple app instances behind a load balancer.
- Scaling workers separately from API instances.
- Evolving modules and possibly extracting them later if needed.
Summary and Next Steps
You now have:
- A modular monolith design, with:
- Clear domain modules (users, auth, products, orders, etc.).
- Layers:
- API, service, repository, infrastructure.
- A system architecture that includes:
- FastAPI application, PostgreSQL, Redis, Celery workers, file storage, and reverse proxy.
- Cross-cutting plans for:
- Configuration, logging, security, error handling, background jobs, and caching.
In the following chapters you will:
- Design the database schema to match these modules.
- Implement the REST API following the architecture.
- Integrate PostgreSQL, Redis, file storage, and background workers according to this plan.
Keep this architecture as your reference while implementing features. If you feel tempted to add a shortcut that breaks boundaries, consider whether it is worth the future complexity or if you can extend the architecture cleanly instead.
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!