HubAPI Governance
Design APIs consumer-first, automate schema governance, and ship with confidence.
The Problem
As GraphQL Federation scales across teams, ownership disappears, breaking changes reach production, and platform engineers become human routers.
See capabilitiesTeams ask the platform team who owns what. Platform engineers can field dozens of these routing questions a week.
Deleted fields, renamed types β without traffic-aware validation, they break clients before anyone notices.
Teams design from inside their microservice, not from user needs. The graph reflects the org chart, not the product.
How It Works
Drop a screenshot of your design (PNG, JPG, or a Figma screenshot) onto the canvas.
Select the UI area and build the query. Create any missing fields inline.
Assign new fields to the right subgraph on the shared canvas.
Schema checks run, with a client-traffic check on breaking changes. Owners are auto-assigned as required reviewers.
Protected main, required reviewers, client-traffic checks. Governance that scales.
Ownership
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.
Protected Main
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.
Safe Deletions
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.
Query Intelligence
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.
Governance
Hub automates the rules so your team catches breaking changes before approval.
You can't edit main directly in Hub. Changes made in Hub go through a Proposal.
Modify a subgraph or type and its owners are added as required reviewers automatically. No manual tagging.
Unresolved discussion threads block approval and show as a failing Hub check on the proposal.
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
Governance maps people to parts of the schema and controls approval at the proposal stage.
Can approve any proposal and manage governance settings. Keep this role to platform leads.
Review any change to their type, whichever subgraph resolves it. Assign them to shared entities.
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.
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.
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.
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.
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%.
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.
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.
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.
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.
No. Governance controls approval at the proposal stage, not editing. It doesn't restrict branch edits, assign implementation work, or apply across graphs.
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.
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.
Definitions
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 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.
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.
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 studyAPI 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.
Join teams already using Hub to design, govern, and ship their federated APIs. Start freeβno credit card required.