Building WunderGraph: From Pain Points to a Unified Graph

TL;DR

WunderGraph started with one clear problem: frontends were carrying too much complexity.
In this episode, Jens, Stefan, Dustin, and Björn explain how shifting API composition to the server led to a unified graph model, why open-source adoption validated the approach, and how those lessons continue to shape today’s platform.

Solving the API Integration Problem

The team describes the early days of building client applications that had to call many different APIs, each with its own logic for authentication, caching, and data handling.

We kept writing the same code over and over again just to connect all these services from the frontend.

That repeated pain motivated a new approach: move orchestration off the client and expose one unified API that handles composition securely.

The Move to Server-Side Composition

Dustin explains how pushing composition behind the scenes simplified development. Instead of duplicating logic across frontends, the server became the single place to connect services.

The client shouldn’t care where the data comes from. You ask the graph, and it just handles it.

This design improved performance and consistency and laid the groundwork for today’s supergraph concept—one schema uniting many services.

Open Source and Community Feedback

From the beginning, WunderGraph was released as open source. The community’s feedback confirmed the architecture’s flexibility and surfaced new use cases the team hadn’t considered.

“People started using it for things we never planned, and it still worked — that’s when we knew the abstraction was good.

Open collaboration guided refinements and kept the focus on real developer needs.

Lessons from Early Architecture

Jens emphasizes that simplicity only emerges from solving real problems. Federation wasn’t added later—it appeared naturally as teams tried to scale composition across services.

You can’t fake simplicity — it has to come from solving real problems.

Each iteration clarified boundaries between what the system automates and what developers control.

Looking Ahead: One Graph as the Foundation

The hosts connect those early insights to WunderGraph’s current direction. The unified graph now underpins federation, schema governance, and upcoming integrations with new developer workflows.

From the start, it was always about one graph that makes everything simpler and safer.

The conversation closes with the team reflecting on how a single idea—simplifying API access—continues to drive every decision.