HubAPI Governance

API Governance that doesn't
slow you down.

Design APIs consumer-first, automate schema governance, and ship with confidence.

The Problem

Your graph grows. Your teams stay siloed.

As GraphQL Federation scales across teams, ownership disappears, breaking changes reach production, and platform engineers become human routers.

See capabilities
01

"Who owns this entity?"

Teams ask the platform team who owns what. Platform engineers can field dozens of these routing questions a week.

02

Breaking changes in production

Deleted fields, renamed types β€” without traffic-aware validation, they break clients before anyone notices.

03

Service-first, not consumer-first

Teams design from inside their microservice, not from user needs. The graph reflects the org chart, not the product.

How It Works

From UI mock to reviewed proposal

Paste your UI mock

Drop a screenshot of your design (PNG, JPG, or a Figma screenshot) onto the canvas.

Build the dream query

Select the UI area and build the query. Create any missing fields inline.

Assign to subgraphs

Assign new fields to the right subgraph on the shared canvas.

Open a Proposal

Schema checks run, with a client-traffic check on breaking changes. Owners are auto-assigned as required reviewers.

Everything your graph needs to stay healthy

Protected main, required reviewers, client-traffic checks. Governance that scales.

Ownership

Logical and physical ownership, clearly separated

An Architect can own the User type β€” reviewing its schema quality β€” without owning the subgraph that resolves it. The Payroll subgraph's owners review any change to its fields. One change can need approval from both.

Stop asking who to talk to. One click on a type's shield icon shows its owners β€” so platform engineers stop being a human router.

Ownership Map
Assigned
User EntityArchitect
Payroll SubgraphPayroll owners
HR SubgraphHR owners
Shield icon shows owners on the canvas

Protected Main

Changes made in Hub go through a Proposal

Main is read-only in Hub and stays in sync with your production schema. Changes you make in Hub go through a Proposal β€” Hub's pull request for schema. Touch the Payroll subgraph? Its owners are added as required reviewers automatically. Unresolved threads block approval.

Approval is gated. Approve stays inactive until every check passes and every thread is resolved, and the proposal stays blocked until every required reviewer approves.

Proposal #42 Β· Add bonus fieldOpen
Composes
Pass
Breaking changes
Pass
Unresolved Threads
Pass
Awaiting: Payroll owners
Pending
Auto-assigned: Payroll subgraph owners

Safe Deletions

Traffic-aware deletion protection

When a proposal has a breaking change, such as a deleted field, the client traffic check fails it while real clients still use the field. It looks back 7 days by default and needs your router to send schema usage metrics, which it does by default. Graph pruning, if you enable it, also flags fields deleted without being deprecated first, with a configurable grace period. At Error severity, that fails the check.

Clients still use it β†’ blocked. Deleted without @deprecated β†’ flagged by pruning. Deprecated, no client traffic β†’ allowed.

Deletion CheckphoneNumber
Clients still use fieldBlocked
Pruning: never deprecatedFlagged
Deprecated, no trafficAllowed
Traffic lookback: 7 days (default)

Query Intelligence

See if your changes actually improve the graph

Hub calculates complexity distribution across the operations in the collections you select and visualizes whether a schema change makes your graph more or less efficient. Reassign a field to another subgraph and see how average complexity and total fetches change.

Complexity Distribution
main branch
avg ↓ 11%
this branch
Example: main vs. this branch

Governance

Four pillars of graph protection

Hub automates the rules so your team catches breaking changes before approval.

Protected Main

You can't edit main directly in Hub. Changes made in Hub go through a Proposal.

Auto-Reviewer Assignment

Modify a subgraph or type and its owners are added as required reviewers automatically. No manual tagging.

Thread-Blocked Approval

Unresolved discussion threads block approval and show as a failing Hub check on the proposal.

Checks Before Approval

Composition, breaking changes, client traffic, lint and pruning errors, and linked namespaces run from Cosmo. Hub adds checks for unresolved threads and unassigned fields.

Enforcement

How Hub enforces review

Governance maps people to parts of the schema and controls approval at the proposal stage.

  1. 1You create a proposal from your branch.
  2. 2Hub analyzes the schema changes.
  3. 3It identifies the affected types and subgraphs.
  4. 4It adds their owners as required reviewers.
  5. 5The proposal stays blocked until every required reviewer approves. Unresolved discussion threads also block approval.

Graph admins

Can approve any proposal and manage governance settings. Keep this role to platform leads.

Type owners

Review any change to their type, whichever subgraph resolves it. Assign them to shared entities.

Subgraph owners

Review any change that assigns, removes, or modifies fields in their subgraph. Assign one to every service.

Limits. Governance doesn't restrict branch edits, assign implementation work, or apply across graphs. Every affected owner becomes a required reviewer, with no partial approval. Without owners assigned, proposals have no required reviewers.

Hub governance FAQ

What is schema governance software?

Schema governance software controls how a GraphQL schema changes: who reviews a change, which checks it must pass, and when it can ship. In a federated graph, many teams own parts of one schema, so it also tracks who owns each type and subgraph. WunderGraph Hub handles design, proposals, and owner review. Cosmo runs the checks: composition, breaking changes, client traffic, and, where enabled, lint and graph pruning.

What is API governance?

API governance is the set of standards, reviews, and checks that keep an organization's APIs consistent and backward compatible as they change. For a federated GraphQL API, the thing you govern is the schema: one graph composed from many subgraphs, often owned by different teams.

What does API governance include?

Design standards such as naming and lint rules, ownership of each part of the API, review and checks before a change ships, and runtime controls on who can call what. For a federated graph, Hub covers ownership and review. Cosmo schema checks cover breaking changes, client traffic, and, where enabled, lint. The Cosmo Router covers runtime controls such as authorization directives and persisted operations.

How does API governance work in microservices?

Each team ships its own service, so the hard part is coordination: finding the owners a change affects and getting their approval before the code is written. In Hub, a proposal adds the owners of every affected type and subgraph as required reviewers. At one enterprise with 60+ subgraphs, platform team time spent routing schema requests fell from about 60% to about 15%.

What's the difference between API governance and API management?

API management runs APIs in production: gateways, authentication, rate limits, and usage analytics. API governance decides what the API looks like and how it may change. Hub is a governance tool and does not replace API management. For a federated graph, the Cosmo Router handles runtime controls such as authorization and persisted operations.

How does Hub enforce owner review on federated schema changes?

When you create a proposal, Hub analyzes the schema changes, finds the affected types and subgraphs, and adds their owners as required reviewers. The proposal stays blocked until every required reviewer approves, even if all checks pass. Unresolved discussion threads also block approval.

What's the difference between a type owner and a subgraph owner?

A type owner reviews any change to their type, whichever subgraph resolves it. A subgraph owner reviews any change that assigns, removes, or modifies fields in their subgraph. The two are separate, so one change can need approval from both. Graph admins can approve any proposal.

What checks run on a proposal before it can be approved?

Integration checks from Cosmo: Composes, Breaking changes, Client traffic, Lint Errors, Pruning Errors, and Linked namespaces. Hub checks: Unresolved Threads and Unassigned Fields. The Approve button stays inactive until all checks pass and all discussions are resolved.

Does governance stop people editing branches?

No. Governance controls approval at the proposal stage, not editing. It doesn't restrict branch edits, assign implementation work, or apply across graphs.

What happens if no owners are assigned?

Proposals have no required reviewers, so anyone can approve anything. Assign owners once and Hub adds the right reviewers to every proposal that touches an owned type or subgraph.

Which Hub plans include governance?

Subgraph and type ownership and approval workflows are included in Hub Pro ($49 per user per month, with a 14-day trial) and Hub Enterprise. Proposals also need the graph connected to the Cosmo schema registry, with proposals configured in Cosmo.

Related pages

Definitions

What is schema governance software?

Schema governance software controls how a GraphQL schema changes. It decides who reviews a change, which checks the change must pass, and when it can ship.

In a federated graph, many teams own parts of one schema. Governance has to know who owns each type and subgraph, and bring those owners in before a change lands.

WunderGraph Hub covers design and review: proposals, type and subgraph owners, and required reviewers. Cosmo runs the checks a proposal must pass: composition, breaking changes, client traffic, and, where enabled, lint and graph pruning.

API governance for a federated graph

API governance is the set of standards, reviews, and checks that keep an organization's APIs consistent and backward compatible as they change. For federated GraphQL, the thing you govern is the schema.

What API governance includes

Design standards such as naming and lint rules. Ownership of each part of the API. Review and checks before a change ships. Runtime controls on who can call what. Hub covers ownership and review. Cosmo schema checks cover breaking changes, client traffic, and, where enabled, lint. The Cosmo Router covers runtime controls such as authorization directives and persisted operations.

API governance in microservices

Each team ships its own service, so governance breaks down at coordination: finding the owners a change affects and getting their sign-off. Hub puts review at design time, where a proposal adds every affected owner as a required reviewer. At one enterprise with 60+ subgraphs, platform team time spent routing schema requests fell from about 60% to about 15%.

Read the case study

API governance vs API management

API management runs APIs in production: gateways, authentication, rate limits, and usage analytics. API governance decides what the API looks like and how it may change. Hub is a governance tool and does not replace API management. In a Cosmo setup, the router handles runtime controls such as authorization and persisted operations.

Built for teams like yours.

Join teams already using Hub to design, govern, and ship their federated APIs. Start freeβ€”no credit card required.