A monograph is essentially a federated graph with a single, automatically managed subgraph. When you create a monograph, Cosmo internally creates both the graph and its subgraph. You interact only with the monograph, and the internal subgraph is transparent.

Does migrating preserve schema history?

Yes. Schema history and configurations are preserved during migration. Migration does not require changing your infrastructure.

Can I use Schema Contracts with a monograph?

Yes. Monograph schemas can use `@tag` directives, and Schema Contracts can filter the schema for different audiences. Each contract has its own router deployment.

What do I need to use a monograph?

You need a GraphQL server accessible from the router, router deployment infrastructure, and a CLI authenticated with monograph permissions.

Monograph Support | Cosmo by WunderGraph

Q: What platform features are available for monographs?

Monographs support Cosmo platform features including schema registry, schema checks, analytics, Studio, contracts, and Cosmo Router integration. You get these capabilities without configuring federation.

The problem

Why single-service GraphQL teams often end up under-tooled

Not every GraphQL deployment needs federation from day one. But most federation-focused platforms make you choose between adopting federation complexity early or using basic tooling now and migrating later.

Federation overhead before you need it

Most federation-focused platforms require federation configuration even for a single GraphQL service. Teams end up adopting federation complexity before they actually need multiple services.

Basic tooling now, harder migration later

Use basic tooling now and migrate when the time comes, or adopt federation complexity before it is needed. Both choices create tradeoffs for teams that only need one GraphQL service today.

No schema registry for simple APIs

Teams with simple GraphQL APIs often still need professional schema management, checks, analytics, and contracts. Without first-class monograph support, they are pushed toward basic tooling or federation complexity.

Our solution

A first-class path for single-service GraphQL

Cosmo’s monograph support provides a first-class experience for single-service GraphQL APIs. Create a monograph, publish your schema, and access schema registry, checks, analytics, contracts, Studio, and Router without configuring federation. When you are ready to split into multiple services, one CLI command migrates the monograph to a federated graph while preserving schema history and configurations.

How it works end to end

Create a monograph with `wgc monograph create production --routing-url ... --graph-url ...`. The routing URL is where clients connect; the graph URL is your GraphQL server.
Publish your schema with `wgc monograph publish production --schema ./schema.graphql`. Cosmo registers it and makes it available in Studio for schema management and analytics.
Access Cosmo platform features like schema registry, Studio, analytics, checks, and contracts.
Run `wgc monograph check production --schema ./schema.graphql` in CI before every deploy to catch breaking changes and lint issues before they reach production.
When your architecture grows, run `wgc monograph migrate production` to convert to a federated graph. Your schema history and configurations are preserved.

Start simple. Scale to federation when you are ready.

Monograph support

Before & After

Before Cosmo	With Cosmo
Limited tooling for non-federated GraphQL	Full platform features for monographs
Painful migration to federation later	Single-command migration when ready
No schema registry for simple APIs	Complete schema management
Basic analytics only	Full analytics and observability

Under the hood

What a monograph is

Internally a federated graph — Cosmo manages a single subgraph automatically. You interact only with the monograph.
Routing URL — where clients connect to the Cosmo Router.
Graph URL — your actual GraphQL server endpoint. The router proxies requests there.
Migration to federation — running `wgc monograph migrate production` converts the monograph to a federated graph with the original schema as the first subgraph.

Key benefits

Professional tooling from day one

Available on Free, Pro, and Enterprise plans.

Zero federation overhead

Deploy a single-service GraphQL API without federation complexity or configuring federation. Cosmo automatically manages the internal subgraph so you interact only with the monograph.

Full platform access

Schema registry, schema checks, analytics, Studio, contracts, and Cosmo Router integration are available for monographs without needing a federated graph from day one.

One-command migration to federation

Run `wgc monograph migrate production` and the monograph becomes a federated graph with the original schema as the first subgraph. New subgraphs can then be added.

Contract support for single-service APIs

Use `@tag` directives in your schema and create filtered contracts for different audiences, including internal and external consumers, before you add a second service.

Future-proof from day one

Start with one service and a clear path to federation. When you migrate, schema history and configurations are preserved.

How monograph support works

01

One command to get started.

Create the monograph

Run `wgc monograph create production --routing-url ... --graph-url ...`. Cosmo creates the graph and its managed subgraph internally. You interact only with the monograph.

02

Schema registered immediately.

Publish your schema

Run `wgc monograph publish production --schema ./schema.graphql`. Cosmo publishes the schema to the monograph and makes it available in Studio.

03

No federation configuration required.

Use Cosmo platform features

Use Cosmo platform features like Studio, schema registry, analytics, checks, and contracts without configuring federation.

04

Catch issues before deploy.

Validate in CI

Add `wgc monograph check production --schema ./schema.graphql` to your CI pipeline. Breaking changes and lint issues are caught before they reach production.

05

One command to federate.

Migrate when ready

Run `wgc monograph migrate production`. The monograph becomes a federated graph with the original schema as the first subgraph. New subgraphs can now be added.

Use cases

When teams use monograph support

Quick API deployment

Quick start

A team wants professional schema management for a single GraphQL service. Create a monograph with `wgc monograph create production --routing-url ... --graph-url ...`, publish the schema, and use Studio for schema management and analytics without configuring federation.

API with multiple audiences

Contracts

A single GraphQL service needs to expose different schemas to internal and external consumers. Add `@tag` directives to the monograph schema, create contracts for each audience, and deploy a router per contract.

Migration to federation

Growth

A growing application needs to split into multiple services. Run `wgc monograph migrate production`. The monograph becomes a federated graph with the original schema as the first subgraph. New subgraphs can now be added.

Schema validation in CI

CI/CD

A team wants to catch breaking changes before every deploy. Add `wgc monograph check production --schema ./schema.graphql` to the CI pipeline. Breaking changes and lint issues are reported before production.

When to use a monograph

When to use

You have one GraphQL service and want professional schema management without federation complexity.
You need schema checks, analytics, or contracts before you have multiple services.
You expect to grow to multiple services and want a clear migration path.

Requirements

A GraphQL server accessible from the Cosmo Router.
Router deployment infrastructure.
CLI authenticated with monograph permissions.

Start with one service. Scale when you are ready.

Monograph support is available on all plans — Free, Pro, and Enterprise.

Start Free See the docs

Cosmo platform features for a single GraphQL service