FastAPI Performance Optimization Tips

FastAPI is already fast by default, but there are several techniques to make it even faster and more scalable.

1. Database Optimization

Use Connection Pooling

from sqlalchemy import create_engine
from sqlalchemy.pool import QueuePool

engine = create_engine(
    DATABASE_URL,
    poolclass=QueuePool,
    pool_size=10,
    max_overflow=20
)

Async Database Operations

from databases import Database

database = Database(DATABASE_URL)

@app.get("/users/")
async def get_users():
    query = "SELECT * FROM users"
    return await database.fetch_all(query)

2. Response Optimization

Use Response Models

from pydantic import BaseModel

class UserResponse(BaseModel):
    id: int
    name: str
    email: str

@app.get("/users/", response_model=List[UserResponse])
async def get_users():
    # Only return necessary fields
    pass

Enable Gzip Compression

from fastapi.middleware.gzip import GZipMiddleware

app.add_middleware(GZipMiddleware, minimum_size=1000)

3. Caching Strategies

Redis for Session Data

import redis
from fastapi_cache import FastAPICache
from fastapi_cache.backends.redis import RedisBackend

redis_client = redis.Redis(host="localhost", port=6379, db=0)
FastAPICache.init(RedisBackend(redis_client), prefix="fastapi-cache")

Response Caching

from fastapi_cache.decorator import cache

@app.get("/expensive-operation/")
@cache(expire=300)  # 5 minutes
async def expensive_operation():
    # Heavy computation
    return result

4. Background Tasks

For Heavy Operations

from fastapi import BackgroundTasks

def send_email(email: str, message: str):
    # Heavy email sending logic
    pass

@app.post("/send-notification/")
async def send_notification(
    email: str, 
    background_tasks: BackgroundTasks
):
    background_tasks.add_task(send_email, email, "Welcome!")
    return {"message": "Email will be sent"}

5. Monitoring & Profiling

Add Request Timing

import time
from fastapi import Request

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

Key Takeaways

1. Database is often the bottleneck - Optimize queries first
2. Use async/await properly - Don't block the event loop
3. Cache frequently accessed data - Redis is your friend
4. Monitor performance metrics - You can't optimize what you don't measure
5. Use background tasks - For operations that don't need immediate response

These optimizations can significantly improve your FastAPI application's performance and user experience.