backend-engineering

Name: backend-engineering
Availability: InStock
Author: usermaum

Create FastAPI endpoints and SQLAlchemy models using Clean Architecture patterns.

Updated Nov 22, 2025

Search Tags:#api #fastapi #backend #clean architecture #repository pattern #sqlalchemy

Ready to run

npx skills add https://github.com/usermaum/Themoon --skill backend-engineering-usermaum

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: backend-engineering
Source: https://github.com/usermaum/Themoon/tree/main/.claude/plugins/mas-agents/skills/backend-engineering
Command: npx skills add https://github.com/usermaum/Themoon --skill backend-engineering-usermaum

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a standardized framework and best practices for developing the backend services of TheMoon application, ensuring consistency, maintainability, and scalability.

Core Features & Use Cases

Clean Architecture Implementation: Enforces a layered architecture (API, Service, Repository, Model) for clear separation of concerns.
FastAPI & SQLAlchemy Integration: Offers patterns for creating API endpoints, defining Pydantic schemas, implementing the Repository pattern, and structuring SQLAlchemy models.
Use Case: When you need to add a new API endpoint for managing coffee beans, this Skill guides you through creating the necessary routes, request/response schemas, service logic, and database models following TheMoon's established conventions.

Quick Start

Use the backend-engineering skill to create a new API endpoint for managing coffee beans.

Frequently Asked Questions about backend-engineering

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

FAQPage Schema

How do I structure a FastAPI project using clean architecture?▼

Structure a FastAPI project using clean architecture by enforcing layered separation across API endpoints, Service business logic, Repository data access, and SQLAlchemy Models. This separation of concerns ensures maintainable and scalable backend services.

How do I implement the repository pattern with SQLAlchemy in a backend API?▼

Implement the repository pattern with SQLAlchemy by isolating database operations within a dedicated Repository layer, separate from business logic. This Skill provides conventions for structuring repository implementations alongside SQLAlchemy models and Pydantic schemas.

What is the best way to create a new API endpoint with FastAPI and SQLAlchemy?▼

The best way to create a new API endpoint is to follow established conventions for defining routes, request/response Pydantic schemas, service logic, and SQLAlchemy database models. This process ensures robust and maintainable API endpoint creation.

Do I need Pydantic schemas for every FastAPI endpoint in a clean architecture?▼

Yes, Pydantic schemas are needed to define request and response structures within the API layer. This Skill guides you through creating these schemas to maintain a clear boundary between data validation and internal business logic.

When should I separate service logic from API routes in FastAPI?▼

Separate service logic from API routes in FastAPI when applying clean architecture to maintain separation of concerns. Keeping business logic in a dedicated Service layer prevents endpoint clutter and ensures backend services remain maintainable.