Use case

Serverless REST API endpoints on gateway-backed functions

Ship public JSON APIs without a routing monolith: group REST API endpoints that change together, keep auth at the API gateway, set CORS and rate limits centrally, and version paths before you break schemas.

Create HTTP function →API gateway

Workload and what breaks

Why monolithic REST routers slow teams down

Coupling unrelated REST API endpoints in one deploy makes incidents harder to bisect and slows shipping.

Scaling an entire binary for one hot route wastes memory when only a slice of JSON APIs spikes.

Where shortcuts fail

Why microservice-only splits also miss the mark

Too many tiny repos and pipelines create sprawl—teams still need shared auth, CORS, and rate limits for public JSON APIs.

How Inquir helps

Route groups per function cluster

Group REST API endpoints that deploy together; keep auth, CORS, and rate limits on the API gateway whenever possible.

Validate at the handler boundary and use path prefixes for versioning before breaking JSON contracts.

What you get

REST API gateway hygiene

Rate limits

Protect shared dependencies from abuse.

CORS

Configure browser clients explicitly.

Versioning

Use path prefixes before breaking changes.

What to do next

How to expose REST APIs from Inquir functions

Design resource map

Prefer nouns and consistent error envelopes.

Implement handlers

Validate input at the boundary.

Load test

Measure concurrency per route, not only aggregate RPS.

Code example

JSON error helper

Consistent errors simplify client SDKs. Example envelope: request GET /v1/users/42 → response { "error": { "code": "not_found", "message": "User not found" } }.

util.mjs

export function jsonError(status, code, message) {
  return { statusCode: status, body: JSON.stringify({ error: { code, message } }) };
}

When it fits

Good fit

When this works

Internal APIs
Partner integrations
B2B multi-tenant surfaces

When to skip it

When a framework monolith is already working and team size is tiny

FAQ

Can I expose GraphQL from a serverless function?

Yes—a single function can host your schema and resolvers; rate limits, auth, and cold/warm behavior still apply at the gateway.

How small should each REST function be?

Group routes that deploy and fail together; splitting every path into its own function can explode ops noise—find a balance your team can own.

Where do API keys and JWT validation live?

Prefer gateway-level auth hooks where possible so handlers assume already-authenticated context and stay easier to test.