backend-development

Implement backend service handlers with authentication, idempotency, caching, queues, and observability.

1|Updated May 15, 2026
One-click install
npx skills add https://github.com/Blaze-sports-Intel/uber-engineer --skill backend-development-blaze-sports-intel
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-development
Source: https://github.com/Blaze-sports-Intel/uber-engineer/tree/main/plugins/uber-engineer/skills/backend-development
Command: npx skills add https://github.com/Blaze-sports-Intel/uber-engineer --skill backend-development-blaze-sports-intel

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and scripts (resource) components.

What problem does it solve?

Backend-development helps you implement service handlers and platform behaviors that make an API truly usable in production: correct auth enforcement, predictable error handling, retry-safe idempotency, and observable performance.

Core Features & Use Cases

  • Implement behind-the-contract handlers: build the server-side functionality that conforms to an already-defined API wire contract (OpenAPI), including request/response shapes and error schemas.
  • Enforce security end-to-end: implement authentication and authorization flows (session/JWT/OAuth/OIDC/API keys, RBAC/ABAC) with proper validation and security boundaries.
  • Reliability & performance behaviors: add idempotency, rate limiting, caching decisions, and queue/worker patterns for long-running work with graceful degradation.
  • Operational readiness: wire structured logging plus metrics and tracing, and define health/readiness checks and runbooks for key failure modes.
  • Verification-focused delivery: ensures contract tests, auth tests, load tests, observability visibility, idempotency verification, and security scanning are completed before claiming done.

Quick Start

Use the backend-development skill to implement service handlers for POST /v1/orders with end-to-end auth checks, idempotency, structured error responses, and verification evidence ready to prove it is done.

Frequently Asked Questions about backend-development

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

FAQPage Schema
How do I implement backend service handlers that strictly conform to an OpenAPI contract?

Implementing backend service handlers behind an OpenAPI contract involves building server-side logic that matches request and response schemas, enforces authentication, applies idempotency, and passes contract verification checks before deployment.

What is idempotency in API implementation and when do I need it for backend services?

Idempotency in API implementation ensures retry-safe operations by making duplicate requests produce the same result without side effects. You need it for backend services managing queue workers or long-running tasks to prevent duplicate processing during network retries.

How to enforce authentication and authorization flows in Node.js, Python, Go, or Java backend services?

Enforce authentication and authorization flows by validating sessions, JWTs, OAuth, OIDC, or API keys with proper security boundaries. Apply RBAC or ABAC models within Node.js, Python, Go, or Java web frameworks to restrict endpoint access.

Does this approach support adding rate limiting and caching to existing API endpoints?

Yes, this approach supports adding rate limiting and caching to API endpoints. You can implement rate-limit policies and caching decisions directly within your backend service handlers to control traffic flow and improve observable performance.

What's the best way to wire observability and health checks into backend services?

The best way to wire observability into backend services is to integrate structured logging, metrics, and tracing alongside defining health and readiness probes. This provides operational visibility and supports runbooks for handling key failure modes during production incidents.

Why do I need contract tests and security scanning before declaring an API implementation done?

You need contract tests and security scanning before declaring an API implementation done to verify authentication enforcement, idempotency, and observability visibility. This verification-focused delivery proves the service handlers are truly ready for production use.