Blog
Get the latest news on how products at WunderGraph are built, technologies are used, and join the teams helping to build a better landscape of API integration.
The State of Federation 2026 Survey Is Open
Share how your team adopts, operates, and scales GraphQL Federation—including AI and LLM workloads—in the vendor-neutral State of Federation 2026 survey.
Brendan Bondurant
Three Handlers for Event Driven GraphQL Subscriptions
Cosmo Streams adds three router handlers to enable subscription authorization, initial state delivery, and per-subscriber event filtering without building custom infrastructure.
Dominik Korittki
10 Principles for Designing Good GraphQL Schemas
Learn 10 proven principles for designing GraphQL schemas that scale. Covers capability-based design, error handling, nullability, pagination, federation, and avoiding common pitfalls from companies like eBay and SoundCloud.
Jens Neuse
The Hidden Cost of Non-Compliance in AI
Learn how the EU AI Act, Colorado's AI Act, and California SB-53 impact engineering teams and how to build audit-ready AI systems.
Brendan Bondurant & Tanya Deputatova
What a Year at WunderGraph Looks Like
A year at WunderGraph, what ownership really means in a fast scaling company, and how roles are shaped rather than assigned.
Brendan Bondurant
Cosmo Streams: GraphQL Subscriptions Without the Hurdle
Cosmo Streams lets teams expose events through GraphQL subscriptions without the need to bring their own code. Events flow directly from the message broker through the Cosmo Router to clients.
Dominik Korittki
TypeScript Plugin Support for Cosmo Connect
Cosmo Connect now supports TypeScript router plugins, allowing developers to write plugin logic in TypeScript and load it directly into the GraphQL federation router without deploying separate services.
Milinda Dias
Extending Subgraph Checks in Cosmo
Cosmo now supports subgraph check extensions, allowing teams to add custom validation rules to their subgraph checks. Cosmo runs its normal linting and schema checks, and your service adds any additional logic through a secure external endpoint.
Wilson Rivera
Applying for a Role at WunderGraph
What we look for, how our interview process works, and how to get the most out of applying to WunderGraph.
Mariya Hristova
From 10+ Seconds to Under One: Solving Their Slowest Operation
A personal finance marketplace reduced planning latency by roughly 90–95 percent and made its slowest queries 12–18× faster after replacing an aging Apollo Gateway with WunderGraph Cosmo and enabling the Cache Warmer.
Brendan Bondurant
Building the Company We Always Wanted to Work In
How WunderGraph scaled in 2025 with intentional culture, better hiring, stronger representation, and a people first approach to building a great company.
Alexandra Stoica
Why Customer Success Can't Be Automated
A thoughtful look at why AI can’t replace empathy, curiosity, or creativity in business—and why keeping humans in the loop is good for both customers and companies.
Viola Marku
GraphQL Operation Descriptions: How a Spec Update Solved Our MCP Problem
The September 2025 GraphQL spec update added official support for operation descriptions. This solved a real problem: how to document GraphQL operations for MCP tools without custom hacks or non-standard conventions.
Ahmet Soormally
When Prompt Injection Gets Real: Use GraphQL Federation to Contain It
How GraphQL Federation helps protect AI systems from prompt injection by enforcing runtime boundaries, scoped access, and signed configurations.
Brendan Bondurant & Tanya Deputatova
MCP Gateway with Curated GraphQL Persisted Operations
Curated GraphQL Persisted Operations (POs) provide a secure, task-level facade for exposing APIs to LLMs via the Modex Context Protocol (MCP). They reduce complexity, enforce security, and ensure stable tool use compared to raw REST APIs.
Ahmet Soormally
A Smooth API Developer Experience with WunderGraph Cosmo
How WunderGraph Cosmo simplifies GraphQL Federation with CQRS, event-driven federated subscriptions, and persisted operations for a secure, scalable developer experience.
Vincent Vermersch
Understanding GraphQL Federation Versions (V1, V1.5, and V2)
Learn the key differences between GraphQL Federation V1, V1.5, and V2. Understand how entities, value types, and directives like @external and @shareable evolved, and how routers interpret subgraphs across versions for composition compatibility.
David Stutt
Cosmo Connect vs Apollo Federation vs GraphQL Federation
Head-to-head comparison of Cosmo Connect, Apollo Federation, and GraphQL Federation—how they model entities, handle batching, and what that means for operations.
Jens Neuse
A GraphQL Federation directive for Subgraph-level compliance: @openfed__requireFetchReasons
The @requires directive in GraphQL Federation can leak sensitive fields. See how @openfed__requireFetchReasons improves security, compliance, and audit readiness.
Jens Neuse
Cosmo Connect Tutorials for Router Plugins and gRPC Services
Step-by-step tutorials for Cosmo Connect: build Router Plugins, deploy gRPC services, and integrate subgraphs into a federated GraphQL API.
Brendan Bondurant
The Evolution of GraphQL Federation and the Entity Layer
How GraphQL evolved from monoliths to Schema Stitching to Federation, and why the Entity Layer has become the foundation for unified APIs.
Jens Neuse
Acoustic saves $178K in engineering costs with WunderGraph Cosmo
Acoustic cut $178K in costs and complexity by replacing Rust plugins and brittle rollbacks with Cosmo’s schema-aware router and visual tooling.
Brendan Bondurant
Cosmo Connect: Federation Made Accessible
Cosmo Connect lets backends use gRPC while frontends see one GraphQL API, lowering the barrier to federation across teams and languages.
Jesse Thompson
The WunderGraph Engineering Growth Framework
The engineering career framework at WunderGraph fosters growth, progression, and scaling teams with transparency, fairness, and strong culture.
Alexandra Stoica
How Our Core Beliefs Drive the Way We Scale
Inside WunderGraph’s culture manifesto: how our core beliefs shape hiring, remote teamwork, and scaling a global GraphQL platform — fast and without fluff.
Alexandra Stoica
Over 15 Years of APIs with Kevin Swiber
API veteran Kevin Swiber joins The Good Thing to unpack MCP, AI hype, and why the future of infrastructure should be boring, in a good way.
Brendan Bondurant
The Architecture Behind 40 Deploys a Day at Luxury Presence
Luxury Presence scaled faster and simplified architecture by replacing BFFs with GraphQL Federation using WunderGraph Cosmo's unified API platform.
Brendan Bondurant
The Future of GraphQL Federation
A crosspost of Curtis Layne’s deep dive into the architectural tradeoffs of Apollo Federation and the path toward simpler, faster, more scalable approaches to GraphQL Federation.
Curtis Layne
Behind the Counter: How Cosmo Works
Ever wonder how GraphQL federation works in practice? This story-driven guide uses a food truck park to explain Cosmo’s role in schema composition and routing.
Brendan Bondurant
Managing Permissions in Cosmo Just Got Easier with Groups
Manage access with precision in Cosmo. Groups let you control who can view, publish, or deploy, across users and API keys, in one centralized system.
Wilson Rivera
The Future of Federation: Replacing GraphQL Subgraphs with gRPC Services
Why WunderGraph is moving Federation beyond GraphQL Subgraphs to enable simpler, faster, type-safe APIs using gRPC under the hood.
Jens Neuse
The Next Generation of GraphQL Federation Speaks gRPC
Implement GraphQL Federation with gRPC: compile Subgraph SDLs to type-safe services with built-in data loading and zero N+1 issues.
Jens Neuse
REST in Peace—Connectors Were Never the Right Supergraph Abstraction
Learn how we use LLMs to automate API integration with a single prompt—cutting implementation costs by 99%.
Jens Neuse
Scaling GraphQL Federation: Inside Cosmo’s Food Park
Explore GraphQL federation through the lens of a food truck park. A story-driven guide to core concepts, tradeoffs, and how federation helps systems scale.
Brendan Bondurant
We accidentally built a backend framework for LLMs
While simplifying API orchestration, we accidentally built a backend framework for LLMs—powered by Cosmo Plugins and GraphQL Federation.
Jens Neuse
From Interview Task to Production Feature
The story of how an interview assignment turned into a real feature and became my first open-source contribution to Cosmo.
Akshay Garg
When to Migrate from Cosmo OSS
Cosmo OSS is a great way to start. But when scale, governance, and compliance become blockers, here’s how to know it’s time to move to Cosmo Enterprise.
Brendan Bondurant
Golang sync.WaitGroup: Powerful, but tricky
Learn how to use Go’s sync.WaitGroup correctly with real-world examples, common mistakes, and performance tips. Avoid deadlocks, leaks, and master goroutine management.
Jens Neuse
Why AI Needs A Common Language
Discover how AI systems need structured protocols for effective collaboration. Learn about Model Context Protocol (MCP), agent-to-agent communication, and why natural language alone will not scale for AI interactions. Essential reading for AI developers and API architects.
Cameron Sechrist
Rethinking API Access in the Age of AI Agents
Traditional rate limiting doesn’t protect against misuse by AI agents. Discover how harm limiting offers a new, proactive approach to secure API access.
Cameron Sechrist
The Impact of MCP and LLMs on Software Development - A Practical Example
See how Model Context Protocol enables LLMs to complete real dev tasks like schema exploration, query generation, and router config—all in a single prompt.
Jens Neuse
Cosmo MCP: Agent Mode now handles all the boring parts of GraphQL Federation (Right in your IDE)
Use Cosmo MCP with Cursor, Windsurf, or VSCode to automate schema changes, query validation, and router config—right from your IDE, no CLI juggling required.
Jens Neuse
Query Plan Regression Testing in GraphQL Federation
Discover how we built automated quality checks for GraphQL Federation that catch breaking changes before they hit production. Learn about our query plan testing tools and GitHub workflows that help maintain reliability at scale.
Alessandro Pagnin
Golang Sync.Pool | Memory Pool Example
Understand how Go’s sync.Pool affects memory usage in high-throughput systems. Learn when pooling helps, when it hurts, and how to use it safely for performance optimization.
Jens Neuse
Why we couldn't resist raising from eBay - our Series A announcement
From near shutdown to strategic investment by eBay, this is how WunderGraph’s open-source GraphQL Federation platform became the future of enterprise APIs.
Jens Neuse
AI-Assisted Coding: A Catalyst for Hiring Great Devs
When a candidate uses AI tools in a hiring assignment, and how that helps employers distinguish between those who know how to code and those who are pretending.
Björn Schwenzer
Syncing Up in Bretten: Final Thoughts
The WunderGraph team gets together in Bretten, Germany to work together.
Brendan Bondurant
@inaccessible Keys in Federated GraphQL APIs - A Deep Dive
The @inaccessible directive in GraphQL Federation allows you to hide keys from the public and manage sensitive data access in your federated GraphQL API.
Jens Neuse
Syncing Up in Bretten: Day 1
The WunderGraph team gets together in Bretten, Germany to work together.
Brendan Bondurant
Insights from the Community: State of Federation 2024
Discover why teams choose GraphQL Federation with Cosmo. See real-world insights on modernization, performance, and security at scale.
Stefan Avram
Safeguarding APIs: How K Health Ensures Security While Scaling with Cosmo
K Health streamlined its API architecture with GraphQL Federation and Cosmo, enhancing security, scalability, and collaboration across teams.
Brendan Bondurant
SoundCloud and WunderGraph Cosmo Cut Computing Costs by 86%
How the team at SoundCloud saved 86% on infrastructure costs for their GraphQL Federation deployment by moving to WunderGraph Cosmo.
Brendan Bondurant
GraphQL Federation Architecture: Open/Closed Principle & Project-Based SuperGraphs
Learn how GraphQL Federation enables the Open/Closed Principle in API design. Discover SuperGraphs, subgraph reuse, and why REST struggles with extensibility.
Jens Neuse
Supergraph Kickoff: Scaling Your Federated GraphQL for the Super Bowl
Discover how to prep your GraphQL Federation for Super Bowl-scale traffic with Cosmo Router’s cache warm-up strategy and tips to eliminate cold starts.
Jens Neuse
Introducing the @configureDescription directive for GraphQL Federation
Fine-tune GraphQL Federation schema composition with @openfed__configureDescription. Control which descriptions appear—and which do not.
David Stutt
Scaling GraphQL Schema Usage to billions of requests per day
See how Cosmo’s cloud architecture scales GraphQL observability with Kafka, ClickHouse & regional load balancing for enterprise reliability.
Dustin Deus
From Custom Code to Cutting-Edge: On The Beach Adopts WunderGraph Cosmo for GraphQL Federation
UK travel giant On The Beach replaced their custom GraphQL Federation with WunderGraph Cosmo, improving performance, observability, and developer velocity.
Stefan Avram & Brendan Bondurant
How Normalization affects Query Plan Caching in GraphQL Federation
Explore how normalization boosts query plan cache hits in GraphQL Federation. Learn about three normalization forms and how they improve performance and analytics.
Jens Neuse & Sergiy Petrunin
Is gRPC Really Better for Microservices Than GraphQL?
Compare gRPC and GraphQL for microservices. Exploring strengths, weaknesses, and when to use each for performance, flexibility, and real-time needs
Brendan Bondurant
Expr Lang: Go centric expression language for dynamic configurations
Learn how Cosmo Router uses Expr Lang to power flexible, secure GraphQL configuration without code changes. Explore realf use cases like rate limiting and migrations.
Jens Neuse
Are Connectors the path forward for GraphQL Federation?
Are connectors the right choice for GraphQL Federation? This deep dive explores their pros, cons, and impact on performance, testing, and schema design.
Jens Neuse
I was wrong about GraphQL
After 6 years building GraphQL tools, I’m revisiting past opinions to reflect on how experience has reshaped my views on APIs, federation, and tooling.
Jens Neuse
A Comprehensive Overview of GraphQL Federation in Open Source
Explore GraphQL Federation in open source—how it enables modular APIs with Subgraphs, boosts dev velocity, and scales API infrastructure.
Stefan Avram
How to align Open Source and Enterprise Sales
Learn how WunderGraph aligns Open Source and Enterprise Sales without feature-gating. Balancing community trust and commercial success the right way.
Jens Neuse
Live from the GraphQL Conf: The State of Distributed GraphQL 2024
Learn about the state of distributed GraphQL in 2024 and explore some of the exciting developments that are happening in this space. This is an update on GraphQL Federation, the work of the GraphQL Foundation, and the Composite Schema Working Group.
Jens Neuse
SOC2 Type II is a wrap
WunderGraph Cosmo is now fully certified under SOC2 Type II. Why it matters, what we learned, and what is next on the security roadmap.
Björn Schwenzer
Zero-Cost Abstractions for @skip and @include in Federated GraphQL
Using @skip and @include in GraphQL federation can hurt performance—learn how Cosmo Router's zero-cost abstraction removes overhead and boosts speed.
Jens Neuse
Graph Feature Flags: Fast and Safe GraphQL Federation Schema Evolution
Learn how Graph Feature Flags in Cosmo enable safe schema evolution and gradual rollouts in GraphQL Federation. Test features and ship faster with full control.
Jens Neuse
99% Smaller GraphQL Queries with AST Minification
Speed up GraphQL Federation by 25% with AST Minification. Learn how Cosmo Router generates smaller queries and outperforms Apollo in Subgraph execution.
Jens Neuse
Designing a Multi-Tenant Federated GraphQL Schema
Designing a multi-tenant federated GraphQL schema is a challenge. Let's explore the different approaches to multi-tenancy in a federated GraphQL API.
Jens Neuse
Cosmo OSS Schema Registry Compatibility Mode for Apollo Router and Gateway
Run Apollo Router or Gateway with Cosmo OSS as your open-source schema registry. Fully compatible with Apollo Federation and ideal for gradual migration.
Jens Neuse
SSO Just Got Better: OpenID Connect + SCIM for Identity Management
Learn how combining SCIM and OpenID Connect upgrades your SSO. Automate user provisioning, boost security, and streamline identity management at scale.
Jens Neuse
Distributed GraphQL Subscriptions with NATS and Event Driven Architecture
Learn how to leverage NATS and Event Driven Architecture to build distributed GraphQL Subscriptions.
Jens Neuse
When to use GraphQL vs Federation vs tRPC vs REST vs gRPC vs AsyncAPI vs WebHooks - A 2024 Comparison
Jens Neuse
Exploring 2.5 Reasons People Embrace GraphQL in 2024, and the Caveats Behind Its Non-Adoption
Jens Neuse
So now Cosmo is secure - officially
Why security matters, and why getting audited on SOC 2 is not rocket science.
Björn Schwenzer
How PemPem Accelerates Product Development with a Custom GraphQL Federation Approach
PemPem scaled faster by migrating to Cosmo—gaining GraphQL Federation, endpoint control, and full observability in a single, secure router.
Stefan Avram
Implementing the Viewer Pattern in Federated GraphQL APIs
The Viewer Pattern is a popular way to model GraphQL APIs around a 'viewer'. This article explains how the pattern can be implemented and what benefits it brings for federated GraphQL APIs.
Jens Neuse
Rate Limiting GraphQL Federation with Cosmo Router & Redis
Learn how to protect your federated GraphQL API from abuse and DDoS attacks by implementing effective, centralized rate limiting with Cosmo Router and Redis.
Jens Neuse
How TravelPass Group manages PCI compliance with GraphQL and WunderGraph Cosmo
Discover how TravelPass Group ensures PCI compliance and secure GraphQL usage at scale with WunderGraph Cosmo’s self-hosted router and namespace filtering.
Stefan Avram
Why SoundtrackYourBrand Switched From Apollo to Cosmo
Soundtrack Your Brand migrated from Apollo to Cosmo in a day—boosting performance, federation flexibility, and developer productivity.
Stefan Avram
Why you should avoid exhaustive switch case in API clients
Avoid exhaustive switch cases in API clients — they break forward compatibility and reveal deeper API design flaws you might miss.
Jens Neuse
Announcing Field Level Authorization for GraphQL Federation with Cosmo Router
Jens Neuse
Effective Integration Testing for Distributed Systems: Mastering Cosmo Router with GraphQL Federation
Discover the art of integration testing for distributed systems through our in-depth guide. Learn how to expertly test the Cosmo Router using advanced techniques in GraphQL Federation, including the utilization of subgraphs and subscriptions, to ensure seamless end-to-end functionality, correctness and superior system performance.
Jens Neuse
Serverless GraphQL Federation Router for AWS Lambda
Deploy GraphQL Federation on AWS Lambda with Cosmo’s serverless router. Small, fast, OpenTelemetry-ready, and built for real-world performance.
Dustin Deus
Scaling GraphQL Subscriptions in Go with Epoll and Event Driven Architecture
Learn how we're leveraging Epoll/Kqueue and Event-Driven Architecture to scale GraphQL Subscriptions in Go. We've reduced the number of goroutines by 99% and the memory consumption by 90% without sacrificing performance.
Jens Neuse
Announcing EDFS - Event Driven Federated Subscriptions
Event Driven Federated Subscriptions or EDFS for short is a new way to build federated GraphQL Subscriptions. It is based on the Event Driven Architecture (EDA) pattern and allows you to build highly scalable Event-Driven GraphQL APIs on top of Kafka, NATS, SQS, RabbitMQ and more.
Jens Neuse
Native Subscriptions with Cosmo Router
How an event-based approach makes GraphQL Subscriptions better in Federation.
Prithwish Nath
GraphQL Federation Field-level Metrics 101
Explore how field-level metrics in federated GraphQL help debug faster, cut costs, and optimize APIs. See how Cosmo makes data-driven scaling effortless.
Prithwish Nath
GraphQL is Finally Boring.
The reports of GraphQL’s death have been greatly exaggerated. Let’s look beyond trends, instead, at how a mature, reliable GraphQL is making organizations better.
Prithwish Nath
Introducing astjson: Transform and Merge JSON Objects with Unmatched Speed in Go
Jens Neuse
A C-Level Introduction to API Composition
As the number of APIs keeps growing and headless services are on the rise, understanding APIs and API Composition has become a necessity for decision makers in almost any industry.
Björn Schwenzer
How Cosmo meets Compliance Requirements and Saves Onboarding Time
By being capable of runnung fully on-prem, Cosmo avoids time-consuming due diligence loops and allows for quick implementation of GraphQL Federation.
Björn Schwenzer
Transitioning from Monolithic to Federated Architecture with GraphQL
Explore the shift from monoliths to Federated GraphQL. Learn how modular APIs boost scalability, dev speed, and flexibility—plus tips for a smooth migration.
Stefan Avram
How to analyze the usage of your GraphQL Schema
Learn how to analyze GraphQL schema usage to optimize APIs, prevent breaking changes, and improve observability with federation-aware analytics.
Jens Neuse
How to analyze the usage of your GraphQL Schema
Get deep insights into GraphQL schema usage. Identify unused fields, monitor client behavior, and enable safe, data-driven schema evolution.
Jens Neuse
A Open Source Schema Registry with Schema Checks for Federated GraphQL
With Cosmo, it’s easier than ever to manage your federated GraphQL schemas and prevent composition errors and breaking changes before they reach production.
Prithwish Nath
An Introduction to Cosmo Router — Blazingly Fast Open-Source Federation V1/V2 Gateway
Apollo Router’s Elastic license preventing adoption? Want to go even faster? This open-source Federation gateway has got you covered.
Prithwish Nath
Dataloader 3.0: A new algorithm to solve the N+1 Problem
Introducing a new algorithm to solve GraphQL’s N+1 problem. Learn how breadth-first data loading cuts complexity and boosts performance up to 5x.
Jens Neuse
OSS Analytics, Monitoring, and Tracing for Federated GraphQL APIs
WunderGraph announces the Cosmo Analytics Stack to provide Analytics, Metrics, Monitoring, and Distributed Tracing for Federated GraphQL APIs.
Jens Neuse
Cosmo Router: High Performance Federation v1 & v2 Router / Gateway
WunderGraph announces the Cosmo Router, a high performance GraphQL API Gateway / Router compatible with Apollo Federation v1 and v2.
Jens Neuse
Announcing Open Federation
WunderGraph announces Open Federation, a MIT-Licensed Specification and a set of libraries to build federated GraphQL APIs.
Jens Neuse
Refactoring Monoliths to Microservices with the BFF and Strangler Patterns
Refactor monoliths to microservices with the BFF & Strangler patterns. Avoid adapter hell and shield frontends using WunderGraphs unified BFF layer.
Prithwish Nath
5 Best Practices for Backends-for-Frontends
Best practices to follow when implementing the BFF pattern: do’s and don’ts
Prithwish Nath
7 Key Lessons I Learned While Building Backends-for-Frontends
Crucial takeaways from building production-ready BFFs that every developer should know.
Prithwish Nath
Using invisible divs in GitHub Discussions as a key-value store
Introducing Open Previews and how we built it without a database.
Eelco Wiersma
Return JSON from OpenAI to build AI enhanced APIs
Build AI-enhanced APIs with OpenAI that return structured JSON. Automate schema validation and OpenAPI docs using the WunderGraph Agent SDK.
Jens Neuse
Preventing prompt injections with Honeypot functions
Learn how Honeypot functions help prevent prompt injection attacks in AI-powered APIs built with OpenAI.
Jens Neuse
Beyond Functions: Seamlessly build AI enhanced APIs with OpenAI
Create structured, AI-powered APIs and Agents that integrate with REST, GraphQL, SOAP, and databases—securely, scalably, and without prompt injection risks.
Jens Neuse
TypeSafe Testing in Backends-for-Frontends
Struggling with integration, unit & E2E tests in your BFF? WunderGraph’s type-safe testing & mocking makes API testing easier.
Prithwish Nath
From 26 Minutes to 20 Seconds: Using pprof to optimize large GraphQL Operations in Go
How we reduced the executing time of a huge GraphQL operation using Golang's profiling tools
Alberto García Hierro
Fixing the Backends-for-frontends pattern with Build-time GraphQL
Fix the BFF pattern’s limitations using build-time GraphQL. WunderGraph delivers secure, fast, type-safe APIs—without runtime GraphQL overhead
Prithwish Nath
Apollo Federation v2 compatible OSS licensed Gateway coming to WunderGraph
WunderGraph announces a partnership with YC-backed Tailor Technologies, Inc. to implement an Apollo Federation v2 compatible OSS licensed API Gateway.
Jens Neuse
The Easiest Way to Bake Auth Into Your Backend-for-Frontend with Clerk and WunderGraph
A true match made in heaven, learn how to implement authentication in your BFF architecture in minutes!.
Prithwish Nath
Here's the Universal API ORM for REST, SOAP and GraphQL and more
Call REST, GraphQL, SOAP, and SQL as if they were one API. The WunderGraph ORM gives you type-safe access to any source—without relying on SDKs.
Jens Neuse
GraphQL doesn't solve under & overfetching, Relay & WunderGraph does
Jens Neuse
Dodging the Vercel Tax
Get Vercel-level DX with Postgres, Redis & Blob—without the markup. Use WunderGraph, an open-source alternative to Vercel Storage with no vendor lock-in.
Prithwish Nath
Do you even test?
Easily write end-to-end tests for your API Gateway with mocks. Learn how WunderGraph makes testing integrations faster, safer, and more maintainable.
Dustin Deus
Why you should Relay give GraphQL another look
Explore how Relay and WunderGraph enable secure, fast, type-safe GraphQL apps with SSR, persisted queries, and no runtime API exposure.
Jens Neuse
5 Best Backend-for-Frontend Tools You Should Be Using
Discover 5 powerful Backend-for-Frontend tools—like WunderGraph, Istio, and AWS—to simplify API integration, auth, observability, and scaling.
Prithwish Nath
WunderGraph raises $3M in seed funding to build GitHub for APIs
Jens Neuse
Introducing the new Vue Query client
Introducing the new WunderGraph Vue Query client. Consume WunderGraph queries, mutations and subscriptions fully typesafe with Vue and Nuxt.
Eelco Wiersma
Introducing the new Svelte Query client
Introducing the new WunderGraph Svelte Query client. Consume WunderGraph queries, mutations and subscriptions fully typesafe with Svelte & SvelteKit.
Dani Akash
The Backend-for-Frontend pattern using NextJS A Step-by-Step Guide
Start with BFFs, scale to GraphQL Federation. Build secure, type-safe APIs in Next.js with WunderGraph as your Backend-for-Frontend layer.
Prithwish Nath
Lightning-fast API development with Neon and WunderGraph
Learn how to use the Neon integreation with WunderGraph to create fast APIs
Stefan Avram
How Not invented here kills innovation and 5 rules to avoid it
The not invented here syndrome is a serious threat to innovation and your business. Here are five rules to avoid it.
Björn Schwenzer
Is GraphQL dying? 2023 Trend Analysis of REST, GraphQL, OpenAPI, SOAP, gRPC and tRPC
Jens Neuse
WunderGraph Acquires Apollo GraphQL to Join Forces to Create the Ultimate GraphQL Solution: Graphzilla
WunderGraph’s Virtual Graph meets Apollo’s SuperGraph to form UberGraph — the most powerful GraphQL solution ever built.
Stefan Avram
Integration Testing for GraphQL APIs, type-safe, run locally and in CI
Write fast, type-safe integration tests for GraphQL and REST APIs using WunderGraph. Run tests locally or in CI with built-in support for federation and auth.
Jens Neuse
Embedding SQL into GraphQL without sacrificing type safety
Learn how to embed SQL in GraphQL without losing type safety. This guide shows how to rewrite operations at the gateway level using AST transformations.
Jens Neuse
10 GraphQL Developer Tools I Use To Make Building APIs Easier
Discover 10 GraphQL tools that streamline API development—from schema visualization to testing and performance. Build faster, debug better, and ship with ease.
Prithwish Nath
How to be the worst engineer on your team?
To what extent should we compare ourselves to others? How can we channel differences positively?
David Stutt
TypeScript First API Development: Never Write OpenAPI Specifications Again
Skip the manual OpenAPI work. With WunderGraph’s TypeScript-first approach, generate OpenAPI specs directly from your code—no annotations, no boilerplate.
Jens Neuse
Serverless CI with Podman, Firecracker, fly.io Machines, and temporal.io
This is the story of how we built the CI/CD system for WunderGraph Cloud. 13s builds on top of giants like fly.io Machines, Podman, and temporal.io.
Jens Neuse & Dustin Deus
TypeScript Made Easy
Learn TypeScript the fun way—build your first full stack Todo App with Next.js, Prisma & WunderGraph. End-to-end typesafety, zero boilerplate.
Prithwish Nath
The most important lesson I've had to learn as a technical founder
If you want to build a business, you have to stop being obsessed with technology and start to focus on the customer and their problems.
Jens Neuse
Building internal tools with WunderGraph and Interval
A guide that shows you how to build internal tools using WunderGraph and Interval.
Eelco Wiersma
How to escape the capacity trap of legacy architecture
Legacy systems draining your team? Learn how WunderGraph helps you break the cycle and reclaim capacity without a full rewrite.
Björn Schwenzer
GraphQL's @defer and @stream Directives are overkill
The GraphQL directives @defer and @stream are a great way to incrementally load data, but they are a complex solution that can be solved in a much simpler way.
Jens Neuse
Introducing the new Solid Query client
Introducing the new WunderGraph Solid Query client. Consume WunderGraph queries, mutations and subscriptions fully typesafe with Solid.js.
Eelco Wiersma
A comprehensive Guide to WunderGraph and WunderGraph Cloud
A comprehensive guide to WunderGraph, the API Gateway that turns GraphQL into RPC on the fly, with a focus on its TypeScript Operations
Prithwish Nath
Isomorphic TypeScript APIs: End-to-end type-safety between client & server
Blur the lines between frontend and backend with isomorphic TypeScript APIs. Get instant type-safe feedback for faster full-stack development—no codegen needed.
Jens Neuse
Build a Serverless Live Chat App with Next.js, Fauna & WunderGraph
Learn to build a real-time serverless chat app using WunderGraph’s Live Queries, Next.js, and Fauna—no WebSockets needed, just scalable GraphQL.
Prithwish Nath
Building WunderGraph
The people of WunderGraph discuss a variety of aspects of running a start-up in short, unedited video episodes.
Björn Schwenzer
How to turn employee resignations into a growth opportunity for your company
Discover how employee resignations can spark meaningful growth. Learn to gather feedback, drive change, and improve retention with honest reflection.
Björn Schwenzer
Data Fetching with Next.js 13’s Bleeding-Edge Features
Explore data fetching with Next.js 13 using Streaming and Suspense. Build a record catalog app with GraphQL and WunderGraph for seamless end-to-end typesafety.
Prithwish Nath
Introducing the new React Query client
Introducing the new WunderGraph React Query client. Consume WunderGraph queries, mutations and subscriptions fully typesafe with React Query.
Eelco Wiersma
How to Use ChatGPT as an Educational Chatbot in a Next.js Frontend
Can you use OpenAI’s GPT-3.5 on your website as a chat assistant? You bet. Here’s how to get it done with an Express server, WunderGraph as a BFF, and GraphQL.
Prithwish Nath
Introducing the new Next.js and SWR clients
Introducing the new Next.js and SWR clients
Eelco Wiersma
The simplicity of tRPC with the power of GraphQL
tRPC is a new alternative to GraphQL that promises to be a lot simpler, but at what cost? What tradeoffs does it make? Let's find out!
Jens Neuse
Why going API first will boost your business
Adopting an API first approach and exposing commoditized services is essential to participate in the emerging API Economy.
Björn Schwenzer
How to Compose and Integrate APIs Together as if You Were Using NPM for APIs
Bring React-style composability to APIs, microservices & databases using GraphQL, WunderGraph, and the BFF/API Gateway pattern.
Prithwish Nath
How to Build a GraphQL eCommerce App from Scratch
Setting JAMstack to easy mode with WunderGraph, Next.js, Strapi, and Snipcart
Prithwish Nath
Quirks of GraphQL Subscriptions: SSE, WebSockets, Hasura, Apollo Federation / Supergraph
Jens Neuse & Yuri Buerov
GraphQL is not Terraform
GraphQL is used in many different ways. In this post, I'd like to show why GraphQL is not ideal as a configuration language.
Jens Neuse
The End of DevOps
How WunderGraph’s infraless platform returns simplicity to the developer experience.
Björn Schwenzer
Dev without Ops - Why we are building Vercel for Backend, the Infraless Cloud
Serverless isn't enough. Learn why we're building WunderGraph Cloud—a fully managed backend platform that redefines simplicity, speed, and developer experience.
Jens Neuse
Build flexible GraphQL APIs by treating the Schema like a Database
By treating your GraphQL API like a Database, you're able to build flexible and easy to maintain APIs, with the additional benefit of making them easy to audit.
Jens Neuse
WunderBase – Serverless GraphQL DB using SQLite, Firecracker & Prisma
WunderBase is an open source Serverless GraphQL database built on SQLite, Firecracker, and Prisma. Sleep mode saves cost—perfect for fast, lightweight apps.
Jens Neuse
4 ways to stitch, integrate, compose & federate multiple GraphQL APIs
Combining multiple GraphQL APIs can be a challenge. Learn about four different methods to solve the problem and the tradeoffs of each approach.
Jens Neuse
WunderGraph 🤝 Fauna Integration
WunderGraph and Fauna integration. Quickly integrate FaunaDB into your serverless applications using WunderGraph.
Stefan Avram
How to improve your markdown-based docs with automatic tagging
Help your readers to better understand your markdown-based docs by automatically tagging the content with cross-references to other parts of your documentation.
Jens Neuse
Building WunderGraph Cloud in public
Why WunderGraph builds its cloud solution in public and choses transparency over secrecy.
Björn Schwenzer
When hiring developers gets tough, focus on developer efficiency
When you have difficulties staffing your software engineering positions, consider leveraging the efficiency potential in your existing development teams.
Björn Schwenzer
Stop Building Your MVP Before You Figure Out These 7 Founder Lessons
Most technical founders overbuild and underplan. Learn 7 lessons to avoid wasted effort, from user acquisition to sales strategy, before coding your MVP.
jensneuse
WunderGraph - The Next-Gen API Developer Platform - is Open Source!
Learn more about how WunderHub, the first Package Manager for APIs, creates a whole new Experience of sharing and integrating APIs. We are currently in a public beta and are looking for feedback and ideas.
Jens Neuse
How WunderGraph helps Developers to compose & integrate APIs
Discover how WunderGraph streamlines API composition and integration with Gateway-Less API Management that fits modern developer workflows.
Jens Neuse
Open Source GraphQL CDN / Edge Cache with Cloudflare, Fastly, and Fly.io
WunderGraph's open-source approach to GraphQL CDN and edge caching works with Cloudflare, Fastly, Fly.io, and more—without vendor lock-in or complexity.
Jens Neuse & Dustin Deus
NextJS / React SSR: 21 Universal Data Fetching Patterns & Best Practices
21 Universal Data Fetching Patterns & Best Practices for NextJS / React SSR
Jens Neuse
GraphQL Subscriptions: Why we use SSE/Fetch over Websockets
WebSockets should be deprecated for GraphQL Subscriptions. Instead, we're proposing to use Server Sent Events.
Jens Neuse
Partnership Announcement: Oracle Cloud and WunderGraph
WunderGraph and Oracle Cloud team up to deliver 90% faster API integrations and seamless Kubernetes hosting for modern, scalable app development.
Stefan Avram
API Design Best Practices for long-running Operations: GraphQL vs REST
Discover how to design asynchronous APIs for long-running operations using REST or GraphQL. Learn trade-offs, patterns, and best practices for robust API workflows.
Jens Neuse
Keycloak Integration in Minutes with Cloud IAM and WunderGraph
Integrate Keycloak with WunderGraph in under 10 minutes using Cloud IAM. Boost security, simplify setup, and speed up auth workflows with this step-by-step guide.
Stefan Avram
Thunk-based Resolvers: Building a Flexible GraphQL API Gateway
Learn how thunk-based resolvers enable modular, schema-free GraphQL Gateways. Boost flexibility, performance, and support for REST, federation, and subscriptions.
Jens Neuse
10x faster implementation time for your API with WunderHub
Cut API implementation time by 90% with WunderHub—search, integrate, and scale APIs instantly. Boost user time-to-value and grow adoption.
Karl Baumbarten
WunderGraph 🤝 MongoDB Atlas
We're super excited to introduce our latest integration with MongoDB Atlas – MongoDB’s multi-cloud application data platform.
Stefan Avram
How to market your product as a Technical Founder
How WunderGraph’s founders grew their user base through hands-on marketing—from cold outreach to content and community—in just 6 months.
Stefan Avram
WunderHub - The Package Manager for APIs Public Beta
Try WunderHub, the first API package manager. Share, discover & integrate APIs faster. Now in public beta — feedback welcome!
Jens Neuse
What every GraphQL user should know about HTTP and REST
Stop choosing between GraphQL and REST. Combine their strengths to build more flexible, powerful APIs with the best of both worlds.
Jens Neuse
How automating API Integrations benefits your business
Automate API integrations with WunderGraph to save developer time, cut costs, and boost efficiency across your software ecosystem.
Karl Baumbarten
Join data across APIs: GraphQL, REST, PostgreSQL, MySQL and more
Learn how to join data across GraphQL, REST, PostgreSQL, MySQL, and more using a single GraphQL operation—no stitching or federation required.
Jens Neuse
Announcing WunderHub: Share APIs like they were npm packages
Today, we announce WunderHub, a tool to share APIs just like npm packages. WunderHub enables API developers and consumers to collaborate at a whole new level.
Jens Neuse
Namespacing for GraphQL: Conflict-Free merging of any number of APIs
WunderGraph introduces the concept of Namespacing to GraphQL, allowing you to merge any number of APIs without naming conflicts.
Jens Neuse
Instant Realtime APIs using PostgreSQL, MySQL, SQLite, SQLServer and Planetscale
WunderGraph now supports PostgreSQL, MySQL, SQLite, SQLServer and Planetscale as DataSources to generate a production-ready Realtime API in Minutes
Jens Neuse
API Management does too little, Backend as a Service does too much
Explore the limitations of API Management and Backend as a Service, and how WunderGraph bridges the gap to offer extensibility, type safety, and zero vendor lock-in.
Jens Neuse
Benchmark: Apollo Federation Gateway v1 vs v2 vs WunderGraph vs mercurius-js
Benchmarks of the Apollo Federation Gateway v1 and v2 vs. WunderGraph show that WunderGraph is up to 271 times faster than Apollo.
Jens Neuse
GraphQL file uploads - evaluating the 5 most common approaches
Explore 5 ways to handle file uploads in GraphQL—from base64 to S3 and WunderGraph’s TokenHandler Pattern. See which approach balances speed and security..
Jens Neuse
GraphQL in production - Analyzing public GraphQL APIs #1: Twitch.tv
Explore how Twitch runs GraphQL in production. From batching to APQ, HTTP quirks, and performance trade-offs—learn what works and what to avoid at scale.
Jens Neuse
Build JSON APIs with JSON-Schema by writing GraphQL Operations against any DataSource like REST, GraphQL, Apollo Federation, PostgreSQL and MySQL
Learn how to build JSON APIs with JSON Schema validation by writing GraphQL Operations against any DataSource like GraphQL, REST, PostgreSQL or MySQL
Jens Neuse
The Fusion of GraphQL, REST, JSON-Schema and HTTP2
REST vs. GraphQL is the wrong question. Instead, combine the two! Making GraphQL more RESTful is the better solution than choosing one technology exclusively.
Jens Neuse
Versionless APIs - Making APIs backwards compatible FOREVER to enable businesses to collaborate
A visionary approach to solving API versioning problems one and for all, keeping APIs backwards compatible forever.
Jens Neuse
The complete GraphQL Security Guide: Fixing the 13 most common GraphQL Vulnerabilities to make your API production ready
A description of the 13 most common GraphQL vulnerabilities and how to mitigate them.
Jens Neuse
Solving the Double (Quintuple) Declaration Problem in GraphQL Apps
Stop repeating yourself across your stack. Learn how to eliminate redundant declarations in GraphQL apps using codegen, JSON Schema, and WunderGraph.
Jens Neuse
Authentication for NextJS with GraphQL & REST APIs and SSR (Server Side Rendering)
A discussion on NextJS, GraphQL and Authentication and how to get it right with SSR (Server Side Rendering)
Jens Neuse
Where in the HypeCycle is GraphQL in 2021? Analyzing public data from Google Trends, StackOverflow, GitHub and HackerNews
A review of public data from Google Trends, StackOverflow, GitHub and HackerNews to better understand if GraphQL is still a trending technology.
Jens Neuse
Apollo GraphQL Federation with Subscriptions - production grade and highly scalable
Learn how WunderGraph lets you get the most out of Apollo Federation, being the only provider with a Gateway that supports Subscriptions for SubGraphs.
Jens Neuse
Polyglot persistence for PostgreSQL & MySQL using GraphQL & TypeScript
Storing data in either PostgreSQL or MySQL using the exact same interface, a GraphQL API
Jens Neuse
What if we treat GraphQL Queries as the API definition?
Explore a powerful pattern where GraphQL operations define your API, enabling type-safe clients, input validation, and secure auth—all from your queries.
Jens Neuse
The most powerful GraphQL Client for the web in just 2kb
WunderGraph offers the most powerful GraphQL client for the web in just 2.5kb. Outperforms Apollo & urql in speed, DX, and security—without the bloat.
Jens Neuse
Why you need a Package Manager for APIs
Packager Managers are Common for storing and sharing code. This post describes how we can apply the same pattern to APIs as well.
Jens Neuse
Generated GraphQL APIs: Tight Coupling as a Service
A discussion on the problems related to generating GraphQL APIs from a Database Schema, like tight coupling the client to the server.
Jens Neuse
Why not use GraphQL?
Analyzing common misconceptions on the discussion around GraphQL vs. REST.
Jens Neuse
GraphQL is not meant to be exposed over the internet
A discussion about the problems with using GraphQL over HTTP POST requests and how to improve the situation with a JSON RPC facade.
Jens Neuse
The case against normalized caching in GraphQL
A discussion on the topic of normalized caching in GraphQL Clients, why it's inefficient and how better solutions could look like
Jens Neuse
