Back to Blog

Building APIs with FastAPI and PostgreSQL

A practical guide to modern API development

January 15, 2025
8 min read

FastAPI has become my go-to framework for building modern REST APIs. Combined with PostgreSQL, it creates a powerful stack for scalable backend applications. In this guide, I'll share the patterns and practices I've learned from building production APIs.

Why FastAPI + PostgreSQL?

After working with Django and other frameworks, FastAPI stands out for several reasons:

  • Performance: Built on Starlette and Pydantic, it's incredibly fast
  • Type Safety: Python type hints provide excellent developer experience
  • Auto Documentation: Swagger UI and ReDoc generated automatically
  • Modern Python: Async/await support out of the box

Setting Up the Project

Here's how I structure a typical FastAPI project:

project/
├── app/
│   ├── __init__.py
│   ├── main.py
│   ├── database.py
│   ├── models/
│   ├── schemas/
│   ├── routers/
│   └── core/
├── requirements.txt
└── .env

Database Connection

I use SQLAlchemy with asyncpg for async database operations:

from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql+asyncpg://user:password@localhost/dbname"

engine = create_async_engine(DATABASE_URL)
AsyncSessionLocal = sessionmaker(
    engine, class_=AsyncSession, expire_on_commit=False
)

The async approach is crucial for handling concurrent requests efficiently.

Key Lessons Learned

1. Use Dependency Injection

FastAPI's dependency injection system is powerful for database sessions, authentication, and configuration management.

2. Separate Schemas

Keep your Pydantic schemas separate from SQLAlchemy models. This provides flexibility and better API design.

3. Handle Errors Gracefully

Implement proper exception handling and return meaningful error responses to API consumers.

Next Steps

This combination has served me well in production applications. The type safety, performance, and developer experience make it an excellent choice for modern API development. In future posts, I'll dive deeper into authentication, testing, and deployment strategies.