Deploying a Backend: A Guide to FastAPI and Fly.io

© 2026 Sean Miller. All rights reserved.

In modern app development, it’s common to start with a frontend-driven workflow (React, Vue, Svelte, etc.). It lets you iterate quickly: refine UX, pressure test flows, and nail down data schemas with mock data. But prototypes have a way of turning into products. Under pressure, you get piecemeal integrations (Auth, DB, payments), and before long the frontend is carrying far too much responsibility.

At some point you need a backend: a real server-side home for business logic, data access, and secrets.

The goal: build a FastAPI service, containerize it with Docker, and deploy it to Fly.io.

What You’ll Build

• A FastAPI app with two endpoints: GET /health and POST /simulate
• A Docker image that runs the API with Uvicorn
• A Fly.io deployment behind HTTPS, with repeatable deploy commands

If you already have a backend and you just want the Fly deployment steps, skip down to Steps.

What is a Backend?

Start with a common scenario: an enterprise with three applications and no shared backend.

In this scenario, we have four teams that manage three separate applications: a user-facing web app, a user-facing mobile app, and an internal admin dashboard. Each team maintains its own business logic and integrations directly with the databases. This leads to duplicated effort, inconsistent authorization rules, and a security posture that’s hard to reason about.

The same enterprise with a shared backend looks different.

A backend is the server-side integration layer of an application. It’s the part that runs on a server and handles business logic, data access, and AuthN/AuthZ. It’s the layer your frontend talks to when it needs something durable and authorized to happen.

In practice, “backend” usually means:

• an HTTP API (REST, GraphQL, etc.),
• a service boundary where secrets live (DB credentials, API keys),
• and a place to enforce rules consistently across clients.

The Case for a Dedicated Backend

Platforms like Supabase and Firebase can handle a lot before you need a traditional backend. But custom business logic, side effects, and strict control over secrets all demand a dedicated server-side layer.

• Data Storage: A backend lets you store and retrieve data for multiple users and devices, with a stable interface.
• Business Logic: A backend is the right place for workflows that must be consistent across clients. Example: “create an order, charge a card, reserve inventory, and send a receipt” should not be stitched together in three different frontends.
• Security: Your frontend should never hold database credentials or privileged API keys. Backends also centralize AuthN/AuthZ, rate limiting, and input validation.
• Scalability and operability: A backend gives you a stable place for logging, metrics, tracing, and debugging. When something breaks, you want one system of record to inspect.

What is FastAPI?

FastAPI is a modern, high-performance web framework for building APIs with Python. It’s built on top of Starlette (ASGI) and Pydantic (validation + serialization).

FastAPI’s killer feature is that you can write Python functions with type hints and get:

• request parsing + validation,
• structured responses,
• and automatic OpenAPI docs (Swagger UI),

without writing a bunch of glue code.

What is Fly.io?

Fly.io is a platform for deploying and running your apps as containers on lightweight VMs (“machines”), close to your users. It’s a strong fit for small-to-medium APIs because the workflow is simple:

1. Build a Docker image.
2. Deploy it.
3. Get a public URL, logs, and scaling controls.

Alternatives

Several alternatives exist: serverless functions (AWS Lambda), serverless containers (Cloud Run), and edge runtimes (Cloudflare Workers). The trade space at a glance:

Steps

The example creates two endpoints: GET /health and POST /simulate (deterministic calculations based on input parameters).

0) Prerequisites

• Python installed (3.10+ is fine)
• Docker installed
• A Fly.io account + the Fly CLI installed

The examples below use the fly CLI. Some setups still use flyctl. Same tool.

1) Create the project

mkdir fastapi-fly-example # create new directory
cd fastapi-fly-example # change to directory
python3 -m venv .venv # create virtual environment
source .venv/bin/activate # activate virtual environment
python -m pip install --upgrade pip

Install dependencies:

pip install fastapi "uvicorn[standard]"

Create a minimal main.py:

from __future__ import annotations

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(title="FastAPI on Fly.io", version="0.1.0")


@app.get("/health")
def health():
    return {"status": "ok"}


class SimulateRequest(BaseModel):
    seed: int = Field(..., description="Starting seed for a deterministic simulation")
    steps: int = Field(10, ge=1, le=100_000)


@app.post("/simulate")
def simulate(body: SimulateRequest):
    # Simple deterministic PRNG (linear congruential generator)
    value = body.seed & 0x7FFFFFFF
    for _ in range(body.steps):
        value = (1103515245 * value + 12345) & 0x7FFFFFFF

    return {"seed": body.seed, "steps": body.steps, "result": value}

Create a requirements.txt (pin versions later if you want reproducibility):

fastapi
uvicorn[standard]

2) Run locally

Start the server:

uvicorn main:app --reload --host 127.0.0.1 --port 8000

Test it:

curl -s http://127.0.0.1:8000/health
curl -s -X POST http://127.0.0.1:8000/simulate \
  -H "Content-Type: application/json" \
  -d '{"seed":42,"steps":1000}'

FastAPI also gives you API docs out of the box:

• Swagger UI: http://127.0.0.1:8000/docs
• OpenAPI JSON: http://127.0.0.1:8000/openapi.json

3) Dockerize the API

Create a Dockerfile:

FROM python:3.12-slim

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

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

COPY . .

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

Create a .dockerignore:

.venv
__pycache__
*.pyc
.pytest_cache
.mypy_cache
.ruff_cache
.DS_Store

Build + run the container:

docker build -t fastapi-fly-example .
docker run --rm -p 8080:8080 fastapi-fly-example

In another terminal:

curl -s http://127.0.0.1:8080/health

4) Create the Fly app

Authenticate:

fly auth login

Initialize the app (this creates fly.toml):

fly launch --no-deploy

Open fly.toml and confirm the internal port matches your Docker command above (8080). Depending on your CLI version, this may be under [http_service] or [[services]].

# fly.toml (relevant part)
[http_service]
  internal_port = 8080
  force_https = true

5) Deploy

fly deploy

Then open the app:

fly open

6) Verify in production

Grab your app URL (from fly open or fly status) and test:

curl -s https://YOUR-APP.fly.dev/health
curl -s -X POST https://YOUR-APP.fly.dev/simulate \
  -H "Content-Type: application/json" \
  -d '{"seed":42,"steps":1000}'

7) Basic operations + troubleshooting

Useful commands:

fly status
fly logs
fly ssh console
fly secrets set MY_API_KEY="..."

If your deploy succeeds but you get 502 or health check failures, it’s almost always one of these:

• Your server is bound to 127.0.0.1 instead of 0.0.0.0 inside the container
• Your server is listening on a different port than Fly’s internal_port

For FastAPI + Uvicorn on Fly, the safe default is:

• --host 0.0.0.0
• --port 8080 (and set Fly internal_port = 8080)

8) Next steps

Once the deploy loop is solid, the next moves are:

• Add Auth (JWT/session) and start treating your backend as a security boundary
• Add a database (Fly Postgres or a managed DB) and run migrations
• Add rate limiting, request IDs, and structured logging

Writing endpoints is the easy part. Building a backend you can deploy, observe, and trust is the real work. Fly + FastAPI is a solid starting point.