32.6. PostgreSQL Integration
Table of Contents
Overview
In the final project, you already know how to use PostgreSQL in general and how to use an ORM. This chapter focuses on how to integrate PostgreSQL into a real production‑style backend:
- How your app and database talk to each other in different environments.
- How to configure connections safely with environment variables.
- How to structure code so that database access is clean and testable.
- How to run migrations as part of the project.
- How to deal with connection pooling and production‑grade settings.
We will keep examples Python oriented (FastAPI + SQLAlchemy), but the ideas apply to any backend stack.
Goal of this chapter:
Connect your application to PostgreSQL in a way that is secure, configurable, and production ready, not just "it works on my machine."
Defining PostgreSQL configuration
In a production backend, you never hardcode database credentials in source code. You keep them in environment variables or a secrets store, and your application builds a connection URL from them.
Environment variables for PostgreSQL
A typical set of environment variables for PostgreSQL:
| Variable | Example value | Description |
|---|---|---|
DB_HOST | db or 127.0.0.1 | Database hostname |
DB_PORT | 5432 | PostgreSQL port |
DB_NAME | myapp | Database name |
DB_USER | myapp_user | Username |
DB_PASSWORD | super-secret | Password |
DB_POOL_SIZE | 10 | Max connections per worker |
DB_POOL_MAX_OVERFLOW | 20 | Extra temporary connections |
DB_POOL_TIMEOUT | 30 | Seconds to wait for a connection |
In development you might have a .env file:
DB_HOST=localhost
DB_PORT=5432
DB_NAME=myapp_dev
DB_USER=myapp_dev
DB_PASSWORD=devpassword
DB_POOL_SIZE=5
DB_POOL_MAX_OVERFLOW=10
DB_POOL_TIMEOUT=30In production you set these through your orchestrator or server (Docker Compose, Kubernetes, systemd unit, etc.).
Rule: Database credentials must not live in source control.
Use environment variables, secret managers, or configuration management tools.
Building the database URL
Most libraries use a single URL string, for example:
postgresql+psycopg2://user:password@host:5432/dbnameIn Python:
import os
from urllib.parse import quote_plus
def build_db_url() -> str:
user = os.getenv("DB_USER", "postgres")
password = os.getenv("DB_PASSWORD", "")
host = os.getenv("DB_HOST", "localhost")
port = os.getenv("DB_PORT", "5432")
name = os.getenv("DB_NAME", "postgres")
# URL-encode password in case it has special characters
password_escaped = quote_plus(password)
return f"postgresql+psycopg2://{user}:{password_escaped}@{host}:{port}/{name}"
DATABASE_URL = build_db_url()
You can also expose DATABASE_URL directly as an environment variable and skip building it yourself, but building it from smaller variables often makes it easier to change parts per environment.
Creating the database engine and session
Your ORM or driver needs a central place where you define:
- The engine (connection settings, pooling).
- A factory for sessions or connections.
- The base for your models.
SQLAlchemy engine and session factory
A common pattern in a FastAPI project:
# app/db.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, DeclarativeBase
import os
class Base(DeclarativeBase):
pass
DATABASE_URL = os.getenv("DATABASE_URL")
engine = create_engine(
DATABASE_URL,
pool_size=int(os.getenv("DB_POOL_SIZE", "10")),
max_overflow=int(os.getenv("DB_POOL_MAX_OVERFLOW", "20")),
pool_timeout=int(os.getenv("DB_POOL_TIMEOUT", "30")),
pool_pre_ping=True, # Check connections before using them
)
SessionLocal = sessionmaker(
autocommit=False,
autoflush=False,
bind=engine,
)Key parameters:
| Parameter | Meaning |
|---|---|
pool_size | Number of persistent connections kept in the pool |
max_overflow | Extra connections that can be created when pool is full |
pool_timeout | How long to wait for a connection from the pool before raising an error |
pool_pre_ping | Checks that a connection is still alive, prevents "stale connection" errors |
For most APIs, a small pool per worker like pool_size=5 is enough.
Rule: Always use connection pooling in production.
Opening and closing a PostgreSQL connection on every request is too slow and wastes resources.
FastAPI dependency for database sessions
You want each HTTP request to use its own database session, and you want to make sure the session is closed, even when an error happens.
# app/dependencies/database.py
from typing import Generator
from app.db import SessionLocal
def get_db() -> Generator:
db = SessionLocal()
try:
yield db
db.commit()
except Exception:
db.rollback()
raise
finally:
db.close()Using it in a route:
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from app.dependencies.database import get_db
from app import models, schemas
router = APIRouter()
@router.get("/users/{user_id}", response_model=schemas.UserRead)
def get_user(user_id: int, db: Session = Depends(get_db)):
user = db.query(models.User).filter(models.User.id == user_id).first()
if not user:
# Raise your custom HTTP 404 here
...
return userEvery request:
- Opens a session.
- Runs the route code.
- Commits on success, rolls back on error.
- Closes the session.
Managing database migrations
In a real project, you never manually change schema on production. You use migrations so schema changes are:
- Versioned.
- Reproducible.
- Automated in CI/CD.
This project uses Alembic (mentioned in the ORM chapter). Here we only show how it fits into the final project.
Basic migration workflow in the project
Typical layout:
app/
db.py
models/
__init__.py
user.py
product.py
...
alembic/
versions/
env.py
alembic.ini
Once you have models defined and the Alembic setup created:
- Generate a new migration:
alembic revision --autogenerate -m "create users and products tables"- Inspect the generated file and confirm it looks correct.
- Apply migrations to your local database:
alembic upgrade head- In CI/CD or deployment, run:
alembic upgrade headright after deploying the new version of the application.
Rule: Never edit production schemas by hand.
All schema changes must go through migrations and version control.
Environment specific migration configuration
You want migrations to run against the right database:
- Dev:
myapp_dev - Test:
myapp_test - Prod:
myapp
In alembic/env.py you usually read the same DATABASE_URL as the app, or a special DB_URL_MIGRATIONS variable.
Example snippet:
from logging.config import fileConfig
from sqlalchemy import engine_from_config, pool
from alembic import context
import os
from app.db import Base # to include models' metadata
config = context.config
# Override from env var if set
database_url = os.getenv("DATABASE_URL")
if database_url:
config.set_main_option("sqlalchemy.url", database_url)
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadataThis way you can run:
DATABASE_URL=postgresql+psycopg2://user:pass@host/prod_db alembic upgrade headand Alembic will migrate the production database.
Handling multiple environments
The same application code often runs with 3 configurations:
- Development.
- Testing.
- Production.
They all use PostgreSQL, but with different DBs and stricter or looser settings.
Separate databases per environment
A simple naming convention:
| Environment | Example DB name |
|---|---|
| Dev | myapp_dev |
| Test | myapp_test |
| Prod | myapp |
You can control this with an APP_ENV variable:
APP_ENV=development
DB_NAME=myapp_devIn production:
APP_ENV=production
DB_NAME=myapp
Or you expose different DATABASE_URL values entirely.
Read-only vs read-write access
Sometimes you will want:
- Read-write database for the application.
- Read-only database/user for analytics or reporting.
In a full-scale system you might configure two connection URLs:
DATABASE_URL_RW = os.getenv("DATABASE_URL_RW")
DATABASE_URL_RO = os.getenv("DATABASE_URL_RO") # user with SELECT onlyIn this final project you can keep one main URL, but it is good to know how to extend the design later.
Health checks and connectivity
In production, your app must know whether it can talk to PostgreSQL. This is useful for:
- Kubernetes readiness / liveness probes.
- Monitoring systems.
- Automated failover.
Simple database health check endpoint
You can create a minimal endpoint that asks PostgreSQL for a trivial query, for example SELECT 1.
# app/api/health.py
from fastapi import APIRouter, Depends, status
from sqlalchemy.orm import Session
from app.dependencies.database import get_db
router = APIRouter()
@router.get("/health/db", status_code=status.HTTP_200_OK)
def db_health(db: Session = Depends(get_db)):
# Simple query to check connection
db.execute("SELECT 1")
return {"status": "ok"}
You can then configure your load balancer or Kubernetes to hit /health/db.
Rule: A health check should test real dependencies.
For database health, actually run a small SQL query.
Connection pooling and concurrency
In a production backend, you usually have:
- Several worker processes.
- Many concurrent requests.
- A limited number of available database connections.
Matching pool size to PostgreSQL limits
PostgreSQL has a max_connections setting. Each worker in your app creates its own pool. You must ensure the total pooled connections do not exceed what PostgreSQL can handle.
If you run:
4Gunicorn workers.pool_size=5for each.
Then you can have up to $4 \times 5 = 20$ open connections, plus overflows.
You should choose pool_size such that:
$$
\text{Number of workers} \times \text{pool\_size} \ll \text{max\_connections}
$$
If PostgreSQL has max_connections=100 and you reserve some for admin, a safe configuration might be:
- 4 workers.
pool_size=10,max_overflow=10.
So at worst: $4 \times (10 + 10) = 80$ connections.
Pre-ping and stale connections
Long-running APIs sometimes lose connections if:
- The database restarts.
- An idle connection gets dropped by a firewall.
pool_pre_ping=True solves many of these problems:
engine = create_engine(
DATABASE_URL,
pool_pre_ping=True,
# other params...
)It runs a simple "ping" on a connection before it is reused. If it is broken, SQLAlchemy discards it and opens a new one.
Structuring code for database access
You already met the Repository Pattern in a previous chapter. Here is how it might look inside the final project, with PostgreSQL behind the scenes.
Example project layout with repositories
app/
db.py
models/
__init__.py
user.py
repositories/
__init__.py
user_repository.py
schemas/
__init__.py
user.py
api/
__init__.py
users.pyUser model example
# app/models/user.py
from sqlalchemy import Column, Integer, String
from app.db import Base
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
email = Column(String(255), unique=True, index=True, nullable=False)
hashed_password = Column(String(255), nullable=False)User repository example
# app/repositories/user_repository.py
from typing import Optional, List
from sqlalchemy.orm import Session
from app.models.user import User
class UserRepository:
def __init__(self, db: Session):
self.db = db
def get_by_id(self, user_id: int) -> Optional[User]:
return self.db.query(User).filter(User.id == user_id).first()
def get_by_email(self, email: str) -> Optional[User]:
return self.db.query(User).filter(User.email == email).first()
def list(self, limit: int = 100, offset: int = 0) -> List[User]:
return (
self.db.query(User)
.order_by(User.id)
.offset(offset)
.limit(limit)
.all()
)
def create(self, email: str, hashed_password: str) -> User:
user = User(email=email, hashed_password=hashed_password)
self.db.add(user)
# commit is handled in get_db dependency
self.db.flush() # To get the ID without commit
self.db.refresh(user)
return userUsing repository in a route
# app/api/users.py
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from app.dependencies.database import get_db
from app.repositories.user_repository import UserRepository
from app.schemas.user import UserCreate, UserRead
router = APIRouter(prefix="/users", tags=["users"])
@router.post("", response_model=UserRead)
def create_user(
payload: UserCreate,
db: Session = Depends(get_db),
):
repo = UserRepository(db)
existing = repo.get_by_email(payload.email)
if existing:
# raise HTTP 400: email already exists
...
user = repo.create(
email=payload.email,
hashed_password=payload.hashed_password, # hashed in service layer
)
return userHere PostgreSQL is hidden behind both SQLAlchemy and a repository interface. This makes it easy to swap PostgreSQL for another database in the future or to mock the repository in tests.
Using PostgreSQL in tests
For your final project, you should have automated tests that use a separate PostgreSQL database or an in-memory / ephemeral DB.
Strategy 1: Real PostgreSQL test database
Steps:
- Create
myapp_testdatabase. - Configure
DATABASE_URLfor tests:
TEST_DATABASE_URL=postgresql+psycopg2://myapp_test:password@localhost/myapp_test- In your test configuration, build an engine against
TEST_DATABASE_URL. - Create all tables at test startup.
- Use transactions or truncation between tests.
Example pytest fixture:
# tests/conftest.py
import os
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from app.db import Base
from app.main import app
from fastapi.testclient import TestClient
TEST_DATABASE_URL = os.getenv("TEST_DATABASE_URL")
engine = create_engine(TEST_DATABASE_URL)
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@pytest.fixture(scope="session", autouse=True)
def setup_database():
Base.metadata.drop_all(bind=engine)
Base.metadata.create_all(bind=engine)
yield
Base.metadata.drop_all(bind=engine)
@pytest.fixture
def db_session():
session = TestingSessionLocal()
try:
yield session
finally:
session.close()
@pytest.fixture
def client(db_session, monkeypatch):
from app.dependencies import database as db_dep
def override_get_db():
try:
yield db_session
db_session.commit()
except Exception:
db_session.rollback()
raise
app.dependency_overrides[db_dep.get_db] = override_get_db
with TestClient(app) as c:
yield c
app.dependency_overrides.clear()Now your tests talk to a real PostgreSQL instance and you can test your integration properly.
Docker and PostgreSQL for the final project
Many production deployments and local setups will use Docker for both the app and the database.
Example docker-compose.yml snippet
version: "3.9"
services:
db:
image: postgres:16
restart: unless-stopped
environment:
POSTGRES_DB: myapp
POSTGRES_USER: myapp_user
POSTGRES_PASSWORD: super-secret
ports:
- "5432:5432"
volumes:
- myapp_pgdata:/var/lib/postgresql/data
api:
build: ./app
depends_on:
- db
environment:
DB_HOST: db
DB_PORT: 5432
DB_NAME: myapp
DB_USER: myapp_user
DB_PASSWORD: super-secret
ports:
- "8000:8000"
volumes:
myapp_pgdata:Notice:
- The app connects to
DB_HOST=dbbecausedbis the Docker Compose service name. - The PostgreSQL data is persisted in the
myapp_pgdatavolume.
You can run migrations inside the api container:
docker compose run --rm api alembic upgrade head
or use a dedicated migrations service.
Basic production hardening
Before you ship the final project, check some PostgreSQL related security and reliability practices.
Database user and permissions
Create a dedicated application user with only the privileges it needs:
- Log in as a superuser:
CREATE USER myapp_user WITH PASSWORD 'super-secret';
CREATE DATABASE myapp OWNER myapp_user;- Restrict direct superuser access in production as far as possible.
- Avoid connecting as
postgresfrom the app.
SSL / TLS to PostgreSQL
In many hosting providers, connections to the database are encrypted. You may need to add parameters like:
postgresql+psycopg2://user:pass@host/dbname?sslmode=require
Check your provider's documentation for the recommended sslmode and certificates.
Regular backups
The "Database Backups" chapter covers this in detail. For the final project:
- Document how backups will be taken.
- Ensure you can restore your PostgreSQL database to another instance, even if only in a test.
Checklist for PostgreSQL integration in the final project
Use this as a final self review before you move on:
- [ ] All PostgreSQL credentials come from environment variables or secrets, not from code.
- [ ] There is a single place that defines the SQLAlchemy engine and session factory.
- [ ] Connection pooling is configured with sensible
pool_size,max_overflow, andpool_pre_ping=True. - [ ] The application has a clean
get_dbdependency that opens, commits/rolls back, and closes sessions. - [ ] All schema changes are made through Alembic migrations and are applied with
alembic upgrade head. - [ ] There are separate databases or URLs for development, testing, and production.
- [ ] There is at least one health check endpoint that verifies database connectivity.
- [ ] Tests can run against a separate PostgreSQL database, with fixtures that control sessions.
- [ ] In Docker or deployment scripts, the database container or service is defined and wired to the app.
- [ ] A non-superuser database account is used by the application in production.
If you can check all of these items, your PostgreSQL integration is in good shape for a real production backend.
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!