DEVELOPER KNOWLEDGE BASE & TERMINOLOGY

API & Edge Computing Glossary

Authoritative definitions, architectural patterns, and code examples for Backend for Frontend (BFF), API aggregation, payload slimming, edge caching, and zero-trust API security.

Architecture & BFF5 terms
Architecture & BFF

API Aggregation

API Aggregation is the process of combining multiple distinct API calls into a single unified HTTP request. An intermediate edge gateway queries multiple upstream services in parallel, merges the returned data, and delivers a consolidated response to the client, drastically reducing mobile latency and network overhead.

Architecture & BFFBFF

Backend for Frontend (BFF)

Backend for Frontend (BFF) is an architectural pattern where a dedicated gateway layer is created for a specific frontend client (e.g., iOS, Android, React). Instead of clients calling multiple generic backend APIs, the edge BFF aggregates upstream calls, injects credentials, and strips unneeded payload fields before transmission.

Architecture & BFF

Custom Domain Edge Routing

Custom Domain Edge Routing allows developers to map their own branded domain (e.g., api.yourdomain.com) to edge infrastructure via CNAME and automated TLS issuance. This creates white-labeled API endpoints, prevents third-party ad-blocker filtering, and enhances brand authority.

Architecture & BFF

Reverse Proxy

A Reverse Proxy is an intermediate server that intercepts requests from client applications and forwards them to one or more backend origin servers. The reverse proxy terminates TLS, applies security filtering, caches responses, and returns the result to the client as if it originated from the proxy itself.

Architecture & BFF

Upstream Fan-out

Upstream Fan-out is an execution strategy where an edge gateway dispatches multiple HTTP subrequests to separate origin services concurrently rather than sequentially. The total latency is bound by the single slowest subrequest (max time) rather than the cumulative sum of all subrequests.

Performance & Edge4 terms
Performance & Edge

Edge Caching

Edge Caching is the practice of storing computed API responses on globally distributed Point of Presence (PoP) servers situated geographically close to users. By serving cached responses directly from edge memory, requests achieve sub-10ms latencies while offloading 95%+ of traffic from origin databases.

Performance & EdgePoP

Point of Presence (PoP)

A Point of Presence (PoP) is an edge data center node located at an internet exchange point (IXP) containing servers that cache data, terminate TLS handshakes, and execute serverless compute close to end users, minimizing long-haul internet routing latency.

Performance & EdgeSWR

Stale-While-Revalidate (SWR)

Stale-While-Revalidate (SWR) is an HTTP cache control extension that instructs the edge to serve an existing cached (stale) response instantly to the client, while asynchronously initiating a background fetch to refresh the cache. Users experience zero latency wait time while always receiving fresh data.

Performance & Edge

Sub-10ms Edge Latency

Sub-10ms Edge Latency describes API response times that complete in under 10 milliseconds from client request to response receipt. This is achieved by terminating TLS and serving cached, aggregated, or transformed responses from edge Point of Presence (PoP) servers located near the user.

Data & Payload Slimming4 terms
Data & Payload Slimming

JSON Projection & Key Mapping

JSON Projection is the declarative extraction, transformation, and renaming of specific nested properties from upstream API payloads into a clean target schema. Executed at the edge without unsafe eval() functions, it delivers lightweight, structured JSON tailored to client UI components.

Data & Payload Slimming

Overfetching

Overfetching occurs when an API response delivers more data than the client application requires to render the current screen or view. For example, downloading an entire 50-field user profile object simply to display an avatar and first name wastes bandwidth, memory, and parsing time.

Data & Payload Slimming

Payload Slimming

Payload Slimming is the technique of stripping unneeded properties, internal metadata, and verbose JSON fields from API responses at the edge before sending them to the client. This reduces response size by 80% to 95%, cutting mobile bandwidth usage, memory overhead, and JSON parsing time.

Data & Payload Slimming

Underfetching

Underfetching occurs when an API endpoint returns insufficient data for a view, requiring the frontend to initiate secondary cascading requests to retrieve related details. This creates latency waterfalls (the N+1 request problem), severely slowing down mobile and web application responsiveness.

Security & Reliability7 terms
Security & Reliability

API Rate Limiting

API Rate Limiting is a traffic control mechanism that caps the number of requests a client, IP address, or API token can execute within a specified time window. Rate limiting prevents server overloading, protects against credential brute-forcing, and shields upstream APIs from exceeding subscription quotas.

Security & Reliability

Circuit Breaker Pattern

The Circuit Breaker pattern is a software resiliency design that monitors upstream service health and temporarily halts requests to failing endpoints. By failing fast and returning cached fallback data, it prevents cascading system outages and reduces recovery time.

Security & Reliability

Client Token (Scoped Bearer Auth)

A Client Token is a scoped, revocable authentication credential designed for frontend web and mobile applications. It grants permission to invoke specific edge API pipelines while enforcing allowed-origin domains and rate limits, safely abstracting sensitive upstream API secrets.

Security & ReliabilityCORS

CORS Preflight & Edge Proxying

Cross-Origin Resource Sharing (CORS) is a browser security protocol that restricts web applications from making API requests to a different domain unless the server explicitly grants permission via HTTP headers. Edge proxies resolve CORS errors by terminating browser preflight OPTIONS requests directly at the edge.

Security & Reliability

Edge Secret Injection

Edge Secret Injection is a security pattern where sensitive upstream API credentials (e.g. Stripe Secret Keys, OpenAI Tokens) are stored in an encrypted vault and injected into HTTP request headers exclusively at the edge runtime, ensuring client browsers and mobile apps never see or store the keys.

Security & ReliabilitySSRF

Server-Side Request Forgery (SSRF) Protection

Server-Side Request Forgery (SSRF) is a security vulnerability where an attacker tricks a backend server into making unauthorized HTTP requests to internal, non-public resources. Edge SSRF protection validates outgoing URLs, blocking private RFC 1918 subnets, loopbacks, and cloud metadata endpoints.

Security & Reliability

Zero-Trust API Architecture

Zero-Trust API Architecture is a security model based on the principle of "never trust, always verify." Every API request—whether originating outside the perimeter or between microservices—must be strictly authenticated, authorized, encrypted, and validated before execution.