node-graphql-server: three GraphQL boilerplates that are now deprecated

The deprecation note points you to Prisma examples instead

The first thing the project tells you is that it is finished. The deprecation note states that the repository has been deprecated and is currently unmaintained, and it points to up-to-date examples for building GraphQL servers with a database in the Prisma examples repository.

That is a deliberate handoff rather than an abandonment, and it changes what this repository is for. It is no longer a starting point you scaffold a new service from. It is reference material, and the difference matters for how you read the rest of the README, because everything below it describes a world where you would install one of these and start building.

The repository itself is not marked as archived, and the last push was on 2026-10-15. There are no GitHub releases, so the versioned artifacts of the boilerplates live in the branches and directories rather than in tags.

The top-level layout is unusually small for a project of this kind: three directories named advanced/, basic/ and minimal/, a renovate.json, and the README. There is no shared library, no build system and no test suite at the root. Each boilerplate is a self-contained project with its own README, which is what makes it possible to open one directory and read the whole thing without navigating a framework.

For a reader deciding what a GraphQL server needs, that structure is itself the lesson. The difference between the three tiers is not a matter of taste, it is the difference between a server that returns a string and a server that persists data, authenticates users and pushes updates.

Three tiers from Hello World to authentication and subscriptions

The quickstart section lists the three boilerplates and points to the README inside each one.

The minimal boilerplate is described as having basic Hello World functionality, and it exists to show the smallest possible server rather than anything you would deploy.

The basic boilerplate adds a simple data model and a GraphQL database. In other words, it is where the schema stops being a single query and starts describing entities with fields.

The advanced boilerplate adds a GraphQL database, authentication and realtime subscriptions. Those three additions are the ones that carry real engineering weight, and they are the reason the tier exists. Authentication changes how every resolver receives identity, and subscriptions change the transport story, because the server has to hold connections open and push events rather than answer a request and return.

All three are described as based on graphql-yoga, which the project calls a fully-featured GraphQL server library with focus on easy setup, performance and developer experience. Choosing one server library for all three tiers keeps the examples comparable, so the difference you observe between minimal and advanced is the difference in application code rather than a difference in framework.

The stated design intent is that a boilerplate provides only the minimum setup so you can tailor the API to your use case, and that each one incorporates best practices from the GraphQL community. Combined with the absence of a shared core in the repository, that reads as a set of opinionated starting points rather than a framework with a plugin system.

graphql create is the install path, and the CLI is a separate project

Scaffolding is described as rapid: you use the create command from the GraphQL CLI to download the boilerplate you want.

graphql create

The important detail is where the tool lives. The GraphQL CLI is a repository in its own right, linked from the README, so the command you run is not part of this project and its current state is not described here. That is the practical risk in following a deprecated project's quickstart: the installer is maintained separately and may have moved on, while the content it installs has not.

The alternative is to clone the repository and copy the directory you want. Nothing in the README forbids it, and given that each boilerplate is a self-contained project, a directory copy is a reasonable way to read the code even if you never run the command.

For a fuller walkthrough the project points to the How to GraphQL tutorial and to a blog post explaining the reasoning behind GraphQL boilerplates and the create command. The tutorial is the better starting point for someone who wants to understand the layering, because it explains the steps rather than handing you the finished file.

The community sponsorship no longer describes who maintains the code

The contributing section says the GraphQL boilerplates are maintained by the GraphQL community, with official support from the Apollo and Prisma / Graphcool teams, and it invites feedback, questions and pull requests on a Slack channel named for the boilerplate.

Read that paragraph next to the deprecation note and the picture is clear. The repository is a community project that was hosted with corporate backing, and it has since been wound down while the underlying ecosystem moved to other examples. The Slack channel and the maintainer statement are historical context, not a route to a maintainer who will pick up your issue today.

The topics attached to the repository are graphql, graphql-boilerplate, graphql-server and nodejs, and the description calls the code boilerplate for scalable, production-ready GraphQL servers. Both still describe the intent of the code accurately, which is what makes the repository still useful to read.

The licence situation is murkier. The repository licence is recorded as unknown, and the README does not carry a licence section. For a directory you intend to copy into a product, that is a genuine question rather than a formality, and the answer is in the individual boilerplate directories rather than at the root, so it needs checking per project.

What reading a boilerplate teaches that a tutorial does not

There is a specific reason to read this code even though you should not start from it.

A tutorial teaches one path through a problem. A boilerplate shows the settled shape of a solution at a particular moment, including the decisions that are invisible in a tutorial because the tutorial author made them silently. The three tiers here are ordered by that measure, and the ordering is itself the argument: a server that returns Hello World, a server with a data model and a database, a server with authentication and subscriptions.

The advanced tier is where the reading pays off. Authentication and realtime subscriptions are the two features that turn a query endpoint into an application backend, and they are the two that most often get bolted on badly later. Seeing them placed from the start, in a small project, is the point of the tier.

The graphql-yoga base is the other thing to take away. One server library across all three tiers means the examples are comparable, and the README links to a tutorial and a blog post that explain the reasoning rather than only the result.

Read these as documentation of a moment. The Prisma examples repository, which the deprecation note points to, is where you would look for current patterns, and nothing in this repository contradicts that referral. If you are choosing where to spend time, the current examples come first and this repository is the older reference.

Editorial conclusion

These boilerplates are worth reading as design references, because the three-tier structure of a Hello World setup, a data model with a database, and a version with authentication and realtime subscriptions is a clear statement of what a production GraphQL server needs, and the code is small enough to read in one sitting. They are not worth starting a new project from, because the repository says in its own deprecation note that it is unmaintained, and the GraphQL CLI command that installs them is a separate tool whose current state the repository does not describe. Before you build on any of it, verify three things yourself: that the dependency versions pinned in the boilerplate you copy still install against current Node.js, that the GraphQL CLI still serves the boilerplate registry, and that the subscription and authentication patterns in the advanced template still match the library versions you plan to use.

Frequently asked questions

Official sources

1. graphql-boilerplates/node-graphql-server on GitHub
2. Issues
3. README