Scaling FastAPI and SQLAlchemy 2.0 for Production

In the dynamic world of web development, transitioning from synchronous frameworks like Flask to asynchronous ones, such as FastAPI, can be a game-changer. However, when deploying to production, issues like MissingGreenlet errors, confusing async session behavior, blocked event loops, or slow database calls under load may surface. This article aims to guide developers in building high-performance async backend APIs using FastAPI and SQLAlchemy 2.0, focusing on real-world concerns.

The Setup

To get started, we need our dependencies, including the async driver (aiosqlite) as standard drivers like psycopg2 or sqlite3 are synchronous and will block the loop. The following command installs the necessary packages:

  pip install fastapi uvicorn sqlalchemy aiosqlite pydantic  

The Database Engine (database.py)

The most critical part of an async setup is the AsyncEngine. Initializing this incorrectly can make the entire app synchronous. Here's how to create the Async Engine:

1. Connection String

Note the +aiosqlite driver. For Postgres, use: postgresql+asyncpg://user:pass@localhost/dbname

The Models (models.py)

SQLAlchemy 2.0 introduced a new way to define models using Python type hints (Mapped). Here's an example of a Task model:

The Schemas (schemas.py)

Pydantic handles our data validation. We keep our "Create" logic separate from our "Response" logic.

The API Endpoints (main.py)

Here is where the magic happens. Notice two key things:async def and await session.execute(select(...)).

Async SQLAlchemy Engine and Session Lifecycle in FastAPI

In production FastAPI applications, the async SQLAlchemy engine should be created once at application startup and reused across requests. Creating engines or sessions per request is a common mistake that leads to connection exhaustion and unpredictable performance.

Why This Matters

In the synchronous world, if the database takes 200ms to fetch those tasks, your entire server thread is blocked for 200ms. In this Async version, while the database is fetching data (await db.execute), Python releases the control loop. Your API can accept 50 other requests during that 200ms "wait" time. This is how you scale to thousands of users on a single server.

Next Steps: Deployment

Now that you have a high-performance backend, how do you deploy it? You can't just use python main.py in production. In the next article, I will show you how to containerize this with Docker and deploy it to Google Cloud Run.