Building GraphQL Servers in Node.js: apollo-server vs express-graphql vs graphql-tools

When setting up a GraphQL API in Node.js, developers often encounter three key packages: apollo-server, express-graphql, and graphql-tools. While they all relate to GraphQL, they serve different purposes—one is a full server, one is a lightweight middleware, and one is a schema utility library. Understanding their roles prevents architectural missteps, especially since one of them is no longer maintained.

⚠️ Deprecation Status: Know Before You Build

First, a critical update: express-graphql is officially deprecated. The npm page states: "This package is no longer maintained. We recommend using Apollo Server instead." This means you should not use express-graphql in new projects. We include it here only for context and migration guidance.

In contrast, both apollo-server and graphql-tools are actively maintained and widely used in production systems.

🧱 Core Responsibilities: What Each Package Actually Does

apollo-server: Full-Featured GraphQL Server

apollo-server is a complete GraphQL server implementation. It handles HTTP requests, parses queries, executes resolvers, formats errors, and serves GraphQL Playground (in development). It can run standalone or integrate with Express, Koa, Hapi, and more.

// apollo-server: Standalone server
import { ApolloServer } from 'apollo-server';
import { typeDefs, resolvers } from './schema.js';

const server = new ApolloServer({ typeDefs, resolvers });
server.listen().then(({ url }) => console.log(`Server ready at ${url}`));

express-graphql: Minimal Express Middleware (Deprecated)

express-graphql is just a middleware that plugs GraphQL execution into an Express app. It delegates almost everything to the graphql package and offers minimal configuration.

// express-graphql: Deprecated usage
import express from 'express';
import { graphqlHTTP } from 'express-graphql';
import { schema } from './schema.js';

const app = express();
app.use('/graphql', graphqlHTTP({ schema, graphiql: true }));
app.listen(4000);

🔴 Do not use this in new code. Migrate to Apollo Server if you're maintaining an old codebase.

graphql-tools: Schema Construction Utilities

graphql-tools doesn’t run a server—it helps you build schemas. Its flagship function, makeExecutableSchema, combines type definitions (SDL) and resolver objects into a single executable schema object that any GraphQL server can use.

// graphql-tools: Schema creation
import { makeExecutableSchema } from 'graphql-tools';

const typeDefs = `
  type Query {
    hello: String
  }
`;

const resolvers = {
  Query: { hello: () => 'Hello world!' }
};

const schema = makeExecutableSchema({ typeDefs, resolvers });
// Now pass `schema` to Apollo Server, Yoga, or any other server

🛠️ Real-World Integration Patterns

Using graphql-tools with apollo-server

Most professional Apollo Server setups use graphql-tools under the hood (even if indirectly). Here’s how they work together:

// Combined: graphql-tools + apollo-server
import { ApolloServer } from 'apollo-server';
import { makeExecutableSchema } from 'graphql-tools';

const schema = makeExecutableSchema({
  typeDefs: `type Query { user(id: ID!): User } type User { id: ID! name: String }`,
  resolvers: {
    Query: { user: (_, { id }) => ({ id, name: 'Alice' }) }
  }
});

const server = new ApolloServer({ schema });
server.listen();

Note: Modern Apollo Server versions accept typeDefs and resolvers directly and internally use graphql-tools, so explicit makeExecutableSchema isn’t always needed—but it’s still useful for advanced cases like schema merging.

Why Not Use express-graphql Today?

Beyond deprecation, express-graphql lacks:

• Built-in support for GraphQL subscriptions
• File upload handling
• Structured error formatting
• Plugin system for observability
• Security features like depth limiting

Apollo Server provides all these out of the box.

🧩 Advanced Schema Workflows with graphql-tools

Where graphql-tools shines is in complex schema management:

Schema Stitching (Legacy Federation)

Before Apollo Federation, graphql-tools enabled combining multiple GraphQL services into one schema:

import { stitchSchemas } from 'graphql-tools';

const gatewaySchema = stitchSchemas({
  subschemas: [
    { schema: userServiceSchema },
    { schema: orderServiceSchema }
  ]
});

Note: For new microservices, use Apollo Federation instead—but graphql-tools still powers many stitching-based systems.

Mocking for Development

Generate realistic mock data from your schema:

import { addMocksToSchema } from 'graphql-tools';

const mockedSchema = addMocksToSchema({ schema });
// Now all resolvers return auto-generated mock data

This is invaluable for frontend teams working before backend APIs are ready.

🔒 Error Handling and Developer Experience

Apollo Server

Provides structured error formatting, masking stack traces in production, and extension points:

const server = new ApolloServer({
  formatError: (err) => ({
    message: err.message,
    code: err.extensions?.code || 'INTERNAL_ERROR'
  })
});

express-graphql (Deprecated)

Offers basic error handling but no customization hooks beyond a global formatError option.

graphql-tools

Not applicable—it doesn’t handle runtime execution, so no error formatting.

📦 When to Use Which: Practical Guidance

💡 Key Takeaways

• apollo-server is your go-to for production GraphQL servers—feature-rich, secure, and well-supported.
• express-graphql is deprecated. Avoid it in new projects; plan to migrate existing uses.
• graphql-tools is not a server—it’s a toolkit for schema authoring, testing, and composition. It complements server libraries rather than replacing them.

In modern architectures, you’ll often see apollo-server and graphql-tools used together: the former runs the API, the latter builds the schema. Understanding this division of labor leads to cleaner, more maintainable GraphQL implementations.