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


GraphQL in JavaScript: An Introduction

An introductory article for GraphQL, this article has a nice addition in that it offers up an example with an express endpoint and finally gives some further information on working with GraphQL, including error handling and middleware.


GraphQL In Action: Introduction

Check out the entire first chapter of GraphQL in Action by Samer Buna. The chapter is beginner-friendly and covers the what, why, and challenges that GraphQL comes with.

What is the N+1 problem?

A repost of an informative article on the N+1 problem which comes up when fetching related data entities in GraphQL resolvers. Learn more about the N+1 problem and solution in this article written by the author of Production Ready GraphQL.

GraphQL and Graph Databases

An insightful and opinionated take on the synergies and inherent differences between GraphQL and graph databases. Paul argues that although GraphQL is a helpful interface for Graph Databases, GraphQL technically has little to do with Graph Databases.


GraphQL Lessons After 4 Years: Scaling Subscriptions

Learn from Matt's insights based on his four years of experience building with and scaling GraphQL subscriptions through trial and error. The post covers GraphQL subscription basics and then details his learnings in a series of concise tips.

GraphQL beyond the buzzword; When to use GraphQL

A thought-provoking article covering the situations where GraphQL provides value. GraphQL has many advantages, but it isn't a magic bullet for all API problems. In this article, Shani does an in-depth cost-value analysis of GraphQL adoption and provides a useful decision table to help you decide.


Chaining Graphql Resolvers

This post breaks down the problems of GraphQL resolvers and offers some solutions by creating a chain of resolvers to satisfy individual parts of the overall problem. By doing so, these resolvers can be reused, tested easily and make code more expressive. Abhishek Saha demonstrates through sample code how chaining resolvers helps write schemas quickly to improve server side development.

Caching GraphQL Responses

To support offline capabilities, learn how to cache GraphQL responses by implementing a GraphQL caching in service workers with the caches API. Abdelrahman Awad explains the differences between caching as part of an application logic layer and caching as an enhancement layer, focusing more on the latter. The post also explains the fundamental distinctions between RESTful caching and GraphQL caching, and how GraphQL caching is transport agnostic.


GraphQL for beginners

In this post, Danijel gives a soft introduction to GraphQL with some useful analogies for developers coming from REST style APIs. Danijel uses diagrams to show how GraphQL queries are resolved on the server side.

Optimization GraphQL resolvers with lookaheads

Follow along with Boopathi as he explains what lookaheads are and how they can improve your GraphQL server. Boopathi demonstrates the situations in which it's possible to utilize lookaheads and how to use this technique to only fetch necessary fields, reducing both DB load and unnecessary traffic.


Robust GraphQL mutations the Relay way

This post explores some of the complications faced when designing the mutations part of a GraphQL API and the best practices to follow based on the Relay's API spec for mutations. David Chanin explains how these practices are applicable more generally, even if you're not using Relay on the frontend.

GraphQL is Not "Better" Than REST

A thought provoking and opinionated post about the semantic differences between GraphQL and REST and how they can't be directly compared as one is a query language while the other is an architectural style. Fagner Brack challenges in the post common conventions and includes a list of interesting resources on the topic.


The what, when, why, and how of federated GraphQL

This blog goes in-depth on the origins of federation, the design and implementation of a federated graph architecture, the components of federation, and more. The article explains how federated architecture, although fairly new, helps simplifies, in a highly optimized manner, the problem of bringing multiple schemas from different micro services together and merging them into one unified graph API.

Multi-Tenant GraphQL With Neo4j 4.0

Check out this tutorial that demonstrates how to use multiple databases in Neo4j 4.0 and how to use multiple active databases with the Neo4j GraphQL integration, building a multi-tenant GraphQL API. William Lyon includes example code on how to setup and create a GraphQL schema and Neo4j driver instance. He also provides resources at the end of the tutorial for more information on multi-database support with Neo4j and GraphQL.

Blazing Fast GraphQL Execution with Query Caching & Postgres Prepared Statements

This post explores the important performance considerations for building apps at scale and how Hasura GraphQL Engine leverages PostgreSQL query caching and prepared statements to improve performance. Some interesting metrics are provided as the article breaks down the multiple stages of processing an incoming GraphQL query. Praveen Durairaju explains how Hasura’s architecture allows for GraphQL query plans to get cached and SQL query plans to get cached by Postgres with prepared statements.


Advice from a GraphQL Expert

Sarah Drasner shares the advice and notes from a NodeSF meetup where Francesca Guiducci gave a talk on A GraphQL Guide for Backend Developers. This post dives into how to determine if GraphQL fits into your architecture, whether it’s putting a GraphQL server in front of a database or using GraphQL as a wrapper around existing APIs. She further explains the details and best practices of schema design, providing examples while sharing the challenges that come with using GraphQL.

Domain-Driven GraphQL Schema Design

This article discusses an approach to GraphQL schema design that involves both non-technical domain experts and developers. Khalil Stemmler takes you step by step using event storming to design and build a GraphQL schema, showing the different use cases for when CRUD doesn’t fit.

Why You Should Be Using TypeScript + GraphQL

In this article, Sean Dearnaley explains the powerful combination of TypeScript and GraphQL and the learning outcomes of type safety. These tools combined offer the ability to construct powerful and practical programming interfaces that can be used by all GraphQL consumers. Learn how to evolve an API without endpoint versioning by using Typescript.


GraphQL Scalars in-depth

This article by Andi Marek provides a deep deep dive into scalars. The article helps readers understand GraphQL scalars and learn how to write custom ones. The examples provided within the article are in GraphQL.js but the focus is on the fundamental concepts, especially Coercion.

GraphQL in 2020:What's Next?

With the start of each year predictions and discussions about the upcoming trends in GraphQL are becoming a tradition. In his recent article, Marc-Andre Giroux covers some of the trends he expects this year. He speaks to transport specific implementations/optimizations, alternative execution algorithms/engines, and a greater focus on GraphQL's tradeoffs.

MongoDB Unveils Managed GraphQL for MongoDB Atlas

MongoDB has added support for GraphQL in its cloud DB service, MongoDB Atlas. This New Stack article covers the details of the launch, how the functionality was integrated with Mongo and what requirements the company outlines to get started with the feature.

GraphQL: the REST is history?

An illustrated article with helpful sketches, Stav Barak's introduction to GraphQL is a great summary about the technology for people curious to learn about what GraphQL is and does. Covering the advantages that GraphQL has over REST, Stav offers up examples throughout the piece. A great article for newcomers to GraphQL.


Domain Modeling with Tagged Unions in GraphQL, ReasonML, and TypeScript

This in-depth article introduces the concept of discriminated/tagged unions in GraphQL and how to leverage them to write more extensible applications. The article includes examples of GraphQL unions and how they are represented as tagged unions at runtime. Kevin Saldaña also discusses ReasonML and demonstrates the power of variants and pattern matching in Reason. He explores the power of Hindley-Milner type inference and pattern matching, which can be combined to efficiently write highly type-safe applications.


Using "Loose Typings" in GraphQL to Allow Dynamic Grouping and Aggregation Queries

Sebastian Scholl from the 8base team shares how they were able to build a full-featured group and aggregations enabled GraphQL API with direct SQL access while still within the confines of GraphQL. Sebastian runs through how they utilize aliases that allows for dynamic types and attribute-names to be used.

How Apollo REST Data Source Deduplicates and Caches API calls

Learn about the potential ways to resolve data for a GraphQL endpoint using RESTful APIs and how to utilize Apollo’s REST Data Source library in Khalil Stemmler’s deep dive into an optimized GraphQL server. Find out how request dedication and resource caching works in REST Data Source. The article also provides tips to implement your own resource cache using the apollo-server-caching library.

GraphQL Advances when fetching data in iOS with Swift and Apollo SDK

This article discusses some advanced topics using GraphQL with Apollo SDK and Swift, including the usage of GraphQL fragments and Swift scalar types as well as the pros and cons to using GraphQL. Kristaps Grinbergs demonstrates how to use your own types for custom scalars and improve your code base with custom initializers for your app models.


GraphQL Batching Attack

In this article, learn more about the unexpected quirks to web application behavior that GraphQL introduces. The article runs through how the technique of batching works and how it can cause security problems, such as the inconsistencies of implementations, mutation operations that work with user authentication, and more. At the end, the article offers some tips on how you can safely secure your GraphQL applications against batching attacks.

What Can the Semantic Web Do for GraphQL?

This article speculates the benefits of combining GraphQL and the Semantic Web because of the commonalities between the two technologies. Some core Semantic Web mechanisms and existing resources can help enhance GraphQL data integration and its publishing capabilities. Szymon Klarman provides interesting commentary on how GraphQL and URIs can open the door to global knowledge graphs and improved data environments.

Exploring GraphQL with Coroutines on Android

This blog takes a look into performing GraphQL queries and how to configure your project to communicate with a sample API. Joe Birch introduces a GraphQL setup with coroutines and how it can improve the approach to asynchronous operations. He provides sample code throughout the article to explain how to utilize GraphQL schemas and queries to build out a project.


When Client Developers Love GraphQL To Death

This article discusses the importance of cost computation and limiting the size of server responses to prevent memory overload. Scott Malabarba explains how to calculate costs based with a sample schema of a book list app. He provides some solutions, like adding query cost computation and limits in complex data models, to add robustness and flexibility to your GraphQL APIs.


Protecting Your GraphQL API From Security Vulnerabilities

Tom Nagle provides insight into GraphQL security vulnerabilities that are useful to keep in mind when building a large-scale enterprise application or even a simple side project. He breaks down major threats, like brute forcing vulnerable mutations, and offers detailed solutions against various attacks. The article includes sample code as well as helpful tools to prevent your schema from being leaked in public environments.

How to use subscriptions with GraphQL using Apollo iOS SDK and Swift

In this quick tutorial, learn how to set up and use the Apollo iOS SDK library, which supports GraphQL subscriptions. You can generate all the subscriptions using the GraphQLSubscription protocol, passing parameters to the subscription you want to implement. The tutorial teaches how to utilize the GraphQL subscription feature to listen and send real-time messages using WebSockets.

Migrating to GraphQL at Airbnb

This blog discusses how Airbnb successfully migrated their large API to GraphQL, which led to improved page load times and a more intuitive user experience. The blog talks about the stack Airbnb used, how they handled aliasing and adapters to convert a GraphQL response, stage management, and other features in the project. Thomas Betts also explains all the benefits and improvements for Airbnb ever since they switched to GraphQL over REST.

Lessons learned using Single-table design with DynamoDB and GraphQL in production

This article shares some key learnings on utilizing DynamoDB to develop a fully serverless GraphQL API in production. It discusses which query access patterns are important, how to handle proper abstractions and create your own opinionated ORM, and more. Learn the dos and don’ts to prevent your table from consuming too many write capacity units and enable large scalability.


GraphQL performance explained

This blog post does a deep dive into GraphQL performance by examining what GraphQL implementation is doing. The post explains parsing, validation, and execution of a GraphQL query, and how we can reduce performance overhead of the GraphQL API with precompiled queries and mutations. Although applications that use GraphQL can be slightly slower initially, this article provides some tips on how to tweak them to achieve better performance results.


GraphQL Search Indexing

Learn from the Netflix Marketing Tech team about a different approach to searching with GraphQL and how to index data and make it searchable. The team shares how they used the relationships and schemas defined within GraphQL to automatically build and maintain a search database. The blog goes through the challenges of searching decentralized data, keeping everything up to date, periodic indexing, and more.

An Empirical Study of GraphQL Schemas

Check out this brief of the research paper “An Empire Study of GraphQL Schemas” that provides a summary of what GraphQL is, what performance benefits a GraphQL API offers, and what a “typical” GraphQL schema looks like. The research examines the differences between open-source schemas versus commercial schemas, using their findings to discover trends and consistencies in naming conventions, schema designs, and pagination patterns.