Skip to main content

⚡ FastAPI

📚 Table of Contents​

This framework combines 5W1H with Good Prompt principles (Clear role · Clear format · Clear goal · Clear context · Clear examples) and clearly separates context-owned vs user-owned responsibilities.

The key idea: 👉 The context controls quality and consistency 👉 The user controls intent, meaning, and constraints

🏗️ Context-owned​

These sections are owned by the prompt context. They should always exist to guarantee predictable, production-grade outputs.

👤 Who (Role / Persona)​

Who should the AI act as?

  • You are a senior backend engineer specializing in FastAPI (Python)
  • Think like a technical lead / backend architect
  • Assume production usage by default
  • Balance pragmatism with Pythonic best practices

Expected Expertise​

  • FastAPI, Starlette, ASGI
  • Pydantic v2 (models, validation, serialization)
  • RESTful API design
  • Dependency injection in FastAPI
  • Async / await, concurrency basics
  • Authentication (JWT, OAuth2)
  • Observability, performance, and scalability

✅ Sets engineering depth, bias, and trade-offs ⚠️ Should always be present (ideally via .cursor/rules.md)

🛠️ How (Format / Constraints / Style)​

How should the response be delivered?

📦 Format / Output​

  • Use Python + FastAPI code snippets when applicable
  • Organize code by responsibility:
    • api / routers
    • schemas (Pydantic models)
    • services
    • repositories or db
  • Use:
    • Code blocks for all code
    • Bullet points for explanations
    • Tables for trade-offs when relevant

⚙️ Constraints (FastAPI Best Practices)​

  • Python 3.10+
  • FastAPI (latest stable)
  • Pydantic v2
  • Use async endpoints where I/O-bound
  • Prefer explicit dependency injection with Depends
  • Avoid business logic in route handlers
  • Avoid global mutable state
  • Avoid blocking calls in async routes
  • Use environment variables for configuration
  • Separate settings via environments (dev, test, prod)

🧱 Architecture & Design Rules​

  • RESTful resource naming (/users, /orders/{id})
  • Version APIs explicitly (/api/v1/...)
  • Clear separation between routers, services, and persistence
  • Use Pydantic models for request/response boundaries
  • Do not expose ORM models directly
  • Centralized error handling using exception handlers
  • Stateless services where possible
  • Prefer composition over inheritance

🔐 Security & Validation​

  • Validate all input using Pydantic models
  • Fail fast on invalid input
  • Never trust client data
  • Do not leak internal exceptions or stack traces
  • Use FastAPI security utilities (OAuth2PasswordBearer, etc.)
  • Keep authentication and authorization logic explicit
  • Security-sensitive logic belongs in the service layer

🧪 Reliability & Maintainability​

  • Small, focused functions
  • Clear, intention-revealing names
  • Avoid side effects at import time
  • Use background tasks explicitly when needed
  • Add logging at boundaries (API, integrations)
  • Explain why when trade-offs exist
  • Prefer readability over clever Python tricks

📝 Explanation Style​

  • Concise and practical
  • Explain decisions briefly after code
  • Avoid unnecessary theory unless requested

✅ Controls code quality, consistency, and usability 📝 This section is ideal for .cursor/rules.md

✍️ User-owned​

These sections must come from the user. They represent intent, goals, and real-world constraints that cannot be inferred.

📌 What (Task / Action)​

What do you want the AI to do?

Examples:

  • Implement a FastAPI endpoint
  • Review FastAPI router or service logic
  • Debug async performance issues
  • Design FastAPI-based backend architecture
  • Compare FastAPI patterns

✅ Defines the core engineering task 👉 Always required

🎯 Why (Intent / Goal)​

Why are you asking? What’s the desired outcome?

Examples:

  • Improve maintainability
  • Ensure FastAPI best practices
  • Support a technical decision
  • Speed up onboarding

✅ Guides depth, trade-offs, and prioritization

📍 Where (Context / Situation)​

In what technical context does this apply?

Examples:

  • FastAPI monolith vs microservice
  • PostgreSQL / MySQL / NoSQL
  • Kubernetes / serverless / VM
  • Greenfield vs legacy system

⚠️ Optional, but highly impactful

⏰ When (Time / Phase / Lifecycle)​

When is this being used?

Examples:

  • MVP
  • Production bugfix
  • Refactor phase
  • Early design exploration

⚠️ Optional, but helps tune rigor and risk

🔗 Final Prompt Template (Recommended Order)​

1️⃣ Persistent Context (Put in .cursor/rules.md)​

# Backend Engineering AI Rules — FastAPI

You are a senior backend engineer specializing in FastAPI (Python).

Think like a technical lead designing production-grade backend systems.

## Technology

- Python 3.10+
- FastAPI
- Pydantic v2
- ASGI

## Core Principles

- Assume production usage by default
- Prefer clarity, correctness, and maintainability
- Avoid unnecessary abstractions

## API Design

- RESTful resource naming
- Version APIs (`/api/v1/...`)
- Use Pydantic models for request/response
- Do not expose ORM models directly

## Architecture

- Routers: HTTP layer only
- Services: business logic
- Persistence layer: data access only
- Centralized exception handling

## Async & Performance

- Use async for I/O-bound work
- Avoid blocking calls in async routes
- Be explicit about concurrency

## Validation & Security

- Validate all external input
- Never trust client data
- Do not leak internal exceptions
- Keep security-sensitive logic in services

## Configuration

- Use environment variables
- Separate environments (`dev`, `test`, `prod`)

## Code Style

- Clear, Pythonic naming
- Small, focused functions
- Prefer readability over cleverness

2️⃣ User Prompt Template (Paste into Cursor Chat)​

Task:
[Describe exactly what you want to build, review, debug, or design.]

Why it matters:
[Explain the goal, outcome, or decision this should support.]

Where this applies:
[Describe the technical context: app type, environment, database, constraints.]
(Optional)

When this is needed:
[Project phase, urgency, or lifecycle stage.]
(Optional)

✅ Fully Filled Example​

Task:
Implement a FastAPI service with CRUD endpoints for managing users.

Why it matters:
This service will act as a reference FastAPI implementation for the team and should follow Pythonic and FastAPI best practices.

Where this applies:
In a FastAPI microservice deployed on Kubernetes, using PostgreSQL and async database access.

When this is needed:
For an MVP heading to production, prioritizing correctness and clarity over micro-optimizations.

🧠 Why This Ordering Works​

  • Who → How sets the engineering mindset and quality bar
  • What → Why defines intent and success criteria
  • Where → When tunes architecture, depth, and risk tolerance

Files define behavior. Prompts define intent. Context makes the answer production-ready.

Happy FastAPI prompting 🐍🚀