Python + FastAPI — Building APIs with Python

In full-stack engineering, a clear mental distinction must be drawn between the programming language and the web framework:

FastAPI uses Path Operations. In REST terminology, an operation corresponds to an HTTP method (like GET, POST, PATCH, or DELETE), and a path corresponds to the URL endpoint (e.g. /api/items). A Python decorator connects the two to your backend function:

#   HTTP Method   URL Path (Endpoint)
#        │              │
       @app.get     ("/api/tasks")
       def list_tasks():
           # Python backend logic here
           return [{"id": 1, "title": "Buy groceries"}]

Modern FastAPI applications use the FastAPI CLI for local development. Installing the standard package bundle includes FastAPI, Pydantic v2, the CLI tool, and Uvicorn:

# Install FastAPI with standard dependencies (FastAPI CLI + Uvicorn + Pydantic v2)
pip install "fastapi[standard]"

# Or using uv:
uv add "fastapi[standard]"

Create your primary server file named main.py:

from fastapi import FastAPI

app = FastAPI(title="My First API")

@app.get("/")
def root():
    return {"message": "Hello World"}

@app.get("/api/health")
def health_check():
    return {"status": "ok", "service": "backend"}

Start the local development server using the official command:

fastapi dev main.py

An API backend receives data from the client through three primary channels. FastAPI uses Python type annotations and Pydantic models to parse and validate each one:

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()

class TaskCreate(BaseModel):
    title: str = Field(..., min_length=3, max_length=100)
    completed: bool = False

# 1. Path param (task_id: int)
# 2. Query param (include_details: bool = False)
# 3. Request body (task: TaskCreate)
@app.post("/items/{item_id}")
def update_item(item_id: int, task: TaskCreate, notify: bool = False):
    return {
        "item_id": item_id,
        "received_body": task.model_dump(),
        "notify_user": notify
    }

A standard RESTful CRUD architecture maps CRUD operations to HTTP verbs and standardized status codes:

Interact with a live, simulated FastAPI ASGI runtime. Edit the server code, dispatch real HTTP requests, inspect Pydantic v2 validation errors (HTTP 422), or switch to the interactive Swagger UI (/docs) view.

[
  {
    "id": 1,
    "title": "Setup FastAPI project",
    "completed": true
  },
  {
    "id": 2,
    "title": "Write Pydantic models",
    "completed": false
  }
]

In modern full-stack web applications, request data must never be trusted. FastAPI handles validation at two distinct levels:

{
  "detail": [
    {
      "type": "string_too_short",
      "loc": ["body", "title"],
      "msg": "String should have at least 3 characters",
      "ctx": {"min_length": 3}
    }
  ]
}

from fastapi import HTTPException

# Explicitly stop execution and return 404
if task_id not in tasks_db:
    raise HTTPException(
        status_code=404,
        detail="Task not found"
    )

Follow how a client-side frontend (e.g. React / Next.js) communicates with a FastAPI Python backend during a task creation mutation:

const res = await fetch("http://localhost:8000/api/tasks", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ title: "Learn FastAPI", completed: false })
});

Sharpen your diagnostic skills by identifying common FastAPI mistakes, then complete the multi-stage challenge building a production-grade Notes CRUD API.

Part A: FastAPI Diagnostic Lab

@app.get("/api/tasks/{task_id}")
def get_task(task_id):  # Notice: no type annotation!
    return tasks_db.get(task_id)  # Dict has integer keys!

class TaskCreate:  # Missing inheritance!
    title: str
    completed: bool = False

@app.post("/api/tasks")
def create_task(task_in: TaskCreate):
    ...

@app.get("/api/tasks/create")
def create_task(task_in: TaskCreate):
    ...

@app.get("/api/tasks/{task_id}")
def get_task(task_id: int):
    return tasks_db.get(task_id)  # Returns None if missing!

Part B: Build a Notes API with FastAPI Challenge

class NoteCreate:
    title = str
    content = None

class NoteCreate(BaseModel):
    title: str = Field(..., min_length=2)
    content: str | None = None

class NoteCreate(dict):
    title: str
    content: str

Keep these foundational definitions top-of-mind whenever designing backend APIs with Python and FastAPI: