A Backend for Your Flutter App with FastAPI: From the First Endpoint to the Database and Deployment

If you know Flutter, learning backend development turns you from an "app developer" into a "product builder". FastAPI is an excellent choice for this: fast, modern, with automatic docs and close to Dart in how types are used.

#Why FastAPI?

• It is fast and asynchronous (async).
• It validates data automatically using Python types and Pydantic.
• It generates interactive docs (Swagger) by itself; the Flutter team knows what every endpoint takes and returns without asking.

#The first endpoint

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Course(BaseModel):
    id: int
    name: str
    price: int

@app.get("/api/v1/courses", response_model=list[Course])
async def list_courses():
    return [Course(id=1, name="Flutter", price=4900000)]

Run it with uvicorn main:app --reload and open /docs.

#Input and output models

To receive data from the app, define a Pydantic model. FastAPI rejects invalid data with a clear error message by itself:

class OrderIn(BaseModel):
    name: str
    phone: str
    description: str | None = None

@app.post("/api/v1/orders", status_code=201)
async def create_order(data: OrderIn):
    ...

#Database: PostgreSQL and SQLAlchemy

For storing data, PostgreSQL is a reliable choice and SQLAlchemy (async) is the access layer. To change table structure over time use Alembic, so every change is a versioned migration that is applied on the server with one command:

alembic revision --autogenerate -m "add orders table"
alembic upgrade head

#A layered structure

The same principle you learned in Flutter applies here: router (receives the request) → service (business logic) → repository/ORM (data access). Do not write logic inside the router.

#API versioning

Start paths with /api/v1/.... When the structure changes one day you create v2 and older versions of your app keep working; that matters because users do not all update.

#Connecting to Flutter

On the Flutter side, the same model and Dio from the previous article are enough. Because Pydantic gives responses a fixed shape, fromJson stays simple.

#Deployment

• Package the app as a Docker image.
• Run it behind a web server such as nginx.
• Keep sensitive values (database password, keys) in the server environment, not in code.
• A simple VPS is enough to start; scale up as traffic grows.

#A suggested learning path

1) Python and async, 2) FastAPI and Pydantic, 3) SQL and PostgreSQL, 4) authentication, 5) Docker and deployment. After that you can build any Flutter app yourself from start to finish.