I’ve been thinking about GraphQL APIs a lot lately. Why? Because modern applications demand flexibility. Clients want to fetch exactly what they need - no more, no less. That’s where GraphQL shines. But building production-ready GraphQL servers requires careful choices. After experimenting with various Python tools, I found Strawberry and FastAPI to be an exceptional pairing. Let me show you how to build robust GraphQL APIs with this stack.

First, let’s set up our environment. You’ll need Python 3.8+ installed. Create a virtual environment and install key packages:

pip install fastapi uvicorn strawberry-graphql[fastapi] sqlalchemy aiosqlite

Our foundation starts with database models. Using SQLAlchemy, we define our core structures:

# app/models/user.py
from sqlalchemy import Column, Integer, String, Boolean
from app.database import Base

class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String(50), unique=True, nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    hashed_password = Column(String(255), nullable=False)
    is_active = Column(Boolean, default=True)

Notice how we’re using async SQLAlchemy? This ensures our API remains performant under load. Now, what about the GraphQL schema? Strawberry’s dataclass approach makes this intuitive:

# app/schemas/user.py
import strawberry

@strawberry.type
class User:
    id: strawberry.ID
    username: str
    email: str
    is_active: bool

@strawberry.type
class Query:
    @strawberry.field
    async def user(self, info, id: strawberry.ID) -> User:
        # Fetch user from database
        return await UserService.get_user_by_id(id)

Authentication is crucial for production APIs. Let’s implement JWT handling:

# app/services/auth.py
from jose import jwt
from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"])

def create_access_token(data: dict, secret: str, expires_delta: timedelta):
    expires = datetime.utcnow() + expires_delta
    return jwt.encode({**data, "exp": expires}, secret)

Performance matters. The N+1 query problem can cripple GraphQL APIs. DataLoaders solve this elegantly:

# app/services/dataloader.py
from strawberry.dataloader import DataLoader

async def load_users(keys: list[int]) -> list[User]:
    async with AsyncSession() as session:
        stmt = select(User).where(User.id.in_(keys))
        result = await session.execute(stmt)
        return result.scalars().all()

user_loader = DataLoader(load_fn=load_users)

What about real-time updates? Subscriptions are where Strawberry truly shines. Let’s implement a basic event system:

# app/schemas/subscription.py
import strawberry
from .user import User

@strawberry.type
class Subscription:
    @strawberry.subscription
    async def user_created(self) -> AsyncGenerator[User, None]:
        async with pubsub.subscribe("USER_CREATED") as stream:
            async for event in stream:
                yield event["user"]

Error handling separates hobby projects from production systems. We need to catch issues gracefully:

# app/utils/errors.py
from strawberry import GraphQLError

def format_error(error: GraphQLError) -> dict:
    return {
        "message": error.message,
        "code": error.extensions.get("code", "INTERNAL_ERROR")
    }

When deploying, consider these critical steps:

1. Use ASGI servers like Uvicorn with Gunicorn
2. Implement query cost analysis
3. Set up request timeouts
4. Add comprehensive logging
5. Enable distributed tracing

Have you considered how you’ll monitor your API in production? Tools like Prometheus for metrics and Sentry for error tracking are essential. I recommend exporting execution metrics:

# app/monitoring.py
from prometheus_client import Counter

GRAPHQL_QUERIES = Counter("graphql_queries", "Total GraphQL queries")
GRAPHQL_ERRORS = Counter("graphql_errors", "GraphQL errors by type", ["error_type"])

The Strawberry-FastAPI combination gives you type safety through Python’s type hints while maintaining excellent performance. I’ve found this stack reduces development time while increasing reliability. What problems might you solve with this approach?

I’d love to hear about your experiences building GraphQL APIs! If this guide helped you, please share it with others who might benefit. Have questions or suggestions? Let’s discuss in the comments below.