A weekly newsletter of the best news, articles and projects about GraphQL


GraphQL: Overlapping Fields Can Be Merged Fast

In this article, Simon Adameit, an engineer at XING, breaks down the algorithm he developed that significantly improves the runtime performance of the GraphQL validation Field Selection Merging. He showcases the improvements the algorithm provides when there are multiple fragments in the query. He also explains with runtime data how the algorithm works and how to implement it into the mainline.

What The Heck Is GraphQL?

This blog post includes a special podcast with 14 GraphQL experts from the community that offers an introduction to GraphQL and how the query language has evolved and grown in popularity. They discuss React Hooks, when not to use GraphQL, and the differences between GraphQL and REST. The post also provides a list of accessible resources that were mentioned throughout the podcast, like useful guides and playgrounds for learning/using GraphQL.


The Ultimate Guide to handling JWTs on frontend clients (GraphQL)

Learn how to handle authentication with Hasura as they demystify what a JSON Web Token is and discuss the best practices in setting up a GraphQL client to accept a JWT auth token. This article provides great insight on token usage, error handling, refresh tokens, and persistent sessions. References and sample code of an end to end working app with server side rendering capabilities are available at the end of the article.

Adopting GraphQL and Apollo in a Legacy Application

The development teams at Trello share their journey of modernizing their legacy architecture and incrementally adopting GraphQL, Apollo, React, and TypeScript. The blog explains the sizable benefits to adopting a GraphQL schema on the frontend and how to wrap an API with Apollo client. There are examples on translating a GraphQL query into a REST API request as well as writing local resolvers to fetch requested data from your REST API.


Using GraphQL to Improve Data Hydration in our Customer Care Platform and Beyond

The engineers at Uber share how GraphQL has significantly decreased the amount of code engineers have to write to add new features and has helped streamline development. Kunyao Liu describes the nature of using a service-oriented micro service architecture and the need for new data hydration tooling. Read more on Fusion.js and how Uber’s Customer Care Platform frontend connects with their GraphQL server.

Federated GraphQL Server at Scale: Zillow Rental Manager Real-time Chat Application

This blog discusses how Zillow utilized GraphQL to develop a central communication platform that provides in-app chat functionality for both renters and property owners. Akshar Takle breaks down the frontend and backend architecture and explains why a federated schema was the best solution for team independence and reusability.


How we learned to stop worrying and love GraphQL

Read more about why the engineers at Revolut adopted GraphQL and their journey from implementing GraphQL over their REST/RPC endpoints. Andrew Los details the issues GraphQL solves, such as typescript and stale API typings, and the migration from Redux to Apollo for the data layer.

Building Resilient GraphQL APIs Using Idempotency

This blog explains how Shopify built a new Payment Service that utilizes GraphQL and API idemopotency. The blog presents the difficulties with non-resilient payment services that could fail to complete a charge or even double-charge buyers. Todd Jefferson also dives into the team’s thought process on choosing API level idemopotency, the steps on GraphQL implementation, and some drawbacks of API idempotency.


How we manage live 1M GraphQL Websocket Subscriptions

Learn about how the folks at Hexact Inc. have been handling the live 1 million GraphQL web socket subscriptions on Google Cloud Kubernetes. Tigran Bayburtsyan explains how their infrastructure is set up and how they used a custom-built PubSub library. The article also discusses the benefits to using GraphQL subscriptions to provide more interactive UI to users.

Migrating from Redux to GraphQL

Ming Horn from NerdWallet shares some tips and learnings on migrating several screens from Redux to Apollo GraphQL. She takes you through the steps of migration, from writing GraphQL schema and resolvers to making your first query. She mentions the two complex issues she ran into with the schema and Redux store and how she solved the issues with a HOC.

How to Secure a GraphQL API

This in-depth guide details how to implement some of the best practices in securing a GraphQL API from abusive queries by clients. Sample code snippets are provided throughout on how to limit query complexity, automatically persist queries, rate limit based on server time, and more. The guide includes resources to help protect your GraphQL endpoint and apply best practices for authentication and authorization.


Type safety in microservices using GraphQL and TypeScript

This two part series details how to handle type safety in a microservices architecture. The blog discusses the different schema approaches, code-first and schema-first, and how to generate Typescript types from your schema. Part 1 focuses on type safety between the frontend and backend and includes examples using GraphQL Codegen to convert types exposed in a GraphQL schema back into TypeScript types.

Architecting a Roles & Permissions System Using Rails, GraphQL & React

This in-depth tutorial explains how Atrium, a tech-enabled law firm, has designed and built a custom permissions system that allows for more efficient and logical workflows. Sam Henderson adds useful advice and tips on how to establish goals for permission systems, naming conventions, and how to bundle permission sets into roles.


Apollo Client, now with React Hooks

Apollo is thrilled to announce the addition of React Hooks to Apollo Client! The useQuery, useMutation, and useSubscription hooks will help reduce boilerplate and unnecessary data management code, handle multiple mutations, and significantly reduce bundle size. With improved TypeScript support, it makes writing type-safe React components that much easier.

How companies are making GraphQL work in the real world

This article discusses how companies like Apollo and Github have handled the variety of challenges and successes faced when commercially implementing GraphQL into their APIs. The article also investigates the different schema design patterns for GraphQL and best practices in determining what the API should represent.


Fullstack template for React GraphQL project

Tomek Poniatowicz provides three fullstack React GraphQL boilerplates to help get any project set up quickly and efficiently. Each boilerplate comes with different features to fit your needs. The minimal boilerplate comes packaged with a GraphQL server and a pre-configured Apollo Client, while the basic and advanced boilerplates come with a GraphQL database, tooling, and a pre-configured graphql-config setup.

GraphQL, Auto Persisted Queries, CDN Support and Getting it work on Native App.

This article by Henry Hong explains how to address performance issues in GraphQL by using Auto Persisted Queries. Auto Persisted Queries (APQs) allows the query mapping record to be added from a normal request. Hong also provides a step by step guide on how to implement Auto Persisted Queries in a mobile application.

Not Sold Yet, GraphQL: A Humble Tale from Skeptic to Enthusiast

Garrett Heinlen from Netflix explains how GraphQL was important for evolving Netflix’s schema to the next level. Heinlen talks about how GrpahQL provides unity with separate teams and helps an entire organization communicate in a more efficient way. In addition, Heinlen discusses the challenges that arose when using GraphQL at scale.


Using GraphQL Playground with Gatsby

In this article, Adebiyi Adedotun guides you through the steps needed to switch the default GraphiQL IDE to GraphQL Playground while developing with GatsbyJS. GraphQL Playground provides features to further help with development, such as automatic schema reloading, multiple tabs, and query history.

Nullability in GraphQL

This article goes over the best practices on how to properly use Nullability in GraphQL. When used properly, Nullability allows for further resiliency, graceful UI degradation, frictionless user workflows, and more.

Why GraphQL Performance Monitoring is Hard

Do you struggle monitoring performance with GraphQL? You aren’t the only one. This article explains why it can be a challenge, and offers some alternative approaches to monitor properly, as well as provides suggestions on how to detect anomalies.


The GraphQL Dataloader Pattern: Visualized

In this article, Marc-André Giroux breaks down what the GraphQL Dataloader pattern is and why data loading issues exist with GraphQL. He provides examples of performance issues with various executions of GraphQL queries. Giroux also provides his thoughts on lazy loading and emphasizes an asynchronous approach to resolvers.

GraphQL Code-First and SDL-First, the Current Landscape in Mid-2019

This blog sheds some light on the current state of the GraphQL ecosystem and the decision between code-first or SDL-first schema development. Rohit Ravikoti analyzes both implementations and offers insight into the risks and tradeoffs each approach has. He includes a couple of suggestions on how your team can stay organized and choose the approach that fits best.

Some thoughts on GraphQL vs. BFF

This post shares some interesting insight on the different API patterns, Back-end for Front-end (BFF) and One-Size-Fits-All (OSFA), and how they could be affected by the usage of GraphQL. Phil Calçado explains how BFFs can optimize endpoints/payloads and questions if BFFs are even necessary with GraphQL. He also challenges single schema data models and how integration databases can be problematic.


GraphQL Documentation Generators, Explorers, and Tools

This article by J Simpson compiles some of the best GraphQL documentation generators and tools for your API development. He lists out the benefits and disadvantages from using static documentation generators like GraphQL Docs to documentation explorers like GraphiQL. Optimize and automate your workflow with the tools Simpson discusses throughout the article.

Migrating to GraphQL: A Practical Assessment

This in-depth research paper by engineers from the Federal University of Minas Gerais assesses the differences in migrating API clients and utilizing GraphQL instead of standard REST-based APIs. After migration to GraphQL, the results demonstrated a 94% reduction in terms of fields and bytes. Read more about the community’s response and commentary towards some controversial claims in the hacker news discussion.

Building a Mock Blue Bottle GraphQL API

This tutorial is packed with resources from Eve Porcello's and Alex Bank's GraphQL Workshop on building a GraphQL Schema to mock a web application. The article details the process of creating a mock schema of bluebottlecoffee.com using Apollo and faker.js. It includes how to implement interfaces, write mock resolvers, and get a GraphQL server set up.


How Product Hunt structures GraphQL Mutations

Learn how Product Hunt maintains a consistent structure for organizing GraphQL mutations with their naming conventions and mutation shape. The blog discusses how to handle Relay compatibility, GraphQL node and error fields, and response aliases. Product Hunt shares the frontend and backend tooling that supports these mutations and allows developers to focus more on business logic.

React Apollo vs Redux + REST: Implementing the same feature twice

This article offers some insight into the benefits and drawbacks of using Redux with REST calls versus using React Apollo with GraphQL. Gytis Vinclovas from Wix Engineering created this experiment to test the two client stacks and the differences in data loading, calling APIs, updating local states, and overall flexibility of each tool.

Why GraphQL

This detailed article explains the reasons and motivations behind the adoption of GraphQL at Managed by Q. It documents the engineering team’s process of rebuilding the bridge between data services and clients. The article not only breaks down the improvements in their architecture but also showcases the concerns the team experienced during implementation.


Top Takeaways from GraphQL Conf 2019

A great summary of the GraphQL Conf 2019 and Prisma Day that includes resources on what was discussed, showcased, released, and any other notable tools/concepts. The post highlights some key takeaways and comments on the state of the GraphQL community.

GraphQL & Caching: The Elephant in the Room

In this article, Marc-André Giroux offers a deeper understanding of GraphQL’s limitations in terms of caching. He investigates how HTTP caching, server-side caching, and application side caching all have different effects on how cacheable GraphQL really is. The article is a preview of his upcoming book which will dive into solutions to the GraphQL caching problem.

There and Back Again, A GraphQL Lifecycle Tale

This blog post helps explain and visualize the lifecycle of a GraphQL request and server response. The post details the path from when the client sends a request to how the server parses and then resolves the expected response.


Postman v7.2 Supports GraphQL!

Postman now supports GraphQL! With the newest update, Postman can send GraphQL queries in the request body, use GraphQL variables, autocomplete queries, and create/store GraphQL schemas directly in Postman. Check out this blog to see examples of all the new features and how to get started working with GraphQL in Postman.

Enhancing schemas with interfaces

This article breaks down what GraphQL interfaces are and how to implement them. Schema examples are provided in a side-by-side comparison on how using interfaces help improve schemas by adding better readability, scalability, and maintenance.

EdgeDB Roadmap

EdgeDB is a new relational database with native GraphQL support. The newly published roadmap details the vision and the future of the product. Currently built out GraphQL features include Querying Object Types and Querying Views, with Access Control and Mutations planned for 1.0.

The Guild is taking over maintenance of merge-graphql-schemas, so let’s talk about GraphQL Schema management

As mentioned in the title, The Guild is taking over the maintenance of merge-graphql-schemas, a tool that was maintained by OK Grow. In The Guild's post on the subject, Uri (the founder of The Guild) explains that merge-graphql-schemas will join other schema management tools that the company works on. Furthermore, in the weeks, additional articles will be published on the various topics related to splitting schemas and the related solutions.


Apollo raises $22 million to simplify app development

Congrats to Apollo for raising 22$ million in funding for its first venture capital round! Apollo is determined to empower developers by providing a platform for building data graphs that connect apps and devices to the cloud. With this funding, Apollo plans on improving core technology, like Apollo Federation, and providing more resources and documentation for open source libraries.

Moving to a static site with Gatsby + Netlify + Contentful

Scott Silver shares the process on how Flexport changed their site architecture to be static, incorporating Gatsby, Netlify, and Contentful into their stack. As both Gatsby and Contentful work with GraphQL, the tools integrated very well into their existing stack. He dives into the pros and cons of these tools, as well as describes the role played by GraphQL, and provides valuable advice for large-scale organizations that are also interested in increasing performance.

The API I wish JavaScript GraphQL implementations supported

This interesting blog post discusses a powerful strategy for building API schemas based on the user interface. Samer Buna breaks down the advantages and disadvantages of implementing your GraphQL service and how we can use schema-language text to start building the frontend without server implementation. To try it out yourself, check out the graphql-makers package included at the bottom of the post.


A Year of Large Scale GraphQL - The Biggest Takeaways

This interesting article discusses the results of implementing GraphQL at scale. Peter Nycander shares the lessons he learned and his experience with GraphQL design, server side caching, mutation types, and schema stitching.