Python & API Design

My Journey Learning FastAPI: Scripting to Scale

Published on February 18, 2026 • 10 Min Read • Written by Bhuvanesh V

Introduction

Like many developers, I started my journey in Python writing simple scripts to automate tasks: web scrapers, data parsers, and basic automation utilities. These scripts were linear, synchronous, and designed to run locally on a single machine.

When I transitioned to building web services, I initially used Flask and Django. While these frameworks are robust, they introduced distinct challenges. Flask felt too minimal, requiring manual configuration of validation and database adapters, while Django was heavy, bringing unnecessary features when my only goal was to build a clean JSON API. This led me to explore FastAPI. In this article, I will share the architectural lessons I learned while mastering FastAPI, from basic request routing to deploying scalable containerized backends.

FastAPI vs. The Alternatives

Before diving into the code, it's important to understand where FastAPI fits in the Python web ecosystem:

  • Flask: A micro-framework. It is synchronous, lacks built-in data validation, and relies on manual documentation updates, which often get out of sync with code changes.
  • Django: An all-inclusive framework. It provides an ORM, an admin panel, and session templates, making it heavy for decoupled API microservices.
  • FastAPI: An asynchronous framework built on Starlette and Pydantic. It automatically generates interactive Swagger UI documentation and validates request payloads using native Python type hints.

The Power of Pydantic Validation

In traditional frameworks, validating incoming JSON payloads requires writing verbose helper functions or using external library libraries. If a client transmits a string where an integer is expected, the application might fail mid-transaction, leading to database errors.

FastAPI solves this by leveraging Pydantic. By defining schemas as standard Python classes with type annotations, we get input validation, serialization, and automatic schema documentation in a single step.

Below is a typical endpoint validation pattern: 

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field, EmailStr

app = FastAPI()

class TicketCreateSchema(BaseModel):
    customer_email: EmailStr = Field(description="Contact email address")
    device_model: str = Field(min_length=2, max_length=50, description="Phone or computer model")
    estimated_cost: float = Field(gt=0, description="Repair cost estimate")

@app.post("/tickets")
async def create_ticket(ticket: TicketCreateSchema):
    # If validation fails, FastAPI automatically returns a 422 Unprocessable Entity
    # error with details on the exact field that failed.
    return {"status": "validated", "data": ticket}

Dependency Injection via Depends

One of FastAPI's most powerful features is its Dependency Injection (DI) system. In backend engineering, endpoints frequently depend on shared resources, like database sessions, authentication states, or service clients.

Using FastAPI's Depends helper, we can write modular, testable dependencies. The framework handles session lifecycles automatically, creating a database session before executing the route logic, and closing it when the response is returned.

Below is a pattern for managing database session dependencies: 

from fastapi import Depends
from sqlalchemy.orm import Session
from database import SessionLocal

# Dependency generator function
def get_db():
    db = SessionLocal()
    try:
        yield db  # Provide the session context to the route
    finally:
        db.close() # Ensure session closes after the request completes

@app.get("/items")
async def read_items(db: Session = Depends(get_db)):
    # The session is injected automatically by FastAPI
    items = db.query(Item).all()
    return items

Writing Containerized Production Dockerfiles

Deploying Python applications in production requires consistent environments. Without containerization, variations in Python versions or library paths can cause unexpected runtime errors.

To deploy FastAPI at scale, we use multi-stage Docker builds. This pattern allows us to compile dependencies in a temporary builder image, and copy only the final compiled packages into a minimal production image, reducing container size and security vulnerability footprints.

Below is the production Dockerfile pattern I use: 

# Stage 1: Build dependencies
FROM python:3.11-slim AS builder

WORKDIR /app

RUN apt-get update && apt-get install -y gcc libpq-dev && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

# Stage 2: Final minimal runtime
FROM python:3.11-slim

WORKDIR /app

RUN apt-get update && apt-get install -y libpq5 && rm -rf /var/lib/apt/lists/*

# Copy installed packages from builder
COPY --from=builder /root/.local /root/.local
COPY . .

ENV PATH=/root/.local/bin:$PATH

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Conclusion

Transitioning to FastAPI helped me move from simple scriptwriting to designing production-ready APIs. The combination of Pydantic validation, modular dependency injection, and clean asynchronous execution makes it an excellent choice for modern backend development.

Back to Blog Directory