backend

Develop FastAPI backends with hexagonal architecture, SQLModel, and async services.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/djimontyp/task-tracker --skill backend-djimontyp
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend
Source: https://github.com/djimontyp/task-tracker/tree/main/.claude/skills/backend
Command: npx skills add https://github.com/djimontyp/task-tracker --skill backend-djimontyp

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill eliminates the complexity of designing and implementing scalable backend systems by providing proven architectural patterns and code templates for FastAPI applications.

Core Features & Use Cases

  • Hexagonal Architecture: Clean separation of concerns with 23 routers, 35 services, and 21 data models.
  • Async Services: High-performance business logic with async/await patterns and background task processing.
  • Use Case: Imagine you need to build a new microservice for user management. Use this Skill to quickly scaffold the API endpoints, service layer, and data models following established patterns.

Quick Start

Use the backend skill to create a new REST API endpoint for managing user profiles following the hexagonal architecture pattern.

Frequently Asked Questions about backend

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

FAQPage Schema
How do I build a FastAPI backend with hexagonal architecture?

Hexagonal architecture organizes FastAPI backends into Router, Service, and CRUD layers for clean separation of concerns. This Skill provides templates for 23 routers, 35 services, and 21 models following that pattern, enabling scalable microservices with proven structure.

Can I use SQLModel and async/await in FastAPI for high-performance services?

Yes. SQLModel provides type-checked database models, and async/await patterns in FastAPI enable concurrent request handling. This Skill combines both with dependency injection via Depends and TaskIQ workers for background processing.

How do I enforce type safety and code quality in FastAPI projects?

FastAPI backends require mypy strict type checking, ruff formatting, and pytest testing. This Skill enforces all three alongside HTTPException error handling and pydantic model validation to maintain code standards across routers, services, and CRUD operations.

What's the best way to structure REST API endpoints with proper dependency injection?

Use FastAPI's Depends for dependency injection, routing handlers that delegate to service layers, and services that call CRUD repositories. This Skill demonstrates that pattern across 23 routers and 35 services with clear responsibility boundaries.

Does this backend pattern support WebSocket endpoints and background tasks?

Yes. This Skill covers WebSocket endpoints for real-time communication and TaskIQ workers for asynchronous background processing, both integrated within the hexagonal architecture alongside REST API routes.

Can I scaffold a microservice quickly with predefined architectural patterns?

Yes. This Skill provides code templates and architectural patterns for user management microservices and similar use cases, allowing you to scaffold REST endpoints, service logic, and data models following established hexagonal conventions.