Solutions / Use Case

API Orchestration with REST +
GraphQL Fan-Out

Build one orchestration flow that fans out across multiple REST and GraphQL endpoints, assembles results in JavaScript in microseconds, and returns one response contract to the caller.

Start Building

Customer Response API

The request enters once, fans out to REST and GraphQL sources in parallel, then returns one assembled payload.

  • Fan out to multiple services in parallel instead of chaining API calls serially.
  • Combine REST and GraphQL endpoints in one flow execution context.
  • Use JavaScript steps to normalize and assemble outputs before returning response.

API Orchestration Flow

API Request

# api.request

REST Profile

# rest_profile

REST Eligibility

# rest_eligibility

GraphQL Account

# gql_account_graph

Assemble Payload

# script.assemble

API Response

# api.response

Flow Breakdown

This endpoint returns a unified customer response for a frontend or partner app by orchestrating data from multiple systems in one call.

START
  -> Receive request (customerId)
  -> Validate input
  -> Parallel fan-out:
       - REST: customer profile service
       - REST: product eligibility service
       - GraphQL: account + relationship graph
  -> Merge responses
  -> JavaScript transform: assemble unified customer payload
  -> Return response
END
  • Receive request payload from HTTP trigger or upstream service.
  • Validate request shape and required input fields.
  • Fan out: call REST APIs and GraphQL queries concurrently.
  • Collect and merge responses into a single typed object.
  • Run JavaScript transformation for final response structure.
  • Return aggregated response to caller.

Step Overhead in Unmeshed

For this style of API orchestration, step-to-step runtime overhead is next to nil in Unmeshed because of its architecture.

  • Unmeshed step transitions are engineered for near-nil runtime overhead.
  • Most latency in this pattern comes from upstream APIs, not workflow step handoff.
  • This makes it practical to model clear, granular orchestration steps without sacrificing response speed.

Operational Controls

Orchestration should own reliability behavior so callers get consistent responses even when upstream dependencies vary.

  • Reduce p95 latency by parallelizing independent upstream calls.
  • Centralize retries, timeout behavior, and error routing in orchestration.
  • Keep response contract logic in one place instead of scattered services.

Build an API Orchestration Flow

Start with one composed endpoint, then add additional data sources, retries, and transformation rules without rewriting client-facing APIs.

Get Started