How do I expose multiple backend services behind one API?

The usual way is to put an API gateway or reverse proxy in front of your services and have it route requests to the right backend.

Common patterns

1) Path-based routing

Expose one public API domain, then route by URL path:

• api.example.com/users/* → user service
• api.example.com/orders/* → order service
• api.example.com/payments/* → payment service

This is the simplest and most common approach.

2) Host-based routing

Route by subdomain or hostname:

• users.api.example.com → user service
• orders.api.example.com → order service

Useful if services are more independent or have different scaling/security needs.

3) Aggregation/BFF

Have one API layer that calls multiple backend services and returns a combined response.

Example:

• Client calls GET /dashboard
• Gateway/BFF fetches data from user, orders, and notifications services
• Returns one merged payload

This is often called Backend for Frontend (BFF).

Typical architecture

Client
  ↓
API Gateway / Reverse Proxy
  ↓       ↓        ↓
Users   Orders   Payments services

The gateway can also handle:

• authentication/authorization
• rate limiting
• TLS termination
• request logging/metrics
• response caching
• API versioning
• request/response transformation

Tools you can use

Reverse proxies / gateways

• Nginx
• Traefik
• Kong
• Envoy
• AWS API Gateway
• Azure API Management
• Apigee
• Istio ingress gateway / service mesh gateways

If you’re on Kubernetes

• Ingress for simple routing
• API gateway for more advanced API management

Example with Nginx path routing

server {
  listen 443 ssl;
  server_name api.example.com;

  location /users/ {
    proxy_pass http://users-service:8080/;
  }

  location /orders/ {
    proxy_pass http://orders-service:8080/;
  }

  location /payments/ {
    proxy_pass http://payments-service:8080/;
  }
}

Things to watch out for

• Consistent auth across services
• Timeouts and retries
• Versioning so changes don’t break clients
• CORS if accessed from browsers
• Observability: tracing, logs, metrics
• Avoid making the gateway too smart unless you need response aggregation

Rule of thumb

• If you just need routing: reverse proxy / ingress
• If you need centralized API control: API gateway
• If you need combined responses for a client: BFF

If you want, I can show you how to do this with Nginx, Kubernetes Ingress, AWS API Gateway, or Node/Express.