Blog

Distributed GraphQL Subscriptions with NATS and Event Driven Architecture

Learn how to leverage NATS and Event Driven Architecture to build distributed GraphQL Subscriptions.

When to use GraphQL vs Federation vs tRPC vs REST vs gRPC vs AsyncAPI vs WebHooks - A 2024 Comparison

Exploring 2.5 Reasons People Embrace GraphQL in 2024, and the Caveats Behind Its Non-Adoption

So now Cosmo is secure - officially

Why security matters, and why getting audited on SOC 2 is not rocket science.

How PemPem is harnessing the power of federation with a customized approach to accelerate product development at scale

This case study explores how Jose, a senior developer at PemPem and his team were able to migrate away from Hasura to Cosmo, while solving issues with scaling and observability across their clients with Cosmo and GraphQL Federation

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.

Rate Limiting for Federated GraphQL APIs with Cosmo Router & Redis

GraphQL Federation is a powerful solution for building scalable APIs, but it also opens up an attack vector for DDoS attacks right into your Microservices architecture. In this article, we will explore how to implement rate limiting for federated GraphQL APIs using Cosmo Router and Redis.

How Travelpassgroup.com manages PCI compliance with GraphQL and WunderGraph Cosmo

In this case study, we delve into how Travelpassgroup.com, under the guidance of Team Lead Tyler Hawkins, ensures PCI compliance through their innovative use of GraphQL and WunderGraph Cosmo. This transformation has revolutionized how they handle secure transactions, providing enhanced security and improved efficiency.

Why SoundtrackYourBrand Switched From Apollo to Cosmo

This case study explores how Fredrik, the Vice President of Engineering at Soundtrack your Brand and his team were able to migrate away from Apollo GraphOS in a day, while noticing improvements in performance, smarter query planning, and productivity in Cosmos Studio.

Why you should avoid exhaustive switch case in API clients

Exhaustive switch case in API clients should be avoided as it prevents your client from being forward compatible. In addition, this problem highlights three hidden problems when it comes to designing APIs. You might be breaking clients although you're confident that your changes are backward compatible.

Announcing Field Level Authorization for GraphQL Federation with Cosmo Router

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.

Serverless GraphQL Federation Router for AWS Lambda

Discover the first-ever Serverless GraphQL Federation Router for AWS Lambda by Dustin Deus. Learn about its event-driven architecture, OpenTelemetry support, performance insights, and easy deployment steps in this comprehensive blog post.

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.

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.

Native Subscriptions with Cosmo Router

How an event-based approach makes GraphQL Subscriptions better in Federation.

GraphQL Federation Field-level Metrics 101

Making data-driven decisions for evolving your enterprise’s graphs, via field usage metrics..

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.

Introducing astjson: Transform and Merge JSON Objects with Unmatched Speed in Go

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.

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.

Embracing the Future: Transitioning from Monolithic to Federated Architecture with GraphQL

Explore the transformative journey from monolithic to federated architecture in software development, emphasizing the integration of GraphQL and the role of tools like Cosmo from WunderGraph. This insightful post delves into the benefits, challenges, and real-world applications of this paradigm shift, offering a comprehensive guide for developers and organizations looking to enhance scalability, flexibility, and efficiency in their systems.

How to analyze the usage of your GraphQL Schema

You might want to get insights into how your GraphQL Schema is being used, not just to optimize your Schema, but also to not break existing clients. In this article, we'll show you how to analyze the usage of your GraphQL Schema.

How to analyze the usage of your GraphQL Schema

You might want to get insights into how your GraphQL Schema is being used, not just to optimize your Schema, but also to not break existing clients. In this article, we'll show you how to analyze the usage of your GraphQL Schema.

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.

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.

Dataloader 3.0: A new algorithm to solve the N+1 Problem

We present a new algorithm to solve the N+1 Problem in GraphQL that's much more efficient and easier to maintain than current solutions. By resolving breadth-first instead of depth-first, we can reduce concurrency from O(N^2) to O(1) and improve performance by up to 5x while reducing code complexity.

OSS Composition library for GraphQL Federation v1 & v2 in TypeScript, NodeJS and Golang

Today we're announcing our Composition library for Federation v1 and v2. Compose Subgraphs in TypeScript, NodeJS and Golang and get Composition validation errors.

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.

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.

Cosmo: An Open Source Alternative to Apollo Federation & GraphOS

WunderGraph announces Cosmo, an open source alternative to Apollo Federation and GraphOS.

Announcing Open Federation

WunderGraph announces Open Federation, a MIT-Licensed Specification and a set of libraries to build federated GraphQL APIs.

Refactoring Monoliths to Microservices with the BFF and Strangler Patterns

How do you effectively migrate away from monoliths without getting stuck in Adapter Hell? Let’s talk about the synergy between BFFs and the Strangler pattern, featuring WunderGraph.

5 Best Practices for Backends-for-Frontends

Best practices to follow when implementing the BFF pattern: do’s and don’ts

7 Key Lessons I Learned While Building Backends-for-Frontends

Crucial takeaways from building production-ready BFFs that every developer should know.

Using invisible divs in GitHub Discussions as a key-value store

Introducing Open Previews and how we built it without a database.

Return JSON from OpenAI to build AI enhanced APIs

When building APIs on top of OpenAI, you're usually getting plain text back. In this article we're going to show you how to return structured data (JSON) from OpenAI to build AI enhanced APIs.

Preventing prompt injections with Honeypot functions

OpenAI recently added a new feature (Functions) to their API, allowing you to add custom functions to the context. While super powerful, this feature also comes with a security risk. In this article, we'll explore how to mitigate this risk with Honeypot functions.

Beyond Functions: Seamlessly build AI enhanced APIs with OpenAI

Announcing the WunderGraph OpenAI integration / Agent SDK to simplifly the creation of OpenAI enhanced APIs and AI Agents for Systems Integration on Autopilot, making it easy to build AI Agents to interact with your existing REST, GraphQL, SOAP APIs and databases.

TypeSafe Testing in Backends-for-Frontends

Integration, Unit, and E2E testing aren’t mutually exclusive, but they sure are a pain to implement in a BFF system. Could WunderGraph’s type-safe testing and mocking library make this easier?

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

Fixing the Backends-for-frontends pattern with Build-time GraphQL

The BFF pattern optimizes backends for specific client interfaces. Using GraphQL for it fixes some of its drawbacks, but can we do better? Let’s find out with WunderGraph.

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.

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!.

Here's the Universal API ORM for REST, SOAP and GraphQL and more

The universal API ORM allows you to interact with distributed systems as if they were a monolith. Call into REST, SOAP, GraphQL, SQL, and more with a single API. The TypeScript ORM gives you type-safe access to all your data sources.

GraphQL doesn't solve under & overfetching, Relay & WunderGraph does

Dodging the Vercel Tax

Find out how to get the same DX wins of Vercel Storage by using its Postgres, Redis, and Blob providers with Wundergraph – a free and open-source technology without the Vercel markup, and without vendor lock-in to boot.

Do you even test?

Taking End-to-end Tests with Mocks for API Gateways to the next level. Testing is an important part of any software development process. At WunderGraph, we believe that testing should be easy and fun. That's why we've built a testing library that makes it easy to write tests for your WunderGraph applications.

Why you should Relay give GraphQL another look

Relay is a game-changer for GraphQL once you get behind the initial learning curve. We've made it 100x easier to use and adopt. In this post, I will explain why you should give the data fetching client another look.

5 Best Backend-for-Frontend Tools You Should Be Using

The Backends-for-Frontends pattern might be exactly what you need to avoid monolithic Backend APIs and Frontends bloated with business logic. Let’s implement one in Next.js, using WunderGraph as a BFF framework.

WunderGraph raises $3M in seed funding to build GitHub for APIs

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.

Introducing the new Svelte Query client

Introducing the new WunderGraph Svelte Query client. Consume WunderGraph queries, mutations and subscriptions fully typesafe with Svelte & SvelteKit.

The Backend-for-Frontend pattern using NextJS A Step-by-Step Guide

The Backends-for-Frontends pattern might be exactly what you need to avoid monolithic Backend APIs and Frontends bloated with business logic. Let’s implement one in Next.js, using WunderGraph as a BFF framework.

Lightning-fast API development with Neon and WunderGraph

Learn how to use the Neon integreation with WunderGraph to create fast APIs

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.

Is GraphQL dying? 2023 Trend Analysis of REST, GraphQL, OpenAPI, SOAP, gRPC and tRPC

WunderGraph Acquires Apollo GraphQL to Join Forces to Create the Ultimate GraphQL Solution: Graphzilla

Yes, you read that right! Two of the biggest names in the graphQL industry are teaming up to bring you the UberGraph - the most epic, powerful, and awe-inspiring GraphQL solution the universe has ever seen. We're talking about combining WunderGraph's Virtual Graph with Apollo GraphQL's SuperGraph, people! You're not ready for this

Integration Testing for GraphQL APIs, type-safe, run locally and in CI

Testing GraphQL APIs requires a lot of boilerplate code to be productive. We've built a testing framework that makes it easy to write type-safe integration tests for GraphQL & REST APIs locally and in CI.

Embedding SQL into GraphQL without sacrificing type safety

Embedding SQL into GraphQL sounds like a bad idea, but it's actually a great way to easily build a powerful API on top of your database. This article teaches you how to implement a GraphQL Gateway that dynamically rewrites GraphQL Operations to be able to embed SQL into GraphQL without sacrificing type safety.

10 GraphQL Developer Tools I Use To Make Building APIs Easier

Discover the best GraphQL Dev Tools that can help you streamline your development workflow. From full stack development, to schema visualization, to performance monitoring, these tools have got you covered.

How to be the worst engineer on your team?

To what extent should we compare ourselves to others? How can we channel differences positively?

TypeScript First API Development: Never Write OpenAPI Specifications Again

The TypeScript First workflow shows how you can leverage the TypeScript compiler to never write OpenAPI specifications again. Just write your API in TypeScript and let the compiler do the work for you.

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.

TypeScript Made Easy

It’s time to put your fears aside and finally learn TypeScript. Let’s give you your first “Eureka!” moment by building a full stack Todo App with end-to-end typesafety

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.

Building internal tools with WunderGraph and Interval

A guide that shows you how to build internal tools using WunderGraph and Interval.

How to escape the capacity trap of legacy architecture

Many companies are so overloaded with their legacy stack that they are unable to consider options to remedy this. It is worth taking a step back and consider your options, such as WunderGraph.

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.

Introducing the new Solid Query client

Introducing the new WunderGraph Solid Query client. Consume WunderGraph queries, mutations and subscriptions fully typesafe with Solid.js.

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

Isomorphic TypeScript APIs: End-to-end type-safety between client & server

Isomophic TypeScript APIs blur the lines between client and server, creating a whole new developer experience with an immediate feedback loop for fast and safe full stack development.

Building A Serverless Live Chat App with Next.js, Fauna, and WunderGraph for GraphQL Live Queries

A Step-by-Step Guide to creating a Scalable, Real-time Chat App using Serverless technologies… with a little help from NextAuth.js for GitHub sign-ins. Who needs WebSockets when you’ve got Live Queries? Not us!

Building WunderGraph

The people of WunderGraph discuss a variety of aspects of running a start-up in short, unedited video episodes.

How to turn employee resignations into a growth opportunity for your company

When team members decide to move on, it’s actually a great opportunity to learn and improve – as long as you’re willing to be honest with yourself and accept uncomfortable truths.

Data Fetching with Next.js 13’s Bleeding-Edge Features

Data Fetching with Next.js 13's Bleeding-Edge Features. Let's build a record store catalog and discuss

Introducing the new React Query client

Introducing the new WunderGraph React Query client. Consume WunderGraph queries, mutations and subscriptions fully typesafe with React Query.

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.

Introducing the new Next.js and SWR clients

Introducing the new Next.js and SWR clients

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!

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.

How to Compose and Integrate APIs Together as if You Were Using NPM for APIs

Learn how to bring React’s paradigm of Composability to the world of APIs, microservices, and databases — powered by Wundergraph, build-time GraphQL, and the BFF/API Gateway pattern.

How to Build a GraphQL eCommerce App from Scratch

Setting JAMstack to easy mode with WunderGraph, Next.js, Strapi, and Snipcart

Quirks of GraphQL Subscriptions: SSE, WebSockets, Hasura, Apollo Federation / Supergraph

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.

The End of DevOps

How WunderGraph’s infraless platform returns simplicity to the developer experience.

Dev without Ops - Why we are building Vercel for Backend, the Infraless Cloud

It's about time that we simplify cloud native software development. Serverless was a great start, but it's time that we abstract away infrastructure completely. We will demonstrate our opinionated approach that can radically simplify the existing workflow of building software

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.

WunderBase - Serverless GraphQL Database on top of SQLite, Firecracker and Prisma

WunderBase is a Serverless Database with a GraphQL API on top of SQLite, Firecracker and Prisma. It's open source, sleeps when you don't use it and therefore extremely inexpensive.

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.

WunderGraph 🤝 Fauna Integration

WunderGraph and Fauna integration. Quickly integrate FaunaDB into your serverless applications using WunderGraph.

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.

Building WunderGraph Cloud in public

Why WunderGraph builds its cloud solution in public and choses transparency over secrecy.

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.

Stop building your MVP before figuring out 7 essential things: The Technical Founder #1

Building a startup as a technical founder is less about writing code and more about building a business. This post addresses some common pitfalls and how to avoid them.

WunderGraph - The Next Generation 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.

How WunderGraph helps Developers to compose & integrate APIs

What Problem does WunderGraph solve and how is it different from other solutions? Learn more about Gateway-Less API Management and how WunderGraph improves the Development Workflow.

Open Source GraphQL CDN / Edge Cache with Cloudflare, Fastly, and Fly.io

WunderGraph offers an Open Source Alternative to adding a GraphQL CDN / Edge Cache for your APIs that can leverage any Caching Service, like Cloudflare, fastly or even fly.io for Edge deployments.

NextJS / React SSR: 21 Universal Data Fetching Patterns & Best Practices

21 Universal Data Fetching Patterns & Best Practices for NextJS / React SSR

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.

Partnership Announcement: Oracle Cloud and WunderGraph

WunderGraph is extremely pleased to announce a partnership with Oracle Cloud that allows developers to build their next application with 90% faster integrations, to then host it easily on Oracle’s cloud.

API Design Best Practices for long-running Operations: GraphQL vs REST

I've recently read an article where the author stated that GraphQL is "not appropriate for long-running operations". I'd like to show that GraphQL can very well be used for long-running operations.

Keycloak Integration in Minutes with Cloud IAM and WunderGraph

We are very excited to announce our most recent partnership with Cloud IAM - the Keycloak Identity and Access Management as a Service solution used by 10,000+ developers.

Thunk-based Resolvers: How to build a powerful and flexible GraphQL Gateway

Building a GraphQL Gateway has special requirements. This post explains how you can leverage thunk-based Resolvers to build a powerful and flexible GraphQL Gateway.

10x faster implementation time for your API with WunderHub

Publishing your API on WunderHub will drastically reduce implementation time of your API and therefore boost your most important metric: time-to-value for your users.

WunderGraph 🤝 MongoDB Atlas

We're super excited to introduce our latest integration with MongoDB Atlas – MongoDB’s multi-cloud application data platform.

How to market your product as a Technical Founder

Marketing for a technical founder is a huge challenge for many startups This article explains how WunderGraph used a variety of techniques to grow our email list to 1000+ contacts, 200+ Discord members (who are actively participating), and 1–5 Sales calls a week in 6 months.

WunderHub - The Package Manager for APIs Public Beta

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.

What every GraphQL user should know about HTTP and REST

This article proposes an alternative way to think about GraphQL and REST. Instead of looking at the two as alternatives, we can use the advantages of both of them to create a better, more flexible and more powerful API.

How automating API Integrations benefits your business

API integrations is a huge challenge for many businesses. This article explains how WunderGraph can help you automate API integrations and make your business more efficient.

Join data across APIs: GraphQL, REST, PostgreSQL, MySQL and more

This post explains a novel way to join data across multiple APIs (GraphQL, REST, PostgreSQL, MySQL and more), using just a single GraphQL Operation and a few directives.

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.

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.

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

API Management does too little, Backend as a Service does too much

A comparison between Full Lifecycle API Management and Backend as a Service, outlining the pros and const of each approach, identifying the gaps between the two and proposing a solution.

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.

GraphQL: The hidden Champion of Postman's State of the API 2021

GraphQL shows strong growth, has the largest percentage of users who love it and is the only API Specification amongst future technologies that Developers are Excited about.

GraphQL file uploads - evaluating the 5 most common approaches

We're comparing the 5 most common approaches of uploading files with GraphQL APIs, using base64 encoding, Multipart uploads, a custom REST API, S3 or the TokenHandler Pattern.

GraphQL in production - Analyzing public GraphQL APIs #1: Twitch.tv

This is the first post of the series on GraphQL in production. We're analyzing the GraphQL API of twitch.tv, discussing the pros and cons and conclude with suggestions on how to run GraphQL in production.

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

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.

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.

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.

Solving the double (quintuple) declaration Problem in GraphQL Applications: How to not repeat yourself!

Most web applications suffer from the double declaration problem, defining type definitions in multiple places. This post discusses the problem and provides a solution.

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)

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.

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.

Polyglot persistence for PostgreSQL & MySQL using GraphQL & TypeScript

Storing data in either PostgreSQL or MySQL using the exact same interface, a GraphQL API

What happens if we treat GraphQL Queries as the API definition?

Most GraphQL users believe that the Schema is the API definition. This article describes a different approach, using the GraphQL Operations as the API definition.

The most powerful GraphQL Client for the web in just 2kb

Most GraphQL clients are bloated, slow and unnecessarily complex. We're discussing a simpler solution that is only 2.5kb small, fast, secure and highly performant.

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.

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.

Why not use GraphQL?

Analyzing common misconceptions on the discussion around GraphQL vs. REST.

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.

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