add-backend-entity

Generate FastAPI backend entity modules with models, schemas, and routers.

5|Updated Feb 12, 2026
One-click install
npx skills add https://github.com/agusmdev/fullstack-ai-template --skill add-backend-entity
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: add-backend-entity
Source: https://github.com/agusmdev/fullstack-ai-template/tree/main/template/.pi/skills/add-backend-entity
Command: npx skills add https://github.com/agusmdev/fullstack-ai-template --skill add-backend-entity

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a complete, scaffolded approach for adding a new backend entity to a FastAPI project, eliminating ad-hoc boilerplate and ensuring consistency across modules.

Core Features & Use Cases

  • Model, Schemas, Repository, Service, Router: provides a standardized structure to implement a new API resource.
  • Filters, Dependencies, and Registration: ensures consistent querying, wiring, and endpoint exposure.
  • Migration Readiness: includes guidance for creating and applying Alembic migrations. Use Case: When adding a new domain entity (e.g., Product) to a FastAPI app you can follow this guide to generate all necessary layers in a uniform way.

Quick Start

Follow this guide to scaffold a new backend module by creating the model, schemas, repository, service, filters, dependencies, and router, then register it in the app.

Frequently Asked Questions about add-backend-entity

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I add a new backend entity to a FastAPI project?

To add a new backend entity to a FastAPI project, generate the full module structure including SQLAlchemy models, Pydantic schemas, repository, service, and router. This enforces a 3-layer architecture with consistent naming and dependency wiring.

What is the best way to structure a new FastAPI API resource with SQLAlchemy?

The best way to structure a new FastAPI API resource is following a 3-layer architecture that separates models, schemas, repository, service, and router components. This ensures consistent querying patterns, dependency wiring, and endpoint exposure.

Does this FastAPI scaffolding approach include Alembic migration readiness?

Yes, this FastAPI scaffolding approach includes migration readiness by providing guidance for creating and applying Alembic migrations. It ensures typed SQLAlchemy models are ready for database schema updates.

Can I use this to generate Pydantic schemas and repository patterns for FastAPI?

Yes, you can use this to generate Pydantic schemas and repository patterns for FastAPI. It automates creating typed schemas, service layers, filters, and dependencies to ensure uniform module wiring.

What do I need to scaffold a FastAPI module with PostgreSQL integration?

To scaffold a FastAPI module with PostgreSQL integration, you need a project following a 3-layer architecture. The process generates typed SQLAlchemy models, dependencies, router configuration, and registration within your existing application.

Why generate separate repository and service layers when adding a FastAPI module?

Generating separate repository and service layers when adding a FastAPI module enforces consistent querying and business logic separation. This 3-layer architecture standardizes endpoint exposure, filtering, and dependency wiring across new API resources.