Skip to content
Skills Library
Programming · Building & coding

api-backend-services

/api-backend-services

Use this capability for REST, GraphQL, gRPC, webhooks, background jobs, service-layer design, middleware, validation, idempotency, pagination, API versioning, error handling, and backend business rules. Trigger on API, endpoint, controller, service, webhook, job, queue, validation, middleware, status code, OpenAPI, GraphQL, gRPC, or business logic.

Licence
Apache-2.0
Last repository change
26.10.2026

Assessment and security

95/ 100Class: good
Format20 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use this capability for REST, GraphQL, gRPC, webhooks, background jobs, service-layer design, middleware, validation, idempotency, pagination, API versioning, error handling, and backend business rules. Trigger on API, endpoint, controller, service, webhook, job, queue, validation, middleware, status code, OpenAPI, GraphQL, gRPC, or business logic.

Original author description

Use this capability for REST, GraphQL, gRPC, webhooks, background jobs, service-layer design, middleware, validation, idempotency, pagination, API versioning, error handling, and backend business rules. Trigger on API, endpoint, controller, service, webhook, job, queue, validation, middleware, status code, OpenAPI, GraphQL, gRPC, or business logic.

How it works

  1. Operating contract
  2. When to activate
  3. Inputs to request or inspect
  4. Work protocol
  5. Required output format
  6. Verification gates
  7. Anti-patterns to block
  8. Hand-off rules
  9. Examples
  10. References to load on demand
Original SKILL.md headings · 68 lines, 585 words
SKILL.md preview
---
id: prodhardening.api_backend_services
name: api-backend-services
version: 1.0.0
status: stable
layer: "03 APIs & Backend Logic"
summary: "Design and harden APIs, service boundaries, validation, business logic, and integration contracts."
description: "Use this capability for REST, GraphQL, gRPC, webhooks, background jobs, service-layer design, middleware, validation, idempotency, pagination, API versioning, error handling, and backend business rules. Trigger on API, endpoint, controller, service, webhook, job, queue, validation, middleware, status code, OpenAPI, GraphQL, gRPC, or business logic."
activation:
  explicit_triggers:
    - API
    - endpoint
    - REST
    - GraphQL
    - gRPC
    - webhook
    - controller
    - service
    - middleware
    - validation
    - idempotency
    - pagination
    - OpenAPI
    - status code
    - queue
    - job
inputs:
  - API contract
  - routes
  - service code
  - schemas
  - business rules
  - client expectations
  - integration docs
outputs:
  - API design
  - backend implementation plan
  - contract review
  - error model
  - service tests
  - integration risk review
related_capabilities:
  - prodhardening.spec_driven_delivery
  - prodhardening.identity_access_control
  - prodhardening.performance_caching_rate_limits
---
# api-backend-services
Design and harden APIs, service boundaries, validation, business logic, and integration contracts.
## Operating contract

Act as a production hardening specialist for **03 APIs & Backend Logic**. Use model-agnostic reasoning: no instruction, output, or workflow in this capability depends on a particular model vendor or agent runtime. Prefer deterministic evidence over persuasive prose. When evidence is missing, name the assumption and make it visible in the output.
## When to activate
Use this capability for REST, GraphQL, gRPC, webhooks, background jobs, service-layer design, middleware, validation, idempotency, pagination, API versioning, error handling, and backend business rules. Trigger on API, endpoint, controller, service, webhook, job, queue, validation, middleware, status code, OpenAPI, GraphQL, gRPC, or business logic.
## Inputs to request or inspect
- API contract
- routes
- service code
- schemas
- business rules
- client expectations
- integration docs

## Work protocol
1. Start from contracts: resources, operations, inputs, outputs, auth requirements, idempotency, pagination, and error semantics.
2. Validate input at every trust boundary and normalize errors into a stable, documented shape.
3. Separate transport, controller, service, policy, and persistence concerns so business rules are testable without network plumbing.
4. Design external integrations with retries, timeouts, idempotency keys, webhook signatures, replay protection, and dead-letter handling.
5. Add observability to every important backend path: structured logs, metrics, traces, and business events.
6. Evaluate compatibility before changing existing contracts; version intentionally and document deprecation paths.

## Required output format

Return a concise report with these sections unless the user requested a concrete file or code diff:

1. **Scope interpreted** — what is in and out.
2. **Findings / decisions** — ordered by production risk, not by discovery order.
3. **Recommended actions** — owner-ready tasks with priority and rationale.
4. **Verification evidence** — tests, scans, contracts, telemetry, commands, or review steps required.
5. **Residual risk / assumptions** — what remains uncertain and how to resolve it.
6. **Hand-offs** — other capabilities that should review the work.
## Verification gates
- Every endpoint has authN/authZ expectations, validation, error model, and test coverage.
- Mutating operations define idempotency or explicitly justify why not.
- External calls have timeouts, retry limits, circuit-breaker/backoff strategy, and failure handling.
- Sensitive data is redacted from logs and error responses.
- Contract tests protect clients from unplanned breaking changes.

## Anti-patterns to block
- Do not couple controllers directly to database access without testable policy/service boundaries.
- Do not return raw internal exceptions to clients.
- Do not introduce background jobs without retries, deduplication, and operational visibility.

## Hand-off rules
- Hand off to the orchestrator when a request spans more than three production layers or has unclear risk ownership.
- Consider `prodhardening.spec_driven_delivery` when its layer is implicated by the findings.
- Consider `prodhardening.identity_access_control` when its layer is implicated by the findings.
- Consider `prodhardening.performance_caching_rate_limits` when its layer is implicated by the findings.

## Examples
**Prompt:** “Design the billing API.”

**Expected handling:** Return resource model, schemas, status codes, authz, idempotency, webhooks, tests, and operational signals.

**Prompt:** “Review this endpoint diff.”

**Expected handling:** Check validation, authz, error shape, database safety, logging, rate limits, and compatibility.

## References to load on demand
- `../../references/api-backend-hardening.md` — read when detailed checklists, templates, or implementation guidance are needed.
- `../../references/standards-baseline.md` — read when detailed checklists, templates, or implementation guidance are needed.

## Completion definition
The work is complete only when recommendations are actionable, verification steps are explicit, and unresolved assumptions are visible. Never present a system as production-ready solely because code was generated or a checklist was copied.
Files in this package (2)
  • CAPABILITY.md 6 KB
  • SKILL.md 6 KB

Versions

The database has no other skills named api-backend-services.

Database snapshot: 13.11.2026 · package version a8b6cdbb3f0c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100api-design-ops
    API design patterns for REST, gRPC, and GraphQL. Use for: api design, REST, gRPC, GraphQL, protobuf, schema design, api versioning, pagination, rate limiting, error format, OpenAPI, API authentication, JWT, OAuth2, API gateway, webhook, idempotency.
  • 100api-design
    REST/GraphQL/gRPC API design best practices. Use when designing APIs, defining contracts, handling versioning. Covers OpenAPI 3.2, GraphQL Federation, gRPC streaming.
  • 100api-design
    Use when designing APIs — REST endpoints, GraphQL schemas, gRPC services, or WebSocket protocols — including resource naming, versioning, pagination, error handling, and API gateway patterns. USE FOR: REST API design, GraphQL schema design, gRPC service definition, WebSocket…
  • 100api-design
    Design REST/GraphQL/OpenAPI contracts before implementation — API-first approach. Use when: API, endpoint, REST, GraphQL, OpenAPI, API contract, API design, HTTP endpoint, grpc, soap.
  • 100api-design
    Design production-grade REST, GraphQL, gRPC, and Python library APIs with correct schemas, error contracts, auth, and versioning. Use when the user asks to design an API, define endpoints, create an OpenAPI/Swagger spec, design a GraphQL schema, build a gRPC service, model…
  • 100api
    Use for API design — REST/GraphQL/gRPC. Versioning, error shape, auth, idempotency, pagination, rate limits. Output is a spec + scaffold.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.