backend-development

Design REST APIs and database schemas with JWT auth, caching, and rate limiting.

2|Updated Jan 22, 2026
One-click install
npx skills add https://github.com/abnegate/claudes --skill backend-development-abnegate
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-development
Source: https://github.com/abnegate/claudes/tree/main/skills/backend-development
Command: npx skills add https://github.com/abnegate/claudes --skill backend-development-abnegate

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you design backend APIs, database schemas, and service behaviors without relying on ad-hoc patterns that later cause inconsistent responses, brittle queries, or weak reliability.

Core Features & Use Cases

  • API Design Conventions: RESTful endpoint structure with clear HTTP verb semantics for resources and nested routes.
  • Production-Ready Data Contracts: Consistent response envelopes with pagination metadata and structured error formats.
  • Backend Architecture Patterns: Schema design (UUID public IDs, soft deletes, indexing), cursor pagination, JWT auth payload and middleware, cache-aside invalidation, rate limiting, and core observability practices.
  • Use Case Example: When building a user/posts service, define the routes, response/error envelopes, implement a UUID-based schema with soft deletes, choose cursor pagination for scalability, and standardize auth, caching, rate limits, and logging/metrics.

Quick Start

Ask an AI to generate a complete backend API and database design for a new service by applying REST conventions, the specified response/error envelopes, cursor pagination, JWT auth middleware, cache-aside invalidation, rate limiting, and basic observability endpoints.

Frequently Asked Questions about backend-development

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

FAQPage Schema
What's the best way to design REST API response envelopes and error contracts?

REST API response envelopes should use a consistent data structure with embedded pagination metadata and a standardized error format. This ensures reliable web service communication by applying uniform HTTP verb semantics across resources and nested routes.

How do I implement cursor pagination for scalable REST APIs?

Cursor pagination for scalable REST APIs is implemented by using a cursor-based query design instead of standard offset limits. This approach prevents performance degradation on large datasets and is integrated directly into the API's pagination metadata response envelope.

How do I structure a database schema with UUID public IDs and soft deletes?

Database schemas should use UUID public IDs, soft deletes, and indexing strategies to maintain data integrity and query efficiency. This schema design method prevents brittle queries by ensuring stable public identifiers and preserving historical records safely.

When do I need JWT authentication middleware and rate limiting for web services?

JWT authentication middleware and rate limiting are needed when building scalable web services that require secure access control. Implementing windowed IP throttling and specific token payload shapes protects endpoints from abuse and verifies user identity.

How does cache-aside invalidation work for backend systems?

Cache-aside invalidation works by explicitly updating or removing cached data when the underlying database record changes. This backend architecture pattern keeps the cache synchronized with primary data stores without relying on automatic time-based expiration alone.

What observability practices should I apply to backend API design?

Backend API observability requires implementing structured logging, metrics collection, distributed tracing, and health check endpoints. These practices monitor API latency and system reliability, providing actionable insights into web service behavior during production operation.