Learn GraphQL - Latest Specification & Future Developments

#Introduction

GraphQL isn't a static technology. Its specification keeps evolving through proposals and RFCs discussed by the community. Episode 40 maps out GraphQL specification development and its future direction.

We'll trace the specification's evolution, discuss the @defer and @stream directives for incremental delivery, the features currently in the works, and the role of the community and the GraphQL Foundation.

#GraphQL Specification Evolution

#Specification Development

The GraphQL specification is managed by the GraphQL Foundation through an open RFC process. Key milestones:

• 2015: the initial specification was released alongside the open-source project.
• 2016-2018: formalization, joining the Linux Foundation, and a maturing ecosystem.
• 2021: GraphQL over HTTP and fragment arguments.
• Recent: incremental delivery (@defer and @stream), schema coordinates, and input unions as proposals.

Features are never added carelessly — every proposal goes through long discussions and implementations in several languages before entering the specification.

#@defer and @stream

#Incremental Delivery with @defer

@defer allows responses to be sent incrementally: fields marked @defer (slow ones) are sent later, while fast fields appear immediately:

query PostPage($id: ID!) {
  post(id: $id) {
    id
    title
    body
    comments @defer {
      items { id body }
    }
  }
}

Use case: a detail page that shows the main content first, with comments arriving afterwards. The performance benefit is real for slow fields (analysis, external calls) — users don't wait for the entire response.

#@stream for List Fields

@stream does the same for list elements: each item (or chunk of items) is sent as soon as it's available, instead of waiting for the whole list:

query Feed {
  feed @stream(initialCount: 5) {
    id
    title
  }
}

Implementing @stream requires a transport that can send incremental responses — usually via multipart HTTP or WebSocket. Support is still maturing across servers and clients; make sure your library versions support it.

#Upcoming Features

#Features in Development

Some interesting proposals to follow:

• Client Controlled Nullability: clients can mark fields as non-null (title!) in their responses — shifting part of the nullability decision to the client.
• Fragment Arguments: fragments can accept arguments, making them far more flexible.
• Input Unions: unions for input types — simplifying polymorphic inputs.
• Schema coordinates: a standard format for pointing to a location in the schema (for example User.name), used by tools and the error spec.
• Full-text search directive: a proposal for a directive enabling full-text search in queries.
• Subscriptions improvements: refinements to the subscriptions spec for better transport and recovery.

query UserPage($id: ID!) {
  user(id: $id) {
    username!
    email
  }
}

Note: the features above are proposals or drafts. The production rule of thumb — only use features already in the stable spec and supported by the libraries you use.

#Community Initiatives

#GraphQL Foundation and the RFC Process

The GraphQL Foundation under the Linux Foundation manages the specification, trademark, and community programs. Ways to contribute:

• Follow the working groups (graphql-spec) that discuss proposals regularly.
• Read and comment on RFCs before features are finalized.
• Implement proposals in your favorite libraries.
• Attend GraphQL Conf and community meetups.

See active proposals by cloning the spec repo: git clone https://github.com/graphql/graphql-spec.git.

Contributing to the spec isn't only for veterans — questions and real-world use cases from everyday developers are often valuable material for working groups.

#Conclusion

Key takeaways:

• The GraphQL specification evolves through an open RFC process.
• @defer sends slow fields later; @stream sends list items incrementally.
• Incremental delivery needs multipart or WebSocket transport support.
• Upcoming features: Client Controlled Nullability, Fragment Arguments, and Input Unions.
• Schema coordinates standardize how locations in a schema are referenced.
• The GraphQL Foundation and working groups are open to anyone's contributions.

In the next episode, episode 41, you'll learn about a full-stack e-commerce project — a monorepo with Turborepo, a Next.js frontend and Apollo Server backend, a product catalog with search, a shopping cart with mutations, Stripe integration, and production deployment and monitoring. Everything you've learned comes together in one real project!