12.15. Repository Pattern
Table of Contents
Why Use the Repository Pattern?
In a typical backend application you will write code that:
- Talks to the database using an ORM, for example SQLAlchemy
- Implements business rules and decisions, for example “a user can only create 10 posts per day”
If you mix these in the same place, you quickly end up with code that is:
- Hard to test, because tests must hit a real database
- Hard to change, because business logic and database details are tangled
- Hard to reuse, because every part of the code knows about ORM sessions, models, and queries
The Repository Pattern solves this by putting all data access behind a clear interface. Your application code speaks to repositories, not directly to the ORM.
A simple mental picture:
- Without repository:
Handlers → ORM session + queries + business logic all mixed together - With repository:
Handlers → Repository interface → Repository implementation → ORM + database
Your business logic only depends on interfaces, which makes it easier to test and maintain.
Core Ideas of the Repository Pattern
Repository as a Collection-like Interface
A repository represents a collection of objects of a certain type, for example users or orders. Think of it like a specialized in-memory list, but backed by a database.
Typical operations:
add(entity)get(id)list()remove(entity)ordelete(id)- Custom queries, for example
find_by_email(email)
The important part is that your application does not care how these operations are implemented. It just calls methods on a repository.
A very small example in Python-style pseudocode:
class User:
id: int
email: str
name: str
class UserRepository:
def add(self, user: User) -> User:
...
def get(self, user_id: int) -> User | None:
...
def list(self) -> list[User]:
...
def find_by_email(self, email: str) -> User | None:
...This is just an interface or abstract idea. The real work happens in concrete implementations.
Separating Interface from Implementation
The Repository Pattern is about abstraction. You define:
- A repository interface that describes what can be done
- One or more implementations that describe how it is done
You might have:
SqlAlchemyUserRepositorythat uses SQLAlchemy and PostgreSQLInMemoryUserRepositorythat uses a Python list for fast unit testsRedisUserCacheRepositorythat wraps a Redis cache in front of the main repository
The interface stays the same, only the implementation changes.
In Python, this often looks like:
from abc import ABC, abstractmethod
class UserRepository(ABC):
@abstractmethod
def add(self, user: User) -> User:
...
@abstractmethod
def get(self, user_id: int) -> User | None:
...
@abstractmethod
def find_by_email(self, email: str) -> User | None:
...
class SqlAlchemyUserRepository(UserRepository):
def __init__(self, session):
self.session = session
def add(self, user: User) -> User:
self.session.add(user)
self.session.flush()
return user
def get(self, user_id: int) -> User | None:
return self.session.get(User, user_id)
def find_by_email(self, email: str) -> User | None:
return (
self.session.query(User)
.filter(User.email == email)
.one_or_none()
)
Your route handlers and services only know about UserRepository, not about SqlAlchemyUserRepository.
Benefits in a Backend Application
Decoupling Business Logic from Data Access
When you do not use repositories, you often see code like this in a FastAPI endpoint:
def create_user(db_session: Session, user_in: UserCreate):
# ORM code and business logic mixed
existing = (
db_session.query(User)
.filter(User.email == user_in.email)
.one_or_none()
)
if existing:
raise HTTPException(status_code=400, detail="Email already used")
user = User(
email=user_in.email,
name=user_in.name,
)
db_session.add(user)
db_session.commit()
db_session.refresh(user)
return userThe endpoint:
- Knows about SQLAlchemy
- Knows about how uniqueness is checked
- Knows about transaction handling
With a repository, you can separate roles:
class UserService:
def __init__(self, users: UserRepository):
self.users = users
def register_user(self, email: str, name: str) -> User:
if self.users.find_by_email(email):
raise EmailAlreadyUsed()
user = User(email=email, name=name)
self.users.add(user)
return userThen your FastAPI endpoint becomes:
def create_user(
user_in: UserCreate,
service: UserService = Depends(get_user_service),
):
try:
user = service.register_user(
email=user_in.email,
name=user_in.name,
)
except EmailAlreadyUsed:
raise HTTPException(status_code=400, detail="Email already used")
return userNow:
- Business logic lives in
UserService - Data access is hidden behind
UserRepository - The endpoint is thin and only translates HTTP to service calls
Easier Unit Testing
With a repository interface, you can swap the database implementation for something simpler in tests.
For example, an in-memory repository:
class InMemoryUserRepository(UserRepository):
def __init__(self):
self._items: dict[int, User] = {}
self._id_counter = 1
def add(self, user: User) -> User:
if getattr(user, "id", None) is None:
user.id = self._id_counter
self._id_counter += 1
self._items[user.id] = user
return user
def get(self, user_id: int) -> User | None:
return self._items.get(user_id)
def find_by_email(self, email: str) -> User | None:
return next(
(u for u in self._items.values() if u.email == email),
None,
)Then a unit test for business logic does not need a database at all:
def test_register_user_creates_new_user():
repo = InMemoryUserRepository()
service = UserService(users=repo)
user = service.register_user(
email="test@example.com",
name="Test User",
)
assert user.id is not None
assert repo.get(user.id).email == "test@example.com"You test the logic without worrying about:
- Database connections
- Transactions
- Migrations
- Database performance
This usually makes tests much faster and simpler.
Supporting Multiple Storage Technologies
Because the application only depends on the interface, you can:
- Start with a simple SQLite database and later move to PostgreSQL
- Add a read-side repository that uses a cache like Redis
- Integrate with external systems that act like data sources
For example, two implementations of the same repository:
class SqlAlchemyOrderRepository(OrderRepository):
# uses PostgreSQL via SQLAlchemy
...
class RedisCachedOrderRepository(OrderRepository):
def __init__(self, inner: OrderRepository, redis_client):
self.inner = inner
self.redis = redis_client
def get(self, order_id: int) -> Order | None:
cache_key = f"order:{order_id}"
cached = self.redis.get(cache_key)
if cached:
return deserialize_order(cached)
order = self.inner.get(order_id)
if order:
self.redis.set(cache_key, serialize_order(order))
return order
def add(self, order: Order) -> Order:
order = self.inner.add(order)
cache_key = f"order:{order.id}"
self.redis.set(cache_key, serialize_order(order))
return orderThe service layer does not change. Only the wiring changes when you decide which concrete repository to use.
Typical Repository Design in Python with SQLAlchemy
Below is a small, concrete example that mirrors a real project structure. Details of sessions, models, and transactions belong to other chapters, so we keep those parts simple.
Assume you have a User ORM model.
# models.py
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
email: Mapped[str]
name: Mapped[str]Now define a repository interface and its SQLAlchemy implementation.
# repositories.py
from abc import ABC, abstractmethod
from sqlalchemy.orm import Session
from .models import User
class UserRepository(ABC):
@abstractmethod
def add(self, user: User) -> User:
...
@abstractmethod
def get(self, user_id: int) -> User | None:
...
@abstractmethod
def list(self) -> list[User]:
...
@abstractmethod
def find_by_email(self, email: str) -> User | None:
...
class SqlAlchemyUserRepository(UserRepository):
def __init__(self, session: Session):
self.session = session
def add(self, user: User) -> User:
self.session.add(user)
# flush to get generated primary key without committing
self.session.flush()
return user
def get(self, user_id: int) -> User | None:
return self.session.get(User, user_id)
def list(self) -> list[User]:
return self.session.query(User).all()
def find_by_email(self, email: str) -> User | None:
return (
self.session.query(User)
.filter(User.email == email)
.one_or_none()
)Your service layer consumes the interface:
# services.py
class UserService:
def __init__(self, users: UserRepository):
self.users = users
def register_user(self, email: str, name: str) -> User:
if self.users.find_by_email(email):
raise EmailAlreadyUsed()
user = User(email=email, name=name)
self.users.add(user)
return userThen in your FastAPI dependency injection, you bind the interface to an implementation:
# dependencies.py
from fastapi import Depends
from sqlalchemy.orm import Session
from .db import get_session
from .repositories import SqlAlchemyUserRepository
from .services import UserService
def get_user_repository(
session: Session = Depends(get_session),
) -> SqlAlchemyUserRepository:
return SqlAlchemyUserRepository(session=session)
def get_user_service(
repo = Depends(get_user_repository),
) -> UserService:
return UserService(users=repo)
When you import get_user_service into routes, FastAPI will create SqlAlchemyUserRepository instances for each request automatically.
Common Variations of the Repository Pattern
One Repository per Aggregate or Entity
In many systems you will have:
UserRepositoryOrderRepositoryProductRepository
Each repository handles its own entity type. Methods in each repository are specific and meaningful to that entity.
Example repository methods:
| Entity | Example methods |
|---|---|
| User | find_by_email, list_active, search |
| Order | list_by_user, list_pending, find_paid |
| Product | search_by_name, list_in_category |
The names express intent, not implementation details like join or filter.
Generic Base Repository
Some teams create a base repository with generic CRUD methods and then inherit from it.
from typing import Generic, TypeVar, Type
from sqlalchemy.orm import Session
from .models import Base
T = TypeVar("T", bound=Base)
class SqlAlchemyRepository(Generic[T]):
model_class: Type[T]
def __init__(self, session: Session):
self.session = session
def add(self, entity: T) -> T:
self.session.add(entity)
self.session.flush()
return entity
def get(self, entity_id: int) -> T | None:
return self.session.get(self.model_class, entity_id)
def list(self) -> list[T]:
return self.session.query(self.model_class).all()
class UserRepository(SqlAlchemyRepository[User]):
model_class = User
def find_by_email(self, email: str) -> User | None:
return (
self.session.query(User)
.filter(User.email == email)
.one_or_none()
)This reduces repetition for basic operations and lets you add entity-specific queries in each subclass.
Read and Write Separation
Sometimes you may have:
- A read repository for queries, often optimized for performance
- A write repository for changes, often tied closely to business rules
For example:
class UserReadRepository(ABC):
@abstractmethod
def get(self, user_id: int) -> User | None:
...
@abstractmethod
def list(self) -> list[User]:
...
class UserWriteRepository(ABC):
@abstractmethod
def add(self, user: User) -> User:
...
@abstractmethod
def delete(self, user: User) -> None:
...This pattern is useful for complex systems or CQRS architectures, but for beginner projects a single repository per entity is usually enough.
Practical Examples of Using Repositories
Example: Creating and Fetching a Product
Define a product repository:
class ProductRepository(ABC):
@abstractmethod
def add(self, product: Product) -> Product:
...
@abstractmethod
def get(self, product_id: int) -> Product | None:
...
@abstractmethod
def list_in_stock(self) -> list[Product]:
...
class SqlAlchemyProductRepository(ProductRepository):
def __init__(self, session: Session):
self.session = session
def add(self, product: Product) -> Product:
self.session.add(product)
self.session.flush()
return product
def get(self, product_id: int) -> Product | None:
return self.session.get(Product, product_id)
def list_in_stock(self) -> list[Product]:
return (
self.session.query(Product)
.filter(Product.quantity > 0)
.all()
)In a service:
class ProductService:
def __init__(self, products: ProductRepository):
self.products = products
def create_product(self, name: str, price: float, quantity: int) -> Product:
product = Product(
name=name,
price=price,
quantity=quantity,
)
self.products.add(product)
return product
def list_available_products(self) -> list[Product]:
return self.products.list_in_stock()In a FastAPI route:
@router.post("/products")
def create_product(
data: ProductCreate,
service: ProductService = Depends(get_product_service),
):
product = service.create_product(
name=data.name,
price=data.price,
quantity=data.quantity,
)
return product
@router.get("/products")
def list_products(
service: ProductService = Depends(get_product_service),
):
return service.list_available_products()
You can now unit test ProductService with an in-memory ProductRepository without any web framework or database.
Transaction Handling and Repositories
Repositories often interact with database transactions. There are two common approaches:
- The unit of work pattern handles the transaction and passes a session into repositories.
- The repository itself begins and commits or rolls back transactions.
In modern applications, the first approach is more common. The repository just uses the session it receives. A higher-level component controls when to commit.
Example with a simple unit of work:
class UnitOfWork(ABC):
users: UserRepository
@abstractmethod
def commit(self) -> None:
...
@abstractmethod
def rollback(self) -> None:
...
class SqlAlchemyUnitOfWork(UnitOfWork):
def __init__(self, session_factory):
self.session_factory = session_factory
def __enter__(self):
self.session = self.session_factory()
self.users = SqlAlchemyUserRepository(self.session)
return self
def __exit__(self, exc_type, exc, tb):
if exc:
self.rollback()
else:
self.commit()
self.session.close()
def commit(self) -> None:
self.session.commit()
def rollback(self) -> None:
self.session.rollback()Usage in a service:
def register_user(uow: UnitOfWork, email: str, name: str) -> User:
with uow:
if uow.users.find_by_email(email):
raise EmailAlreadyUsed()
user = User(email=email, name=name)
uow.users.add(user)
return user # committed on successful exitYour business logic now uses repositories and unit of work instead of dealing with raw sessions.
When to Use the Repository Pattern
The Repository Pattern is most useful when:
- You have non-trivial business logic that you want to test thoroughly
- You expect the data access layer to change or become more complex
- You want to keep frameworks and ORMs out of your core domain logic
- You want to use patterns like Domain Driven Design or layered architecture
For very small scripts or simple CRUD prototypes, a full repository layer might feel like extra work. But as projects grow, this separation pays off in clarity and testability.
Key Rules to Remember
Important rules for the Repository Pattern:
- Your business logic should depend on repository interfaces, not concrete ORM implementations.
- Repositories represent collections of aggregate roots or entities and expose intent-based methods like
find_by_email, not raw SQL. - Repository interfaces stay stable while implementations can change to use different databases, caching, or mocking for tests.
- Keep transaction control outside repositories, usually in a unit of work or service layer, so repositories focus on data access, not coordination.
- Tests for business logic should use in-memory or fake repository implementations, not the real database.
If you keep these rules in mind, repositories will help you build backend applications that are easier to change, easier to test, and easier to reason about as they grow.
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!