Ship API changes without breaking your clients

Replace deployment anxiety with automated confidence. Hub validates your GraphQL schema changes against real production traffic, enforces deprecation policies, and catches regressions before they merge.

Know what you'll break. Before you ship.

Every change goes through a proposal. Every proposal runs checks. Every check uses real production traffic data.

Traffic-aware validation

Schema changes validated against real client operations. See exactly who is affected before you merge.

Deprecation enforcement

Grace periods and deprecation rules run automatically. No deletion without the right steps.

Performance visibility

Optimizer shows query plan and complexity impact. Catch regressions before they hit production.

Protected main

Main is read-only. Invalid compositions never reach it. That's how Hub works.

The Problem

Every schema change is a bet. Most teams are flying blind.

A field gets renamed. A type gets moved. Someone deletes something that "looked unused." Then production breaks and you spend hours figuring out which client was depending on that field. The problem isn't your engineers — it's that the tools give them no way to know what they're breaking until it's already broken.

01

"I thought nothing was using that"

No visibility into which clients hit which fields. Deletions and renames become a game of chance.

02

Deployment anxiety

Every merge feels risky. Teams delay changes or skip deprecation and hope for the best.

03

Late-night rollbacks

Breaking changes reach production before anyone notices. You find out when clients break.

Protection

The main branch is sacred. Hub keeps it that way.

Traffic-aware checks

Schema changes validated against real client operations. See exactly who is affected.

Deprecation enforcement

Grace periods and deprecation rules run automatically. No deletion without the right steps.

Performance visibility

Optimizer shows query plan and complexity impact. Catch regressions before production.

Protected main

Main is read-only. Invalid compositions never reach it. That's how Hub works.

How It Works

The workflow your team actually needs.

No surprise breakages. No manual governance. No late-night rollbacks.

Create an isolated feature branch.

Main stays clean and locked. Developers work in branches. Main is read-only. Every change goes through a proposal — no direct pushes.

Modify the schema on the canvas.

Validation catches errors as you go. Change types and fields on the canvas. Hub validates composition in real time. Naming rules, type compatibility, duplicate arguments — you fix issues before opening a proposal.

Open a proposal.

Hub runs schema checks and client traffic analysis. Hub connects to your router's production traffic. When you propose a change, Hub checks every active client operation against it. You see which operations are affected and whether the breakage is intentional or a mistake.

Subgraph owners get notified as required reviewers.

Hub adds affected subgraph owners as required reviewers. All discussion threads must be resolved before approval. Nothing merges until the right people sign off.

Once approved, changes flow back to main and sync with production.

Approved proposals update main and sync with your registry. No surprise breakages. No manual governance. No late-night rollbacks.

Everything your graph needs to ship safely

Traffic-aware validation, deprecation enforcement, and composition guardrails — all enforced by the system.

Know exactly what you'll break — before you ship

Hub connects to your router's production traffic. When a developer proposes a schema change, Hub checks every active client operation against it. You see which operations are affected and whether the breakage is intentional or a mistake.

No guesswork. No "I thought nothing was using that."

• Affected operations
  • CheckoutFlowMigrated
  • UserProfileMigrated
  • LegacyReportStill using field
  • Deletion blocked until LegacyReport migrates

Invalid compositions never reach main.

As you design on the canvas, Hub validates in real time — naming rules, type compatibility, duplicate arguments. If your proposed changes don't compose, Hub tells you why and prevents you from saving until it's fixed.

Main only moves forward when a proposal passes every check.

• Real-time validation
  • Schema checks passed: Pass
  • Composition valid: Pass
  • Duplicate argument: userId: Fail
  • Fix errors before opening a proposal

Enforce deprecation. Enforce grace periods. Automatically.

Want to delete a field? Hub requires you to deprecate it first. Set a grace period — say, 14 days — and Hub gives downstream teams time to migrate. After the grace period: if clients are still using the field, Hub blocks the deletion and tells you exactly who's still on it.

Governance that runs itself, so your platform team can stop playing traffic cop.

• Deletion Check: phoneNumber
• Traffic on field: Blocked
• Deprecated < 14 days: Blocked
• 14+ days, zero traffic: Allowed
• Grace period: 14 days

Get Started

Ship with confidence. No more deployment anxiety.

Every change goes through a proposal. Every proposal runs checks. Every check uses real production traffic data.

WunderGraph Hub — Like Figma for your GraphQL schema. Collaborative, visual, and safe to ship.