What should I use for failover and circuit breaking at the API layer?

For the API layer, a good default is:

• Failover: use a load balancer / API gateway / service mesh retry + upstream health checks
• Circuit breaking: use a circuit breaker library or mesh feature around each downstream dependency

Practical choices by layer

1) If you want something infrastructure-level

Use:

• API Gateway / Load Balancer for routing and failover
• Service Mesh (Istio, Linkerd, Consul) for retries, timeouts, and circuit breaking

Good when you have multiple services and want centralized policy enforcement.

2) If you want application-level control

Use a circuit breaker in the API code:

• Java: Resilience4j
• .NET: Polly
• Node.js: opossum
• Go: gobreaker or built-in patterns

Then pair it with:

• short timeouts
• limited retries with backoff
• bulkheads / concurrency limits
• fallbacks where appropriate

Recommended pattern

At the API layer, implement in this order:

1. Timeouts
2. Circuit breaker
3. Retries only for safe/transient failures
4. Fallback or degraded response
5. Health checks / failover routing at gateway or LB

Important cautions

• Don’t retry on every error; retrying can make outages worse.
• Circuit breakers should be per dependency, not one global breaker.
• Failover should be based on health checks, not just request failures.
• Keep retries low and bounded to avoid thundering herds.

Simple recommendation

If you want a straight answer:

• For microservices: use a service mesh or API gateway for failover, plus Resilience4j/Polly/etc. in the service for circuit breaking.
• For a simpler setup: use LB health checks for failover and an in-app circuit breaker library for downstream calls.

If you tell me your stack (AWS/GCP/Azure, language, monolith vs microservices), I can suggest the best concrete option.