12.10. Queries
Table of Contents
Querying with an ORM
Working with an ORM is all about expressing database queries in your programming language instead of writing raw SQL. In this chapter we focus on how to read data using queries, not how to define models or manage sessions, which are covered in their own chapters.
Examples below use Python and SQLAlchemy 2.x style (the most common choice with FastAPI), but the ideas are the same in other ORMs.
Basic query patterns
The ORM gives you an object oriented way to express the same things you would do with SQL:
| SQL idea | Typical ORM pattern |
|---|---|
SELECT * FROM users | select(User) or session.query(User) |
| WHERE filter | .where(...) or .filter(...) |
| ORDER BY | .order_by(...) |
| LIMIT/OFFSET | .limit(...).offset(...) |
| JOIN | join() / relationship-based loading |
| COUNT, SUM | func.count, func.sum |
Below is a minimal setup we will reuse in examples:
from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import declarative_base, relationship
Base = declarative_base()
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
email = Column(String, unique=True, nullable=False)
full_name = Column(String)
age = Column(Integer)
posts = relationship("Post", back_populates="author")
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True)
title = Column(String, nullable=False)
body = Column(String)
author_id = Column(Integer, ForeignKey("users.id"))
author = relationship("User", back_populates="posts")
We will assume you already have an active Session object, usually called session.
Selecting all records
Select all rows from a table
In SQL:
SELECT * FROM users;With SQLAlchemy 2.x style:
from sqlalchemy import select
stmt = select(User)
result = session.execute(stmt)
users = result.scalars().all()Important details:
select(User)produces aSELECT * FROM users.session.execute(stmt)sends it to the database..scalars()extracts model objects from the rows..all()loads all of them into a list.
Typical usage:
def get_all_users(session):
return session.execute(select(User)).scalars().all()
If you forget .scalars() you will get Row objects instead of User instances, which can be confusing.
Filtering with conditions
Filtering is the ORM equivalent of WHERE in SQL.
Simple equality filter
SQL:
SELECT * FROM users WHERE email = 'john@example.com';ORM:
stmt = select(User).where(User.email == "john@example.com")
user = session.execute(stmt).scalar_one_or_none()
scalar_one_or_none() returns:
- the single result, or
Noneif there is no row, or- raises if there are multiple rows.
Use this pattern often for queries by unique keys.
Multiple conditions
SQL:
SELECT * FROM users WHERE age >= 18 AND age <= 30;ORM:
from sqlalchemy import and_
stmt = select(User).where(
and_(User.age >= 18, User.age <= 30)
)
users = session.execute(stmt).scalars().all()You can also use Python operators chained, which is usually cleaner:
stmt = select(User).where(
User.age >= 18,
User.age <= 30,
)
SQLAlchemy treats multiple arguments to where() as an implicit AND.
OR conditions
SQL:
SELECT * FROM users WHERE age < 18 OR age > 65;ORM:
from sqlalchemy import or_
stmt = select(User).where(
or_(User.age < 18, User.age > 65)
)
users = session.execute(stmt).scalars().all()IN and NOT IN
SQL:
SELECT * FROM users WHERE id IN (1, 2, 3);ORM:
user_ids = [1, 2, 3]
stmt = select(User).where(User.id.in_(user_ids))
users = session.execute(stmt).scalars().all()For NOT IN:
stmt = select(User).where(~User.id.in_(user_ids))
The ~ is “NOT” here.
LIKE and ILIKE (pattern matching)
SQL:
SELECT * FROM users WHERE full_name LIKE 'John%';ORM:
stmt = select(User).where(User.full_name.like("John%"))
users = session.execute(stmt).scalars().all()Case insensitive pattern matching (PostgreSQL):
stmt = select(User).where(User.full_name.ilike("%smith%"))
Important rule: Never build filters by string concatenation with user input. Always use ORM expressions like User.email == user_email or parameters to avoid SQL injection.
Ordering and limiting results
ORDER BY
SQL:
SELECT * FROM users ORDER BY age DESC, id ASC;ORM:
from sqlalchemy import desc
stmt = select(User).order_by(desc(User.age), User.id)
users = session.execute(stmt).scalars().all()
You can also use User.age.desc():
stmt = select(User).order_by(User.age.desc(), User.id.asc())LIMIT and OFFSET
SQL:
SELECT * FROM users ORDER BY id LIMIT 10 OFFSET 20;ORM:
stmt = (
select(User)
.order_by(User.id)
.limit(10)
.offset(20)
)
users = session.execute(stmt).scalars().all()
This combination of order_by, limit, and offset is the classic pagination pattern for APIs.
Getting single objects
There are several helpers for fetching one row.
`first()`, `one()`, `one_or_none()`, `scalar_one_or_none()`
Common patterns:
# First row or None
user = session.execute(
select(User).where(User.email == email)
).scalars().first()
# Exactly one row, or raise if 0 or > 1
user = session.execute(
select(User).where(User.id == user_id)
).scalar_one()
# One row or None, raise if > 1
user = session.execute(
select(User).where(User.id == user_id)
).scalar_one_or_none()Typical use in an API:
def get_user_or_404(session, user_id: int):
user = session.execute(
select(User).where(User.id == user_id)
).scalar_one_or_none()
if user is None:
# In a FastAPI app, you might raise HTTPException(status_code=404)
raise ValueError("User not found")
return userProjections: selecting specific columns
You do not always need full model instances. You can select specific columns.
SQL:
SELECT id, email FROM users;ORM:
stmt = select(User.id, User.email)
rows = session.execute(stmt).all()
for row in rows:
print(row.id, row.email)
You get Row objects with those fields.
You can also select expressions:
from sqlalchemy import func
stmt = select(
User.id,
User.email,
func.length(User.full_name).label("name_length"),
)
rows = session.execute(stmt).all()
for row in rows:
print(row.id, row.email, row.name_length)
Labeling expressions with .label("...") gives them a column name.
Aggregations and counting
Counting rows
SQL:
SELECT COUNT(*) FROM users;ORM:
from sqlalchemy import func
stmt = select(func.count(User.id))
total_users = session.execute(stmt).scalar_one()Filter and count:
stmt = select(func.count(User.id)).where(User.age >= 18)
adult_count = session.execute(stmt).scalar_one()Grouping and aggregates
SQL:
SELECT age, COUNT(*) FROM users GROUP BY age;ORM:
stmt = (
select(User.age, func.count(User.id).label("count"))
.group_by(User.age)
)
rows = session.execute(stmt).all()
for age, count in rows:
print(age, count)Multiple aggregates:
stmt = select(
func.min(User.age),
func.max(User.age),
func.avg(User.age),
)
min_age, max_age, avg_age = session.execute(stmt).one()
Important pattern: Use func for database functions like COUNT, MAX, LOWER, etc. This keeps your query portable and parameterized.
Joining related tables
Joins let you query across relationships in one go.
Simple join
SQL:
SELECT * FROM posts JOIN users ON posts.author_id = users.id;ORM:
from sqlalchemy import select, join
stmt = (
select(Post, User)
.join(User, Post.author_id == User.id)
)
rows = session.execute(stmt).all()
for post, author in rows:
print(post.title, "by", author.email)
Note that each row from execute contains both models.
Join using relationships
If you have relationships defined, you can join via the relationship.
stmt = select(Post).join(Post.author).where(User.email == "john@example.com")
posts = session.execute(stmt).scalars().all()
Here, Post.author refers to the relationship. SQLAlchemy builds the join condition automatically.
Filtering across relationships
Find all users who have at least one post:
stmt = (
select(User)
.join(User.posts)
.group_by(User.id)
)
users_with_posts = session.execute(stmt).scalars().all()Filter posts by author age:
stmt = (
select(Post)
.join(Post.author)
.where(User.age >= 18)
)
posts = session.execute(stmt).scalars().all()Eager loading vs lazy loading
When you access user.posts, by default the ORM will often do a separate query the moment you access the attribute. This is called lazy loading.
Lazy loading example:
users = session.execute(select(User)).scalars().all()
for user in users:
# This may run another SQL query each time
print(user.email, len(user.posts))This can cause many small queries, sometimes called the N+1 query problem.
Avoiding N+1 with eager loading
You can ask the ORM to load related data in the same query.
from sqlalchemy.orm import selectinload
stmt = select(User).options(selectinload(User.posts))
users = session.execute(stmt).scalars().all()
for user in users:
# Now user.posts is already loaded
print(user.email, len(user.posts))There are several eager loading strategies:
| Strategy | Purpose |
|---|---|
selectinload | Does a separate IN query for related rows, efficient for many parents |
joinedload | Uses JOIN to load relationships in one big query |
Example with joinedload:
from sqlalchemy.orm import joinedload
stmt = select(Post).options(joinedload(Post.author))
posts = session.execute(stmt).scalars().all()
for post in posts:
# post.author already loaded
print(post.title, post.author.email)Important rule: Be explicit about loading strategies when you need related data for many rows. This avoids hidden extra queries and performance issues.
Querying JSON fields (PostgreSQL example)
If your model has a JSON column:
from sqlalchemy import JSON
class Event(Base):
__tablename__ = "events"
id = Column(Integer, primary_key=True)
type = Column(String, nullable=False)
payload = Column(JSON, nullable=False)You can filter on JSON keys:
from sqlalchemy import cast, String
# payload: {"user_id": 123, "source": "mobile"}
stmt = select(Event).where(Event.payload["user_id"].as_integer() == 123)
events = session.execute(stmt).scalars().all()Or check nested structures, depending on your database capabilities. The exact syntax can depend on backend, but the idea is the same: access JSON keys through the column object.
Combining queries into reusable functions
You rarely put query logic directly in your route handlers. You usually wrap it in functions or repository methods.
Example "repository" style:
from typing import Sequence, Optional
from sqlalchemy import select
class UserRepository:
def __init__(self, session):
self.session = session
def list_users(
self,
limit: int = 100,
offset: int = 0,
) -> Sequence[User]:
stmt = (
select(User)
.order_by(User.id)
.limit(limit)
.offset(offset)
)
return self.session.execute(stmt).scalars().all()
def get_by_email(self, email: str) -> Optional[User]:
stmt = select(User).where(User.email == email)
return self.session.execute(stmt).scalar_one_or_none()
def list_by_min_age(self, min_age: int) -> Sequence[User]:
stmt = select(User).where(User.age >= min_age)
return self.session.execute(stmt).scalars().all()Then your API code becomes simple:
def list_users_endpoint(session=Depends(get_session)):
repo = UserRepository(session)
return repo.list_users(limit=50, offset=0)This keeps your queries testable and easier to change.
Pagination, filtering, and searching in APIs
Backend APIs usually combine these query patterns together.
Imagine an endpoint:
GET /users?search=john&min_age=18&max_age=40&limit=20&offset=0You can build the query step by step.
from typing import Optional
from sqlalchemy import select, and_, or_
def search_users(
session,
search: Optional[str] = None,
min_age: Optional[int] = None,
max_age: Optional[int] = None,
limit: int = 20,
offset: int = 0,
):
stmt = select(User)
# Dynamic filters
conditions = []
if search:
like_pattern = f"%{search}%"
conditions.append(
or_(
User.email.ilike(like_pattern),
User.full_name.ilike(like_pattern),
)
)
if min_age is not None:
conditions.append(User.age >= min_age)
if max_age is not None:
conditions.append(User.age <= max_age)
if conditions:
stmt = stmt.where(and_(*conditions))
stmt = stmt.order_by(User.id).limit(limit).offset(offset)
users = session.execute(stmt).scalars().all()
return usersThis pattern lets you assemble flexible queries based on request parameters without ever touching raw SQL.
Common pitfalls and how to avoid them
- Loading too much data
Example of a problem:
users = session.execute(select(User)).scalars().all() # thousands of usersBetter: always limit or paginate.
users = session.execute(
select(User).order_by(User.id).limit(100)
).scalars().all()- N+1 problem
Looping and accessing related objects inside the loop without eager loading:
users = session.execute(select(User)).scalars().all()
for user in users:
# Each `user.posts` might trigger its own query
print(user.email, len(user.posts))
Fix with selectinload:
stmt = select(User).options(selectinload(User.posts))
users = session.execute(stmt).scalars().all()- Session closed or expired
If you access user.posts after the session is closed, lazy loading will fail. If you must use objects after the session is closed, load relationships eagerly.
- Mixing raw SQL and ORM expressions incorrectly
If you need raw SQL, use text() or session.execute(text(...)). Do not concatenate raw strings with ORM expressions. Keep one approach per query.
Summary
In this chapter you learned how to:
- Select all records and single records with
select,execute, and scalar helpers. - Filter using equality, ranges,
IN,LIKE, and boolean combinations. - Order, limit, and offset results for pagination.
- Select specific columns and use aggregates like
COUNTandAVG. - Join related tables and filter across relationships.
- Control loading of relationships to avoid N+1 problems with
selectinloadandjoinedload. - Wrap queries in reusable repository methods.
- Build real world API filters and search features from ORM queries.
These querying techniques are the core of reading data from your database through an ORM. In the next chapters you will see how to combine them with transactions, connection pooling, and the repository pattern to build robust backend applications.
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!