Cosmo Developer Experience

Tools that make federated GraphQL fast to build

Interactive playground tracing, schema exploration, lint enforcement, usage-based pruning, and CLI automation — all built into Cosmo.

Playground, schema explorer, lint, pruning, and CLI. One platform.

Overview

Schema tools, built into Cosmo

Cosmo ships a complete set of developer tools alongside its federation engine. The same platform that composes your graph also provides the playground, schema explorer, lint enforcer, usage analyzer, and CLI you need to build and maintain it.

Every tool connects to the same graph and the same analytics data. There is no context-switching between a separate IDE, a lint tool, and a deployment script. You work in one place.

Why dedicated tooling matters

Why teams need federation-native developer tools

Generic IDEs and linters have no federation awareness. They see a single schema, not a composed graph with subgraphs, operation checks, and real traffic data.

Four problems that surface repeatedly without federation-native tooling.

Query execution is a black box.

Standard GraphQL IDEs return the final result. No subgraph-level timing, no routing information, no visibility into parallel execution.

Schema conventions drift across teams.

Without automated enforcement, naming conventions, documentation requirements, and deprecation standards vary by team and erode over time.

Unused fields accumulate silently.

Teams cannot safely remove fields without usage data. Fear of breaking consumers leads to schema bloat and growing technical debt.

Schema deployments are manual and unvalidated.

Without a CI-integrated CLI, schema changes go out without checks. Breaking changes reach staging before they are caught.

Cosmo Developer Experience tools address all of this natively — no third-party IDEs, no custom lint scripts, no separate deployment tooling.

Cosmo Developer Experience capabilities

GraphiQL Playground++

Enhanced GraphiQL with Advanced Request Tracing (ART). Add the X-WG-TRACE header and get tree and waterfall visualizations of query execution, including per-subgraph timing and inputs/outputs.

Free / Pro / Enterprise

Query Plan Visualization

Include the X-WG-Include-Query-Plan header to receive the full query plan in the response extensions. Use X-WG-Skip-Loader to inspect plans without making subgraph requests.

Free / Pro / Enterprise

Custom Playground Scripts

Run JavaScript before and after operations. Pre-flight scripts handle authentication globally across tabs. Pre-operation and post-operation scripts run per-tab for setup, validation, and transformation. Supports CryptoJS and external fetch.

Free / Pro / Enterprise

Shared Playground State

Generate a URL that encodes a complete playground session — operation, variables, and headers. Recipients open the link and see the exact session, ready to run.

Free / Pro / Enterprise

Which tool do you need?

If you are…Start here
Debugging a slow or unexpected federated queryGraphiQL Playground++
Understanding how the router routes a query across subgraphsQuery Plan Visualization
Sharing a query session with a teammate for review or debuggingShared Playground State
Browsing types, fields, and authentication requirementsSchema Explorer
Enforcing naming conventions and documentation on every checkLint Policies
Finding unused or deprecated fields safe to removeGraph Pruning
Approving an intentional breaking change without disabling checksBreaking Change Overrides
Automating schema checks and deployments in CI/CDCosmo CLI (wgc)

How Cosmo developer tools compare

CosmoGeneric GraphQL IDEsCustom tooling
Query execution tracingART with tree and waterfallResponse onlyManual instrumentation
Schema lint enforcementBuilt-in, runs on every checkPlugin-based, inconsistentCustom scripts required
Usage-based field pruningBuilt-in (Pro / Enterprise)Not availableAnalytics integration required
CLI schema check and publishBuilt-in via wgcSeparate toolingCustom scripts
Shareable playground sessionsBuilt-inRarely availableNot available
Use cases

Developer experience use cases

Real debugging, governance, and automation patterns, and the Cosmo tool behind each one.

Performance debugging

Find which subgraph is slowing your query

Scenario

A product query takes 2 seconds. Multiple subgraphs contribute fields, but generic monitoring only shows the total request time.

How Cosmo handles it

Open the Cosmo Playground, add the X-WG-TRACE header, and run the query. The waterfall visualization shows timing for each subgraph call.

Outcome

The slow subgraph is immediately visible. The fix is targeted — no need to instrument each service separately.

Schema governance

Stop naming inconsistencies before they reach production

Scenario

Multiple teams contribute subgraphs. Without enforcement, field names drift between camelCase and snake_case, types lose descriptions, and deprecated fields accumulate without context.

How Cosmo handles it

Enable Lint Policies with FIELD_NAMES_SHOULD_BE_CAMEL_CASE, ALL_TYPES_REQUIRE_DESCRIPTION, and REQUIRE_DEPRECATION_REASON as errors. Every wgc subgraph check enforces these rules automatically.

Outcome

Schema conventions are enforced consistently. Code review stops catching style violations — the check does.

CI/CD automation

Validate and deploy schema changes without manual steps

Scenario

Schema changes require manual review in the Studio UI. Engineers forget to run checks, and breaking changes reach staging.

How Cosmo handles it

Add wgc subgraph check to the CI pipeline on pull requests. On merge, wgc subgraph publish deploys the schema. Set COSMO_API_KEY as a CI secret.

Outcome

Every schema change is validated before merge. Deployments run automatically. Breaking changes surface in code review, not in staging.

Why teams use Cosmo developer tools

  • Schema checks in CI, not in incidents. wgc subgraph check runs on every pull request. Breaking changes surface before merge, not after deployment.
  • Usage data drives safe removal. Graph Pruning connects to real traffic analytics. Teams see which fields are used, which are deprecated but active, and which are safe to remove — before touching the schema.
  • Every tool connects to the same graph. The playground, schema explorer, changelog, lint enforcer, and CLI all work against the same composed schema and the same analytics data. No syncing separate tools.
Get started

Build faster on your federated graph