12.2. SQLAlchemy
Table of Contents
Why Use SQLAlchemy?
SQLAlchemy is a popular Python library that helps you work with relational databases like PostgreSQL, MySQL, or SQLite using Python code instead of writing raw SQL everywhere.
You can still use SQL when you need it, but SQLAlchemy gives you:
- A database connection manager
- A way to define tables as Python classes
- A way to write queries in Python expressions
- A consistent API across different databases
Key idea: SQLAlchemy does not replace SQL. It wraps SQL in Python code, makes it safer and more convenient, and still lets you drop down to raw SQL when needed.
In this chapter, you will see how SQLAlchemy works at a high level and get a feel for its two main styles: Core and ORM. Later child chapters like Models, Database Sessions, Creating Records, and Queries will go deeper into each topic.
Installing SQLAlchemy
You install SQLAlchemy with pip. In real projects you will usually do this inside a virtual environment.
pip install sqlalchemyIf you know you will use PostgreSQL, you also need a driver:
pip install psycopg2-binaryFor SQLite you do not need an extra driver. Python ships with one built in.
A minimal requirements.txt might look like this:
sqlalchemy==2.0.32
psycopg2-binary==2.9.9You can then install everything:
pip install -r requirements.txtSQLAlchemy Core vs ORM
SQLAlchemy has two major layers:
| Layer | What it is | When to use |
|---|---|---|
| SQLAlchemy Core | Low level API for building SQL expressions | Simple scripts, highly optimized SQL, migrations, reporting |
| SQLAlchemy ORM | Object Relational Mapper that maps classes | Web applications, domain models, working with objects |
You can use one or both in the same project. The ORM actually uses Core under the hood.
SQLAlchemy Core in One Glance
Core focuses on tables and SQL expressions.
Example with SQLite in memory:
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, select, insert
# 1. Create an engine (DB connection factory)
engine = create_engine("sqlite:///:memory:", echo=True)
metadata = MetaData()
# 2. Define table structure
users_table = Table(
"users",
metadata,
Column("id", Integer, primary_key=True),
Column("name", String, nullable=False),
Column("email", String, unique=True, nullable=False),
)
# 3. Create the table in the database
metadata.create_all(engine)
# 4. Insert data
with engine.connect() as conn:
stmt = insert(users_table).values(name="Alice", email="alice@example.com")
conn.execute(stmt)
conn.commit()
# 5. Query data
with engine.connect() as conn:
stmt = select(users_table).where(users_table.c.name == "Alice")
result = conn.execute(stmt).fetchone()
print(result) # (1, 'Alice', 'alice@example.com')Points to notice:
- You work with
Tableobjects and column objects. - You build SQL with Python functions like
select()andinsert(). - You get back rows as tuples or row objects, not your own Python classes.
SQLAlchemy ORM in One Glance
The ORM lets you map tables to Python classes so you work with objects.
Same example using the ORM:
from sqlalchemy import create_engine
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, Session
from sqlalchemy import String
# 1. Engine
engine = create_engine("sqlite:///:memory:", echo=True)
# 2. Base class for models
class Base(DeclarativeBase):
pass
# 3. Define a model class
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
name: Mapped[str] = mapped_column(String, nullable=False)
email: Mapped[str] = mapped_column(String, unique=True, nullable=False)
# 4. Create tables
Base.metadata.create_all(engine)
# 5. Use Session to work with objects
with Session(engine) as session:
# Create
alice = User(name="Alice", email="alice@example.com")
session.add(alice)
session.commit()
# Read
user = session.query(User).filter(User.name == "Alice").first()
print(user.id, user.name, user.email)Here you:
- Define
Useras a Python class that represents auserstable row. - Use a
Sessionto add and queryUserobjects. - Do not write SQL strings yourself, but SQLAlchemy still sends SQL to the database.
In this course, the later chapters under ORM and Database Integration will mainly use the ORM style, because it fits backend applications well.
Engines and Database URLs
At the center of SQLAlchemy is the Engine. The engine knows how to:
- Connect to your database
- Create connection pools
- Send SQL statements
- Return results
You create an engine once, then reuse it.
Database URLs
To create an engine you provide a database URL. The format is:
Database URL format:
dialect+driver://username:password@host:port/database_name
Examples:
| Database | Example URL |
|---|---|
| SQLite file | sqlite:///./app.db |
| SQLite memory | sqlite:///:memory: |
| PostgreSQL | postgresql+psycopg2://user:password@localhost:5432/mydb |
| MySQL | mysql+pymysql://user:password@localhost:3306/mydb |
Basic engine creation:
from sqlalchemy import create_engine
SQLALCHEMY_DATABASE_URL = "sqlite:///./app.db"
engine = create_engine(
SQLALCHEMY_DATABASE_URL,
echo=True, # Log SQL statements to stdout, useful for learning
future=True, # Modern SQLAlchemy 2 style
)For SQLite with multiple threads (for example in FastAPI), you often use:
engine = create_engine(
"sqlite:///./app.db",
connect_args={"check_same_thread": False},
)We will revisit engines again when we talk about Connection Pooling later in this section of the course.
Defining Tables and Models
SQLAlchemy gives you two styles to define your database structure:
- Table objects (Core)
- Model classes (ORM)
In this chapter we only introduce both at a high level. The child chapter Models will go into definitions in detail.
Table Objects (Core)
You define tables using Table, Column, and MetaData:
from sqlalchemy import (
Table, Column, Integer, String, MetaData, Boolean, DateTime
)
metadata = MetaData()
tasks_table = Table(
"tasks",
metadata,
Column("id", Integer, primary_key=True),
Column("title", String, nullable=False),
Column("description", String),
Column("completed", Boolean, nullable=False, default=False),
Column("created_at", DateTime),
)Later:
from sqlalchemy import create_engine
engine = create_engine("sqlite:///./tasks.db")
metadata.create_all(engine)
All your tables live in metadata. Calling metadata.create_all(engine) will create them in the database if they do not exist.
Model Classes (ORM, Declarative Style)
With the ORM, you define classes that map to tables. You inherit from a base class that stores the metadata.
A common pattern:
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy import Integer, String, Boolean, DateTime
class Base(DeclarativeBase):
pass
class Task(Base):
__tablename__ = "tasks"
id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
title: Mapped[str] = mapped_column(String, nullable=False)
description: Mapped[str | None]
completed: Mapped[bool] = mapped_column(Boolean, default=False)
# created_at will be covered later in this course with defaults
created_at: Mapped[DateTime | None]Then:
from sqlalchemy import create_engine
engine = create_engine("sqlite:///./tasks.db")
Base.metadata.create_all(engine)
Now you can create and query Task objects through the ORM instead of building SQL manually.
Basic CRUD with SQLAlchemy Core
CRUD stands for Create, Read, Update, Delete. You will later have dedicated chapters on these operations with ORM, but here is what they look like using Core so you can see the lower level layer.
Assume we have:
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, select, insert, update, delete
engine = create_engine("sqlite:///./example.db")
metadata = MetaData()
users_table = Table(
"users",
metadata,
Column("id", Integer, primary_key=True),
Column("name", String, nullable=False),
Column("email", String, nullable=False, unique=True),
)
metadata.create_all(engine)Create (INSERT)
with engine.connect() as conn:
stmt = insert(users_table).values(name="Bob", email="bob@example.com")
result = conn.execute(stmt)
conn.commit()
print(result.inserted_primary_key) # [1] for idYou can also insert many rows:
with engine.connect() as conn:
stmt = insert(users_table)
conn.execute(
stmt,
[
{"name": "Alice", "email": "alice@example.com"},
{"name": "Charlie", "email": "charlie@example.com"},
],
)
conn.commit()Read (SELECT)
from sqlalchemy import select
with engine.connect() as conn:
stmt = select(users_table)
result = conn.execute(stmt)
rows = result.fetchall()
for row in rows:
print(row.id, row.name, row.email)Filtering:
with engine.connect() as conn:
stmt = select(users_table).where(users_table.c.email == "alice@example.com")
row = conn.execute(stmt).fetchone()
if row:
print(row.id, row.name)Update (UPDATE)
from sqlalchemy import update
with engine.connect() as conn:
stmt = (
update(users_table)
.where(users_table.c.email == "bob@example.com")
.values(name="Robert")
)
result = conn.execute(stmt)
conn.commit()
print(result.rowcount) # Number of rows updatedDelete (DELETE)
from sqlalchemy import delete
with engine.connect() as conn:
stmt = delete(users_table).where(users_table.c.email == "charlie@example.com")
result = conn.execute(stmt)
conn.commit()
print(result.rowcount) # Rows deletedThis Core style is useful when you want very explicit control over the SQL, or you do not need to map rows to Python objects.
Basic CRUD with the ORM
Now compare that with ORM style. You will later see full details in Creating Records, Reading Records, Updating Records, and Deleting Records, but here is the idea.
Assume:
from sqlalchemy import create_engine
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, Session
from sqlalchemy import String
engine = create_engine("sqlite:///./example_orm.db", echo=True)
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
name: Mapped[str] = mapped_column(String, nullable=False)
email: Mapped[str] = mapped_column(String, unique=True, nullable=False)
Base.metadata.create_all(engine)Create
with Session(engine) as session:
user = User(name="Bob", email="bob@example.com")
session.add(user)
session.commit()
session.refresh(user) # Load generated id from DB
print(user.id) # New primary keyRead
with Session(engine) as session:
users = session.query(User).all()
for user in users:
print(user.id, user.name, user.email)
# Filter
alice = session.query(User).filter(User.email == "alice@example.com").first()
if alice:
print(alice.name)Update
with Session(engine) as session:
bob = session.query(User).filter(User.email == "bob@example.com").first()
if bob:
bob.name = "Robert"
session.commit()
The ORM tracks changes to objects and converts them to SQL UPDATE statements when you call commit().
Delete
with Session(engine) as session:
bob = session.query(User).filter(User.email == "bob@example.com").first()
if bob:
session.delete(bob)
session.commit()
Here you work with User objects and let SQLAlchemy figure out the necessary SQL.
Simple Example: Task Management Data Layer
To connect this chapter to later project work, here is a tiny example of how SQLAlchemy might be used in a backend for a Task Management API.
Database URL and engine:
from sqlalchemy import create_engine
from sqlalchemy.orm import Session, DeclarativeBase, Mapped, mapped_column
from sqlalchemy import String, Boolean
DATABASE_URL = "sqlite:///./tasks.db"
engine = create_engine(DATABASE_URL, echo=False)
class Base(DeclarativeBase):
pass
class Task(Base):
__tablename__ = "tasks"
id: Mapped[int] = mapped_column(primary_key=True, index=True)
title: Mapped[str] = mapped_column(String, nullable=False)
completed: Mapped[bool] = mapped_column(Boolean, default=False)
Base.metadata.create_all(engine)Basic operations:
def create_task(title: str) -> Task:
with Session(engine) as session:
task = Task(title=title, completed=False)
session.add(task)
session.commit()
session.refresh(task)
return task
def list_tasks() -> list[Task]:
with Session(engine) as session:
return session.query(Task).all()
def complete_task(task_id: int) -> Task | None:
with Session(engine) as session:
task = session.get(Task, task_id)
if not task:
return None
task.completed = True
session.commit()
session.refresh(task)
return taskLater, when you integrate this with FastAPI, these functions will be called from route handlers to implement your REST API.
Common Pitfalls for Beginners
When starting with SQLAlchemy, beginners often run into a few common problems.
Forgetting to Commit
If you do not call commit(), changes are not saved.
Wrong:
with Session(engine) as session:
user = User(name="Test", email="test@example.com")
session.add(user)
# No commit here, nothing is actually written to the DBCorrect:
with Session(engine) as session:
user = User(name="Test", email="test@example.com")
session.add(user)
session.commit()Using a Closed Session
Once the context manager exits, the session is closed. You cannot use objects from it to perform new database operations.
This is wrong:
with Session(engine) as session:
user = session.get(User, 1)
# Session is closed here
user.name = "New Name"
session.commit() # Error, session is out of scopeThe right patterns will be explained in detail in Database Sessions, including how to handle sessions in web frameworks.
Confusing Engine With Session
enginemanages connections.Sessionmanages transactions and ORM objects.
Do not call engine.commit(). It does not exist. You always commit on a session or a Core connection.
Summary
In this chapter you learned:
- What SQLAlchemy is and why backend developers use it.
- The difference between SQLAlchemy Core and the ORM.
- How to create an engine with a database URL.
- How to define tables and ORM models at a high level.
- How basic CRUD looks using both Core and the ORM.
- Some common beginner mistakes to avoid.
Next chapters in ORM and Database Integration will build on this:
- Models will show you how to define richer models.
- Database Sessions will teach you proper session lifecycle patterns.
- The CRUD chapters will show you how to implement each operation in a real backend.
- Queries, Relationships, Transactions, and Connection Pooling will add more power step by step.
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!