FastAPI is one of the best Python web frameworks available today — fast, async-native, and backed by excellent tooling. But when you move beyond a single main.py file, you quickly realize that FastAPI gives you the engine, not the car. Structuring a production-ready application is entirely up to you.
Let's walk through what that looks like in practice.
Starting from Scratch
1. Project Layout
A typical "real" FastAPI project ends up looking something like this:
my_app/
├── app/
│ ├── __init__.py
│ ├── main.py
│ ├── config.py
│ ├── database.py
│ ├── logger.py
│ ├── dependencies.py
│ ├── routers/
│ │ ├── __init__.py
│ │ ├── users.py
│ │ └── posts.py
│ └── models/
│ ├── __init__.py
│ ├── user.py
│ └── post.py
├── tests/
├── .env
├── .env.production
├── pyproject.toml
└── README.md
Already a lot of scaffolding — and we haven't written a single route yet.
2. Loading Environment Variables
FastAPI has no built-in env loading. You reach for python-dotenv:
pip install python-dotenv
# app/config.py
import os
from dotenv import load_dotenv
load_dotenv()
env = os.environ.get("APP_ENV", "production")
if env != "production":
load_dotenv(f".env.{env}", override=True)
DATABASE_URL = os.getenv("DATABASE_URL")
SECRET_KEY = os.getenv("SECRET_KEY")
DEBUG = os.getenv("DEBUG", "false").lower() == "true"
But now every config value is a raw string. You need to cast types yourself, handle missing keys yourself, and figure out how to share this across modules without circular imports.
Some teams reach for Pydantic's BaseSettings:
# app/config.py
from pydantic_settings import BaseSettings
class Settings(BaseSettings):
database_url: str
secret_key: str
debug: bool = False
redis_host: str = "localhost"
redis_port: int = 6379
class Config:
env_file = ".env"
settings = Settings()
Better — but now you have two config systems if you need per-environment overrides, and no clean way to namespace configs (database.host vs cache.host).
3. Setting Up the Database
pip install sqlalchemy asyncpg alembic
# app/database.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker, DeclarativeBase
engine = create_async_engine(settings.database_url, echo=settings.debug)
AsyncSessionLocal = sessionmaker(
engine, class_=AsyncSession, expire_on_commit=False
)
class Base(DeclarativeBase):
pass
async def get_db():
async with AsyncSessionLocal() as session:
yield session
Then you wire that into every route as a dependency:
# app/routers/users.py
from fastapi import APIRouter, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from app.database import get_db
router = APIRouter()
@router.get("/users")
async def list_users(db: AsyncSession = Depends(get_db)):
result = await db.execute(select(User))
return result.scalars().all()
Every route needs that Depends(get_db). Every model needs to know about Base. Alembic needs its own env.py wired to your engine. Migrations are a separate manual step to configure.
4. Configuring Logging
FastAPI has no built-in logging configuration. There's no framework opinion — you wire it yourself:
# app/logger.py
import logging
import sys
def configure_logging(debug: bool = False):
level = logging.DEBUG if debug else logging.INFO
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(logging.Formatter(
"%(asctime)s — %(name)s — %(levelname)s — %(message)s"
))
root = logging.getLogger()
root.setLevel(level)
root.addHandler(handler)
logging.getLogger("sqlalchemy.engine").setLevel(logging.WARNING)
logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
Then call it at startup:
# app/main.py
from contextlib import asynccontextmanager
from fastapi import FastAPI
from app.logger import configure_logging
from app.config import settings
from app.routers import users, posts
@asynccontextmanager
async def lifespan(app: FastAPI):
configure_logging(debug=settings.debug)
yield
app = FastAPI(lifespan=lifespan)
app.include_router(users.router, prefix="/api")
app.include_router(posts.router, prefix="/api")
5. Dependency Injection — Roll Your Own
FastAPI's Depends() system is powerful but low-level. Need to inject a service across dozens of routes? You'll write a factory function, register it, and thread it through every handler manually. There's no service container. No provider pattern. No automatic resolution.
6. CLI / Management Commands
Need to run migrations? Seed the database? Clear a cache? FastAPI has no CLI. You'll integrate Alembic, write custom Click commands, wire them to a Makefile or shell scripts, and document everything yourself.
The Honest Summary
By the time you've wired up environment loading, database connections, migrations, logging, dependency injection, CLI commands, and a sensible folder structure — you've built a mini-framework on top of FastAPI.
And you'll do it again for the next project. And the one after that.
There's a Better Way
FastAPI Startkit is a Laravel/Masonite-inspired framework that replaces all of that manual wiring. Let's rebuild the same app — one layer at a time.
Step 1 — A running FastAPI app in one file
Install it:
uv add fastapi-startkit[fastapi]
That's the only dependency you need to start. Here's the minimal main.py:
from pathlib import Path
from fastapi_startkit import Application
from fastapi_startkit.fastapi import FastAPIProvider
app: Application = Application(
base_path=Path(__file__),
providers=[
FastAPIProvider,
]
)
fastapi = app.fastapi
Run it:
uvicorn main:fastapi --reload
Your app is live. No lifespan, no manual FastAPI() instantiation, no setup boilerplate.
Step 2 — Add routes
app.fastapi is a standard FastAPI instance — use FastAPI's own APIRouter exactly as you already know:
from pathlib import Path
+ from fastapi import APIRouter
from fastapi_startkit import Application
from fastapi_startkit.fastapi import FastAPIProvider
app: Application = Application(
base_path=Path(__file__),
providers=[
FastAPIProvider,
]
)
fastapi = app.fastapi
+ router = APIRouter()
+
+ @router.get("/users")
+ async def list_users():
+ return [{"id": 1, "name": "Alice"}]
+
+ @router.get("/users/{user_id}")
+ async def show_user(user_id: int):
+ return {"id": user_id, "name": "Alice"}
+
+ fastapi.include_router(router)
No new API to learn. It's just FastAPI.
Step 3 — Add logging
Swap the standard logging setup for LogProvider. One line:
from pathlib import Path
from fastapi_startkit import Application
from fastapi_startkit.fastapi import FastAPIProvider
+ from fastapi_startkit.logging import LogProvider
app: Application = Application(
base_path=Path(__file__),
providers=[
+ LogProvider,
FastAPIProvider,
]
)
Logging is now configured and active. Change the level with an env var — no code change required:
LOG_LEVEL=DEBUG uvicorn main:fastapi --reload
Step 4 — Add the database
from pathlib import Path
from fastapi_startkit import Application
from fastapi_startkit.fastapi import FastAPIProvider
from fastapi_startkit.logging import LogProvider
+ from fastapi_startkit.masoniteorm import DatabaseProvider
app: Application = Application(
base_path=Path(__file__),
providers=[
LogProvider,
+ DatabaseProvider,
FastAPIProvider,
]
)
Define a model — no Base, no DeclarativeBase, no session factory:
from fastapi_startkit.masoniteorm import Model
class User(Model):
__table__ = "users"
id: int
name: str
email: str
Query it anywhere:
users = await User.all()
user = await User.find(1)
await User.create({"name": "Alice", "email": "alice@example.com"})
Run migrations from the terminal:
uv run artisan migrate
uv run artisan make:model Post
uv run artisan make:migration create_posts_table
No Alembic. No custom env.py. No session dependency threaded through every route.
The full picture
Starting from nothing, here's the complete progression:
from pathlib import Path
from fastapi_startkit import Application
+ from fastapi_startkit.logging import LogProvider
+ from fastapi_startkit.masoniteorm import DatabaseProvider
from fastapi_startkit.fastapi import FastAPIProvider
app: Application = Application(
base_path=Path(__file__),
providers=[
+ LogProvider,
+ DatabaseProvider,
FastAPIProvider,
]
)
fastapi = app.fastapi
Three lines added. Logging, database, and a fully wired FastAPI instance — all ready.
Conclusion
FastAPI is an excellent foundation. But building around it — environment management, configuration, ORM, logging, CLI, dependency injection — takes real effort and tends to drift between projects.
FastAPI Startkit gives you that structure from day one, so you can focus on shipping features instead of plumbing.
For further actions, you may consider blocking this person and/or reporting abuse
