12.3. Models
Table of Contents
Why Models Matter
In backend development, a model is a Python class that represents something stored in your database, for example a user, a blog post, or an order.
You will use models to:
- Describe the shape of your data, for example which columns a table has.
- Enforce types, for example that
ageis an integer andemailis a string. - Connect Python code with SQL without writing SQL for every small operation.
In the context of an ORM (Object Relational Mapper) like SQLAlchemy, models are your main bridge between Python objects and database tables.
A model class in an ORM usually represents one database table.
Each instance of the model class usually represents one row in that table.
This chapter focuses on ORM models themselves, not on how to execute queries or manage sessions. Those have their own chapters.
Models in an ORM: The Big Picture
With an ORM such as SQLAlchemy, you usually:
- Define models as Python classes.
- Let the ORM map those classes to database tables.
- Use model instances like normal Python objects.
- Let the ORM convert object operations into SQL under the hood.
A simple mental mapping:
| Concept | ORM / Python world | Database world |
|---|---|---|
| Data structure | Model class | Table |
| One record | Model instance | Row |
| Attribute | Field / column attribute | Column |
| Relationship | Relationship attribute | Foreign key + joins |
You will see examples using SQLAlchemy 2.x with Declarative Mapping, which is one of the most common patterns in Python backends today.
Basic SQLAlchemy Model Structure
SQLAlchemy models use a declarative base class. This base handles the mapping logic for all your models.
from typing import Optional
from datetime import datetime
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy import String, Integer, DateTime
class Base(DeclarativeBase):
"""Base class for all ORM models."""
pass
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
email: Mapped[str] = mapped_column(String(255), unique=True, nullable=False)
full_name: Mapped[Optional[str]] = mapped_column(String(200))
created_at: Mapped[datetime] = mapped_column(
DateTime, nullable=False
)Explanation of important pieces:
Baseis the common parent of all models.__tablename__tells SQLAlchemy which table name to use.Mapped[...]andmapped_column(...)describe columns and types.- Type hints (like
Mapped[int]) let SQLAlchemy know the Python type and also help with IDEs and type checkers.
Every ORM model that maps to a table should:
- Inherit from the declarative
Base. - Define
__tablename__. - Have at least one primary key column.
Primary Keys and Identity
Every table needs a primary key. In ORM models, that is usually a column called id.
from sqlalchemy import Integer
from sqlalchemy.orm import Mapped, mapped_column
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
# ... other columnsCommon patterns:
| Pattern | Example | Notes |
|---|---|---|
| Integer autoincrement key | id: Mapped[int] = mapped_column(primary_key=True) | Most common and simplest |
| UUID key | id: Mapped[uuid.UUID] = mapped_column(Uuid(as_uuid=True), primary_key=True) | Good for distributed systems |
| Composite key | Multiple columns set as primary_key=True | Less common, more advanced |
The primary key is how SQLAlchemy tracks each row / object. Without it, the ORM cannot reliably update or delete records.
Defining Columns and Types
Model attributes mapped with mapped_column become columns. Columns have:
- A Python type, through
Mapped[...]. - A database type, through
mapped_column(<db_type>, ...). - Additional options, such as
nullable,unique,default, etc.
from sqlalchemy import String, Boolean, Integer, Text, DateTime, func
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
email: Mapped[str] = mapped_column(
String(255),
unique=True,
nullable=False,
index=True,
)
is_active: Mapped[bool] = mapped_column(
Boolean,
nullable=False,
default=True,
)
age: Mapped[int] = mapped_column(
Integer,
nullable=True,
)
bio: Mapped[str] = mapped_column(
Text,
nullable=False,
server_default="",
)
created_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.now(), # database default
)
Useful mapped_column keyword arguments:
| Argument | What it does |
|---|---|
primary_key | Marks column as part of the primary key |
nullable | Controls whether column can be NULL in the database |
unique | Adds a uniqueness constraint |
index | Creates an index on the column |
default | Python-side default, used when constructing an object |
server_default | Database-side default, used when inserting without a value |
autoincrement | Controls auto increment behavior for integer primary keys |
Rule: When you set nullable=False on a column, your code must always provide a non-null value, or you must define a default (default or server_default), otherwise inserts will fail.
Optional vs Required Fields
Type hints and nullable often go together, but they are not the same thing.
Example:
from typing import Optional
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
# Required: cannot be NULL in DB
username: Mapped[str] = mapped_column(String(50), nullable=False)
# Optional: can be NULL
middle_name: Mapped[Optional[str]] = mapped_column(String(50), nullable=True)Mapped[str]withnullable=Falsemeans:- Database column is NOT NULL.
- In Python, attribute should never be
None. Mapped[Optional[str]]withnullable=Truemeans:- Database column CAN be NULL.
- In Python, attribute can be
None.
If they do not match, it becomes confusing.
For example, this is inconsistent and should be avoided:
# Inconsistent: type says optional, DB says not nullable
name: Mapped[Optional[str]] = mapped_column(String(50), nullable=False)Defaults and Automatic Values
You often want some values to be set automatically, for example timestamps.
Typical timestamp pattern:
from datetime import datetime
from sqlalchemy import DateTime, func
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
created_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.now(), # default value when row is first inserted
)
updated_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.now(), # set on insert
onupdate=func.now(), # set on every update (ORM-level)
)
server_default=func.now() tells the database to set a default value when no value is provided.
default= or onupdate= are handled by SQLAlchemy on the Python side.
Example of a Python-side default:
import uuid
from sqlalchemy import String
class ApiKey(Base):
__tablename__ = "api_keys"
id: Mapped[int] = mapped_column(primary_key=True)
key: Mapped[str] = mapped_column(
String(64),
unique=True,
nullable=False,
default=lambda: uuid.uuid4().hex, # Python generates default
)Example: User and Post Models
Here is a small but complete example of models for a simple blog.
from __future__ import annotations
from typing import List, Optional
from datetime import datetime
from sqlalchemy import String, Text, Integer, DateTime, ForeignKey, Boolean, func
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(Integer, primary_key=True)
email: Mapped[str] = mapped_column(String(255), unique=True, index=True, nullable=False)
hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
is_active: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
created_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.now(),
)
# Relationship: user has many posts
posts: Mapped[List["Post"]] = relationship(
back_populates="author",
cascade="all, delete-orphan",
)
class Post(Base):
__tablename__ = "posts"
id: Mapped[int] = mapped_column(Integer, primary_key=True)
title: Mapped[str] = mapped_column(String(200), nullable=False)
content: Mapped[str] = mapped_column(Text, nullable=False)
# Foreign key to users.id
author_id: Mapped[int] = mapped_column(
ForeignKey("users.id"),
nullable=False,
index=True,
)
is_published: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
created_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.now(),
)
# Relationship: post belongs to one user
author: Mapped["User"] = relationship(
back_populates="posts",
)Even if you have not studied relationships yet, you can already observe the model structure:
- Both
UserandPostinherit fromBase. - Each has a
__tablename__. - Each has a primary key.
- Columns are clearly described with types and constraints.
- Relationships link models at the Python level, while foreign keys link tables at the database level.
Models vs Pydantic / Schema Models
In a typical backend with FastAPI and SQLAlchemy you often have two types of models:
- ORM models
- Map to database tables.
- Used for querying and persisting data.
- Often live in a
models.pyordb/models.py. - Schema / Pydantic models
- Describe request and response shapes for the API.
- Used for validation and serialization.
- Often live in a
schemas.pyorapi/schemas.py.
It is helpful to keep them separate, even if their fields look similar.
Example:
# ORM model (database)
class User(Base):
__tablename__ = "users"
id: Mapped[int] = mapped_column(primary_key=True)
email: Mapped[str] = mapped_column(String(255), unique=True, nullable=False)
hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
is_active: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)# Pydantic model (API request / response)
from pydantic import BaseModel, EmailStr
class UserCreate(BaseModel):
email: EmailStr
password: str
class UserRead(BaseModel):
id: int
email: EmailStr
is_active: bool
The ORM model contains hashed_password, while the UserRead schema does not, so you never send the hash to the client.
Organizing Your Model Files
In real projects you quickly get many models. Organizing them from the beginning is helpful.
Common patterns:
| Project size | Organization example |
|---|---|
| Very small | All models in models.py |
| Small / mid | Package like app/models/ with multiple files |
| Large | Domain-based packages like app/users/models.py, app/orders/models.py |
Example folder structure:
app/
db/
base.py # defines Base and metadata
session.py # SQLAlchemy engine and session makers
models/
__init__.py # imports all models so metadata sees them
user.py
post.py
comment.py
A minimal base.py might look like:
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
And models/__init__.py might re-export your models:
from app.db.base import Base
from .user import User
from .post import Post
from .comment import Comment
__all__ = ["Base", "User", "Post", "Comment"]Common Modeling Mistakes and How to Avoid Them
Even beginners can avoid many problems by following some simple rules.
1. Forgetting a primary key
Incorrect:
class Product(Base):
__tablename__ = "products"
name: Mapped[str] = mapped_column(String(100), nullable=False)
price: Mapped[int] = mapped_column(Integer, nullable=False)Here there is no primary key column. SQLAlchemy will complain or behave unpredictably.
Correct:
class Product(Base):
__tablename__ = "products"
id: Mapped[int] = mapped_column(primary_key=True)
name: Mapped[str] = mapped_column(String(100), nullable=False)
price: Mapped[int] = mapped_column(Integer, nullable=False)2. Mismatch between type and nullable
Incorrect:
# DB allows NULL, but Python type says str only
nickname: Mapped[str] = mapped_column(String(50), nullable=True)Correct:
from typing import Optional
nickname: Mapped[Optional[str]] = mapped_column(String(50), nullable=True)3. Storing plain passwords
Never store passwords directly in models.
Incorrect:
password: Mapped[str] = mapped_column(String(255), nullable=False)Correct pattern:
hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
The hashing logic belongs in your authentication code, not in the model itself, but the model should never expose a plain password column.
4. Using too generic types
Avoid using very generic types when you know better.
Instead of:
data: Mapped[str] = mapped_column(String)Prefer:
data: Mapped[str] = mapped_column(String(255))
or use specific types like Text, JSON, Integer, Boolean, etc.
Simple End-to-End Example
This short example shows how you can define a model, create an instance, and understand what it represents, without going into session details.
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy import String, Integer
class Base(DeclarativeBase):
pass
class TodoItem(Base):
__tablename__ = "todo_items"
id: Mapped[int] = mapped_column(Integer, primary_key=True)
title: Mapped[str] = mapped_column(String(200), nullable=False)
completed: Mapped[bool] = mapped_column(default=False, nullable=False)
# Using the model in code (no DB interaction shown yet)
item = TodoItem(title="Buy milk")
print(item.id) # None, until inserted into DB
print(item.title) # "Buy milk"
print(item.completed) # False, from defaultConceptually:
TodoItemis your table definition.itemis one row in that table as a Python object.- When you insert
iteminto the database, SQLAlchemy will generate SQL like:
INSERT INTO todo_items (title, completed) VALUES ('Buy milk', false);You will learn how to perform that insert in the chapters about Database Sessions and Creating Records.
Summary
In this chapter you learned that:
- Models are Python classes that represent database tables.
- Each model usually maps to one table, and each instance to one row.
- Models inherit from a declarative base and define
__tablename__. - Columns are defined using
Mapped[...]andmapped_column(...)with proper types and options. - Every model needs at least one primary key.
nullable,default, andserver_defaultcontrol how data is stored and validated.- ORM models are different from API schema models, and they usually live in different files.
- Good structure and consistent type usage help keep your backend code clean and predictable.
With this foundation, you are ready to learn how to use models with sessions, queries, and relationships in the following chapters.
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!