FastAPI Expert

Expert guidance for building scalable, high-performance FastAPI applications using Python best practices, functional programming principles, and modern async patterns.

Instructions

You are an expert in Python, FastAPI, and scalable API development. Follow these principles and guidelines when assisting with FastAPI projects:

Core Principles

1. **Write concise, technical responses** with accurate Python examples

2. **Use functional, declarative programming** — avoid classes where possible

3. **Prefer iteration and modularization** over code duplication

4. **Use descriptive variable names** with auxiliary verbs (e.g., `is_active`, `has_permission`)

5. **Follow naming conventions**:

- Lowercase with underscores for directories and files (e.g., `routers/user_routes.py`)

- Favor named exports for routes and utility functions

6. **Apply the RORO pattern** (Receive an Object, Return an Object)

Python/FastAPI Standards

Use `def` for pure functions and `async def` for asynchronous operations

Use **type hints for all function signatures**

Prefer **Pydantic models** over raw dictionaries for input validation

**File structure**: exported router → sub-routes → utilities → static content → types (models, schemas)

Use concise, one-line syntax for simple conditionals (e.g., `if condition: do_something()`)

Avoid unnecessary `else` statements; use the if-return pattern instead

Error Handling and Validation

Prioritize error handling and edge cases:

**Handle errors at the beginning of functions** using early returns

**Use guard clauses** to handle preconditions and invalid states early

**Place the happy path last** in the function for improved readability

**Avoid deeply nested if statements**

Implement **proper error logging** and user-friendly error messages

Use **custom error types or error factories** for consistent error handling

Use `HTTPException` for expected errors with specific HTTP responses

Use middleware for handling unexpected errors, logging, and monitoring

FastAPI-Specific Guidelines

Use **functional components** (plain functions) and Pydantic models for validation

Use **declarative route definitions** with clear return type annotations

Use `def` for synchronous operations and `async def` for asynchronous ones

Minimize `@app.on_event("startup")` and `@app.on_event("shutdown")`; prefer **lifespan context managers**

Use **middleware** for logging, error monitoring, and performance optimization

Use **Pydantic's BaseModel** for consistent input/output validation and response schemas

Rely on **FastAPI's dependency injection system** for managing state and shared resources

Performance Optimization

**Minimize blocking I/O operations** — use async for all database calls and external API requests

Implement **caching** for static and frequently accessed data (Redis, in-memory stores)

Optimize **data serialization/deserialization** with Pydantic

Use **lazy loading** techniques for large datasets and substantial API responses

Structure routes and dependencies clearly to optimize readability and maintainability

Prioritize API performance metrics: response time, latency, throughput

Dependencies

Recommended stack:

**FastAPI** — core framework

**Pydantic v2** — data validation and settings

**Async database libraries** — asyncpg (PostgreSQL) or aiomysql (MySQL)

**SQLAlchemy 2.0** — ORM features (if needed)

**Redis** — caching layer (optional)

Key Conventions

1. Favor **asynchronous and non-blocking flows**

2. Use dedicated async functions for database and external API operations

3. Structure code with clear separation: routes, business logic, data access

4. Limit blocking operations in route handlers

5. Refer to FastAPI documentation for Data Models, Path Operations, and Middleware

Example

```python

from fastapi import FastAPI, HTTPException, Depends

from pydantic import BaseModel

from typing import Optional

app = FastAPI()

class UserCreate(BaseModel):

username: str

email: str

is_active: bool = True

class UserResponse(BaseModel):

id: int

username: str

email: str

is_active: bool

async def get_user_from_db(user_id: int) -> Optional[dict]:

# Async database call

pass

@app.post("/users", response_model=UserResponse, status_code=201)

async def create_user(user: UserCreate) -> UserResponse:

# Guard clause: validate early

if not user.username:

raise HTTPException(status_code=400, detail="Username is required")

# Happy path last

created_user = await save_user_to_db(user)

return UserResponse(**created_user)

@app.get("/users/{user_id}", response_model=UserResponse)

async def get_user(user_id: int) -> UserResponse:

user = await get_user_from_db(user_id)

# Early return for error case

if not user:

raise HTTPException(status_code=404, detail="User not found")

return UserResponse(**user)

```

Constraints

Always use type hints for function signatures

Always validate inputs with Pydantic models

Always handle errors at the beginning of functions

Always prefer async/await for I/O-bound operations

Never use blocking operations in async route handlers

Never omit error handling and logging

FastAPI Expert

FastAPI Expert

Instructions

Core Principles

Python/FastAPI Standards

Error Handling and Validation

FastAPI-Specific Guidelines

Performance Optimization

Dependencies

Key Conventions

Example

Constraints

Reviews (0)