skills.rest
fm-dev-mx
fm-dev-mxCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

backend_engineering

Standardize server-side logic with TypeScript, Zod, and Supabase.

Updated Jun 21, 2024
Search Tags:#typescript#api#validation#backend#supabase#service layer
One-click install
npx skills add https://github.com/fm-dev-mx/celebra-me --skill backend-engineering-fm-dev-mx
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: backend_engineering
Source: https://github.com/fm-dev-mx/celebra-me/tree/main/.agent/skills/backend-engineering
Command: npx skills add https://github.com/fm-dev-mx/celebra-me --skill backend-engineering-fm-dev-mx

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill standardizes the development of server-side logic, ensuring consistency and reliability in API routes, data validation, and external service integrations.

Core Features & Use Cases

  • Layered Architecture: Enforces separation of concerns between API, Service, and Repository layers.
  • Data Validation: Implements runtime sanitization and schema validation using Zod.
  • Supabase Integration: Provides a pattern for secure and type-safe interaction with Supabase.
  • Error Handling: Defines clear standards for API error responses.
  • Use Case: When creating a new API endpoint for user registration, this skill guides the implementation to validate input, handle business logic, interact with the database via Supabase, and return a standardized success or error response.

Quick Start

Use the backend_engineering skill to create a new API route for handling user sign-ups.

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 TypeScript backend API with Supabase for maintainability?▼

Standardizing server-side logic involves enforcing a strict three-layer architecture: API, Service, and Repository. This pattern separates routing, business logic, and data persistence to ensure consistent, maintainable, and scalable backend systems.

What's the best way to validate API request data in a TypeScript backend?▼

The best way to validate API request data is using Zod for runtime sanitization and schema validation. This guarantees type-safe inputs before processing business logic, preventing invalid data from reaching your service layer.

How do I standardize API error responses in a web application?▼

Standardizing API error responses requires defining clear handling standards within your service layer. This ensures every endpoint returns consistent success or error formats, making server-side logic reliable and predictable.

Does this backend engineering approach work for integrating external services?▼

Yes, this backend engineering approach standardizes external service integration within the service layer. It ensures reliable, type-safe interaction patterns between your API routes and third-party services using structured logic.

When do I need a three-layer architecture for server-side logic?▼

You need a three-layer architecture for server-side logic when building robust backend systems requiring strict separation of concerns. It isolates API routing, business logic, and database persistence to maintain scalability as application complexity grows.

Related Skills

Explore More Software Engineering Skills→
PlebeianAppPlebeianApp
9

typescript

Configure TypeScript projects and design type-safe APIs with advanced types.

Official
Advanced
Selfdb-ioSelfdb-io

api-routes

Implement Expo Router API routes with TypeScript endpoints and EAS Hosting deployment.

Community
Intermediate
lciaccilciacci

supabase-python

Build FastAPI backends with Supabase authentication and typed PostgreSQL access.

Community
Intermediate
heimeshoffheimeshoff
1

fsharp-backend

Implement F# backend endpoints with Giraffe and Fable.Remoting.

Community
Advanced