12.6. Reading Records
Table of Contents
Reading Data with an ORM
Reading data is the operation you perform most often in real applications. In ORM terms this is called querying. In this chapter you will learn how to fetch data from the database using an ORM, with concrete examples in SQLAlchemy, which is the ORM used throughout this course.
You already learned what an ORM is and how models and sessions work in the previous chapters. Here we focus only on how to read records in different ways.
Basic Queries: Getting All Records
The most basic query is “give me all rows of this table”.
Assume you have this SQLAlchemy model:
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy import String, Integer
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(Integer, primary_key=True)
email: Mapped[str] = mapped_column(String, unique=True, nullable=False)
name: Mapped[str] = mapped_column(String, nullable=False)
age: Mapped[int] = mapped_column(Integer)And a session:
from sqlalchemy.orm import Session
session = Session(engine)Select all rows for a model
SQLAlchemy 2 style:
from sqlalchemy import select
stmt = select(User)
result = session.execute(stmt)
users = result.scalars().all()What happens:
select(User)prepares a query:SELECT * FROM userssession.execute(stmt)sends it to the databaseresult.scalars()returns only theUserobjects, not raw rows.all()fetches all results into a Python list
You can loop directly:
for user in users:
print(user.id, user.email)Older style (still seen in many code bases):
users = session.query(User).all()Both are equivalent in effect.
Rule: Use select(Model) and result.scalars() to get ORM objects. Use .all() only when you really want all rows in memory.
Getting a Single Record
Most of the time you want one record, not all of them.
Get by primary key
If you know the primary key, use session.get:
user = session.get(User, 1) # primary key = 1
if user is None:
print("User not found")
else:
print(user.email)This will run something like:
SELECT * FROM users WHERE id = 1;
session.get:
- Fetches by primary key only
- Returns
Noneif not found - Optionally can use the identity map cache (if loaded in the session already)
Get the first matching row
If you want the first row matching some condition:
from sqlalchemy import select
stmt = select(User).where(User.email == "alice@example.com")
result = session.execute(stmt)
user = result.scalars().first()
if user:
print("Found:", user.name)
else:
print("No such user")
.first() returns:
- The first
Userobject - Or
Noneif there are no rows
Exactly one row: `.one()` and `.one_or_none()`
Sometimes you expect exactly one row:
stmt = select(User).where(User.email == "alice@example.com")
result = session.execute(stmt)
user = result.scalars().one().one():- Returns the single row
- Raises
NoResultFoundif no row exists - Raises
MultipleResultsFoundif more than one row exists
from sqlalchemy.exc import NoResultFound, MultipleResultsFound
try:
user = result.scalars().one()
except NoResultFound:
print("User does not exist")
except MultipleResultsFound:
print("More than one user with that email")
.one_or_none() is similar but returns None instead of raising NoResultFound:
user = result.scalars().one_or_none()
if user is None:
print("Not found")Rule:
- Use
session.get(Model, id)when you have a primary key. - Use
.first()when you want at most one row andNoneis fine. - Use
.one()or.one_or_none()when the database must contain exactly one matching row.
Filtering Records (WHERE clause)
Filtering in ORM is how you represent WHERE in SQL.
Basic pattern:
stmt = select(User).where(User.age >= 18)
users = session.execute(stmt).scalars().all()This corresponds to:
SELECT * FROM users WHERE age >= 18;Common filter operators
| Python expression | SQL equivalent |
|---|---|
User.age == 30 | age = 30 |
User.age != 30 | age <> 30 |
User.age > 18 | age > 18 |
User.age >= 18 | age >= 18 |
User.age < 60 | age < 60 |
User.age <= 60 | age <= 60 |
User.name == "Alice" | name = 'Alice' |
User.name.like("A%") | name LIKE 'A%' |
User.name.ilike("a%") | LOWER(name) LIKE 'a%' |
User.age.in_([20, 30]) | age IN (20, 30) |
User.age.is_(None) | age IS NULL |
User.age.is_not(None) | age IS NOT NULL |
Examples:
# All adult users
stmt = select(User).where(User.age >= 18)
# Users named exactly "Alice"
stmt = select(User).where(User.name == "Alice")
# Users whose name starts with "A" or "a"
stmt = select(User).where(User.name.ilike("a%"))
# Users whose age is 20 or 30
stmt = select(User).where(User.age.in_([20, 30]))
# Users with unknown age (NULL in DB)
stmt = select(User).where(User.age.is_(None))Combining Conditions (AND, OR, NOT)
SQL lets you combine conditions with AND, OR, and NOT. The ORM has equivalents.
AND
To require multiple conditions:
from sqlalchemy import and_
# Users older than 18 and name starts with A
stmt = select(User).where(
and_(
User.age >= 18,
User.name.ilike("a%")
)
)
users = session.execute(stmt).scalars().all()
You can also write multiple .where calls, they are combined with AND:
stmt = (
select(User)
.where(User.age >= 18)
.where(User.name.ilike("a%"))
)OR
Use or_:
from sqlalchemy import or_
stmt = select(User).where(
or_(
User.age < 18,
User.age > 60
)
)
# minors or seniorsNOT
Use the bitwise not operator ~ on conditions:
from sqlalchemy import not_
# People who are NOT adults
stmt = select(User).where(~(User.age >= 18))
# Or using not_ function
stmt = select(User).where(not_(User.age >= 18))You can nest and combine:
stmt = select(User).where(
and_(
User.age >= 18,
or_(
User.name.ilike("a%"),
User.name.ilike("b%")
)
)
)
# Adults whose name starts with A or BSorting Results (ORDER BY)
To order your results you use .order_by.
Basic ascending and descending
# Order by name ascending
stmt = select(User).order_by(User.name.asc())
# Order by age descending
stmt = select(User).order_by(User.age.desc())
You can omit .asc() since ascending is the default:
stmt = select(User).order_by(User.name)Multiple sort keys
# First by age ascending, then by name ascending
stmt = select(User).order_by(User.age, User.name)
# First by age descending, then by name ascending
stmt = select(User).order_by(User.age.desc(), User.name)Example usage:
stmt = (
select(User)
.where(User.age >= 18)
.order_by(User.age.desc(), User.name)
)
adults = session.execute(stmt).scalars().all()Limiting and Offsetting (Pagination Basics)
Limiting and offsetting correspond to SQL LIMIT and OFFSET.
Limit number of rows
stmt = select(User).limit(10)
first_ten_users = session.execute(stmt).scalars().all()Skip some rows (offset)
# Skip first 20 rows, then get next 10
stmt = select(User).offset(20).limit(10)
page = session.execute(stmt).scalars().all()This is useful for pagination.
Simple function for “page / page_size” style:
def get_users_page(session, page: int, page_size: int = 20):
offset_value = (page - 1) * page_size
stmt = (
select(User)
.order_by(User.id)
.offset(offset_value)
.limit(page_size)
)
return session.execute(stmt).scalars().all()page = 1gives rows0..page_size-1page = 2gives rowspage_size..2*page_size-1
Rule: For pagination, always combine ORDER BY with LIMIT and OFFSET. Without ORDER BY your page order is not guaranteed.
Selecting Specific Columns
Sometimes you do not need full model objects, you just need a few fields. You can select specific columns.
Raw columns (tuples)
stmt = select(User.id, User.email)
result = session.execute(stmt)
for row in result:
print(row.id, row.email)
Each row is a Row object that behaves like a named tuple.
You can turn them into dictionaries:
rows = result.mappings().all()
for row in rows:
print(row["id"], row["email"])Mixed columns and models
You can also mix a model with extra columns:
stmt = select(User, User.age + 10)
result = session.execute(stmt)
for user, age_plus_10 in result:
print(user.name, age_plus_10)Counting and Aggregations
To answer questions like “how many users do we have” or “what is the average age” you use aggregate functions.
Count rows
from sqlalchemy import func, select
stmt = select(func.count(User.id))
result = session.execute(stmt)
total_users = result.scalar_one() # get the single scalar value
print("Total users:", total_users)func.count(User.id)maps toCOUNT(users.id)scalar_one()is convenient when you expect a single scalar
Other aggregates
Common aggregates:
| Function | Description |
|---|---|
func.count(column) | Number of rows |
func.max(column) | Maximum value |
func.min(column) | Minimum value |
func.avg(column) | Average value |
func.sum(column) | Sum of values |
Example:
stmt = select(
func.count(User.id),
func.avg(User.age),
)
result = session.execute(stmt)
count_users, avg_age = result.one()
print("Users:", count_users, "Average age:", avg_age)Grouping
Quick glimpse, full grouping is covered in SQL and Queries chapters. Example:
stmt = (
select(User.age, func.count(User.id))
.group_by(User.age)
.order_by(User.age)
)
result = session.execute(stmt)
for age, count in result:
print(age, "years:", count, "users")Lazy Loading and N+1 Problem (Reading Related Data)
ORMs can automatically load related objects when you access relationship attributes. This is called lazy loading. It is powerful but can cause performance problems, especially the N+1 query problem.
Assume models:
from sqlalchemy.orm import relationship, Mapped
class Post(Base):
__tablename__ = "posts"
id: Mapped[int] = mapped_column(primary_key=True)
title: Mapped[str]
content: Mapped[str]
user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
author: Mapped["User"] = relationship(back_populates="posts")
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
name: Mapped[str]
posts: Mapped[list["Post"]] = relationship(back_populates="author")Lazy loading example
users = session.execute(select(User)).scalars().all()
for user in users:
print(user.name, "has", len(user.posts), "posts")
If posts uses lazy loading, SQLAlchemy might do:
SELECT * FROM users;- For each user, when
user.postsis first accessed: SELECT * FROM posts WHERE user_id = :id
If you have 100 users this can become 1 + 100 queries. That is the N+1 problem.
You will learn more about eager loading and joins in the “Relationships” and “Queries” chapters. Here the key point is that reading related data can cause additional queries.
Rule: When reading many parents and their children, be aware of lazy loading. It can become N+1 queries and slow your application. Use proper querying patterns to load relations efficiently.
Querying Related Data with Joins (Preview)
You will cover joins in depth in the “Relationships” and “Queries” chapters. Here are two simple examples to show how you can read related data efficiently.
Inner join example
List posts with their author names:
from sqlalchemy import select, join
stmt = (
select(Post.title, User.name)
.join(User, Post.user_id == User.id)
)
result = session.execute(stmt)
for title, author_name in result:
print(title, "by", author_name)You can also use relationship attributes for joining:
stmt = select(Post, User).join(Post.author)
rows = session.execute(stmt).all()
for post, author in rows:
print(post.title, "by", author.name)Pattern: Reusable Query Functions
To keep your code clean, it is common to wrap queries in small repository or service functions. You will formalize this in the “Repository Pattern” chapter, but here are some practical examples.
Get user by email
def get_user_by_email(session: Session, email: str) -> User | None:
stmt = select(User).where(User.email == email)
return session.execute(stmt).scalars().first()Usage:
user = get_user_by_email(session, "alice@example.com")
if not user:
raise ValueError("User not found")Search users by name substring
def search_users_by_name(session: Session, query: str, limit: int = 20):
pattern = f"%{query}%"
stmt = (
select(User)
.where(User.name.ilike(pattern))
.order_by(User.name)
.limit(limit)
)
return session.execute(stmt).scalars().all()Paginated list
def list_users(
session: Session,
page: int = 1,
page_size: int = 20,
min_age: int | None = None,
):
stmt = select(User).order_by(User.id)
if min_age is not None:
stmt = stmt.where(User.age >= min_age)
stmt = stmt.offset((page - 1) * page_size).limit(page_size)
return session.execute(stmt).scalars().all()This approach:
- Hides query details from the rest of your code
- Makes testing easier
- Prevents repeating complex query logic
Common Pitfalls When Reading Records
1. Loading too much data
Using .all() without filters can load thousands of rows into memory.
Bad:
users = session.execute(select(User)).scalars().all()
# Then filter in Python
adults = [u for u in users if u.age >= 18]Better:
stmt = select(User).where(User.age >= 18)
adults = session.execute(stmt).scalars().all()2. Forgetting to call `.scalars()`
If you select a model and then call .all() directly on the result, you get row objects, not model instances.
result = session.execute(select(User))
# This returns Row objects, not User objects
rows = result.all()
You must use .scalars():
users = session.execute(select(User)).scalars().all()3. Relying on unspecified order
Without order_by, database order is not guaranteed.
Bad:
users = session.execute(select(User).limit(10)).scalars().all()
# Assuming these are the "first" 10 usersBetter:
stmt = select(User).order_by(User.id).limit(10)
users = session.execute(stmt).scalars().all()4. Ignoring “not found” cases
If you assume .first() or .one_or_none() always returns something, you will hit NoneType errors.
Bad:
user = session.execute(stmt).scalars().first()
print(user.email) # may raise AttributeErrorBetter:
user = session.execute(stmt).scalars().first()
if user is None:
# handle not found
...
else:
print(user.email)Summary
In this chapter you learned how to:
- Read all records of a model with
select(Model)and.scalars().all() - Fetch a single record with
session.get,.first(),.one(), and.one_or_none() - Filter rows using
.wherewith comparison operators and methods likein_,like, andilike - Combine conditions with
and_,or_, and~(not) - Order results using
.order_by - Limit and offset results for basic pagination
- Select specific columns instead of full models
- Use aggregate functions like
COUNTandAVG - Understand that reading related data can cause extra queries due to lazy loading
- Wrap queries in reusable functions to keep code clean
These are the essential tools for reading data with an ORM. In the next chapters you will build on this and learn more advanced querying, relationships, and how to use these queries inside a complete backend application.
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!