Build High-Performance FastAPI APIs

Fastapi Pro is an expert FastAPI skill for high-performance, async-first API development with modern Python patterns, covering production-ready microservices and scalable architecture. Its capability areas include:

• Core FastAPI: FastAPI 0.100+ features including Annotated types and modern dependency injection, async/await for high concurrency, Pydantic V2 validation, automatic OpenAPI/Swagger docs, WebSocket support, BackgroundTasks, file uploads and streaming responses, and custom middleware.
• Data management: SQLAlchemy 2.0+ with async drivers (asyncpg, aiomysql), Alembic migrations, the repository and unit-of-work patterns, connection pooling, MongoDB via Motor and Beanie, Redis for caching, and N+1 query prevention.
• API design and architecture: RESTful design, GraphQL via Strawberry or Graphene, microservices patterns, API versioning, rate limiting, circuit breakers, event-driven architecture with message queues, and CQRS/Event Sourcing.
• Authentication and security: OAuth2 with JWT (python-jose, pyjwt), social login, API keys, RBAC and permission-based authorization, CORS and security headers, and input sanitization against SQL injection.
• Testing: pytest with pytest-asyncio, FastAPI's TestClient, factory_boy or Faker for test data, pytest-mock, pytest-cov, load testing with Locust, and contract and snapshot testing.
• Performance: connection pooling for databases and HTTP clients, Redis/Memcached response caching, cursor-based pagination, gzip/brotli compression, and CDN integration.
• Observability: structured logging with loguru or structlog, OpenTelemetry tracing, Prometheus metrics, health-check endpoints, APM integration with DataDog, New Relic or Sentry, and profiling with py-spy.
• Deployment: Docker multi-stage builds, Kubernetes with Helm, GitHub Actions or GitLab CI pipelines, Pydantic Settings for configuration, Uvicorn/Gunicorn or Hypercorn/Daphne tuning, and blue-green or canary deployments.
• Integration patterns: RabbitMQ, Kafka or Redis Pub/Sub message queues, Celery or Dramatiq task queues, gRPC, httpx for outbound calls, webhooks, Server-Sent Events, GraphQL subscriptions, and S3/MinIO file storage.

Its response approach is an eight-step loop: analyze requirements for async opportunities, design API contracts with Pydantic models first, implement endpoints with proper error handling, add comprehensive Pydantic validation, write async tests covering edge cases, optimize for performance with caching and pooling, document with OpenAPI annotations, and consider deployment and scaling strategies.

The bundled resources/implementation-playbook.md gives a concrete endpoint procedure: define request and response schemas from the user journey, keeping ownership and permission decisions server-side and separate from serialization; reuse the application's lifespan and dependency patterns, bound outbound timeouts, avoid blocking calls in async handlers, and never share a mutable database session across concurrent tasks; and test success, invalid input, unauthorized access and persistence failure, verifying response fields, transaction rollback and client-visible errors before updating the API contract. Its worked example is an invoice endpoint with an idempotency requirement, where repeating the same request must not create a second invoice and a different tenant must not retrieve the first one.

Use it for fastapi pro tasks and workflows needing guidance, best practices or checklists. Example requests include an async SQLAlchemy microservice with Redis caching, JWT auth with refresh tokens, a scalable WebSocket chat system, and a file-upload system with progress tracking. Do not use it for tasks unrelated to fastapi pro, or when a different domain or tool fits better. Limitations: background work and external effects need their own retry and idempotency design, and schema validation is not authorization.

Playbook inputs are the installed FastAPI/Pydantic/SQLAlchemy versions, the endpoint contract, the identity model and a test database. Output is a verification report naming the actual files or configuration changed, the checks performed, the observed results and any untested environment, with evidence kept sufficient to reproduce the conclusion.

It suits Python developers building or reviewing production FastAPI services who need async patterns, secure authentication, thorough testing and a deployable, observable microservice rather than a toy endpoint.