endpoint-performance-scrutiny

Enforce direct indexed lookups for exact-key retrieval across API, database, and cache layers.

Updated Nov 7, 2025
One-click install
npx skills add https://github.com/belluga/delphi-ai --skill endpoint-performance-scrutiny
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: endpoint-performance-scrutiny
Source: https://github.com/belluga/delphi-ai/tree/main/skills/endpoint-performance-scrutiny
Command: npx skills add https://github.com/belluga/delphi-ai --skill endpoint-performance-scrutiny

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Prevent inefficient access patterns that rely on listing and filtering instead of direct, indexed lookups for exact entities.

Core Features & Use Cases

  • Enforces exact-key lookup paths, direct queries, and appropriate indexing to ensure scalable, low-latency retrieval.
  • Documents canonical lookup paths and provides deterministic audit workflows, integrating with tooling to detect anti-patterns in backend and client code.
  • Use Case: When retrieving resources by id or slug across microservices, ensures the path uses a direct query rather than broad fetch followed by in-memory filtering.

Quick Start

Run a focused audit on an endpoint like /resource/{id} to confirm direct index-based retrieval is used.

Frequently Asked Questions about endpoint-performance-scrutiny

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

FAQPage Schema
How do I prevent API endpoints from doing list-based scans for exact lookups?

Direct, indexed lookups prevent list-based scans by enforcing exact-key database queries using identifiers like id, slug, or uuid. This avoids broad fetches and in-memory filtering, ensuring low-latency retrieval.

Why does my microservice fetch entire lists to filter by uuid instead of querying directly?

Fetching entire lists to filter by uuid happens when endpoints lack canonical direct access paths. Applying indexed query enforcement and database constraints ensures the service retrieves the exact entity directly without scanning.

What is the best way to audit backend endpoints for inefficient data access patterns?

The best way to audit backend endpoints for inefficient data access patterns is running focused audits on routes like /resource/{id}. This verifies direct index-based retrieval and collects deterministic audit evidence for compliance.

When do I need to enforce canonical lookup paths for API design?

You need to enforce canonical lookup paths for API design when retrieving resources by exact keys like id or slug across microservices. This ensures scalable, low-latency retrieval and satisfies explicit index support requirements.

Can I use this approach to detect query optimization anti-patterns in client integrations?

Yes, you can detect query optimization anti-patterns in client integrations. The approach integrates with tooling to identify inefficient access patterns across API, database, and cache layers where exact lookups are required.