Implementing a Simple GraphQL Server in Go

By Alessandro D.P.3 min readMarch 20, 2026

Prerequisites

Before diving into the implementation, ensure you have the following:

Go installed on your machine (version 1.15 or later).
Basic understanding of Go and its package management.

Setting Up the Project

First, create a new directory for your project and initialize a Go module:

mkdir graphql-go-server
cd graphql-go-server
go mod init graphql-go-server

Next, install the required dependencies:

go get github.com/graphql-go/graphql
go get github.com/graphql-go/handler

Defining the GraphQL Schema

In GraphQL, a schema defines the types and their relationships. Let's create a simple schema for a blog with Post and Author types.

Create a file named schema.go:

package main

import (
    "github.com/graphql-go/graphql"
)

// Post represents a blog post.
type Post struct {
    ID      string
    Title   string
    Content string
    Author  Author
}

// Author represents a blog author.
type Author struct {
    ID   string
    Name string
}

// Sample data
var posts = []Post{
    {ID: "1", Title: "GraphQL in Go", Content: "Learn how to implement GraphQL in Go.", Author: Author{ID: "1", Name: "John Doe"}},
    {ID: "2", Title: "Go Concurrency", Content: "Understanding goroutines and channels.", Author: Author{ID: "2", Name: "Jane Smith"}},
}

// Define the Author type
var authorType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Author",
    Fields: graphql.Fields{
        "id": &graphql.Field{
            Type: graphql.String,
        },
        "name": &graphql.Field{
            Type: graphql.String,
        },
    },
})

// Define the Post type
var postType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Post",
    Fields: graphql.Fields{
        "id": &graphql.Field{
            Type: graphql.String,
        },
        "title": &graphql.Field{
            Type: graphql.String,
        },
        "content": &graphql.Field{
            Type: graphql.String,
        },
        "author": &graphql.Field{
            Type: authorType,
        },
    },
})

// Define the root query
var rootQuery = graphql.NewObject(graphql.ObjectConfig{
    Name: "RootQuery",
    Fields: graphql.Fields{
        "posts": &graphql.Field{
            Type: graphql.NewList(postType),
            Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                return posts, nil
            },
        },
    },
})

// Create the GraphQL schema
var schema, _ = graphql.NewSchema(graphql.SchemaConfig{
    Query: rootQuery,
})

Implementing the GraphQL Server

Now that we have our schema defined, let's implement the server. Create a file named main.go:

package main

import (
    "net/http"
    "github.com/graphql-go/handler"
)

func main() {
    h := handler.New(&handler.Config{
        Schema: &schema,
        Pretty: true,
        GraphiQL: true,
    })

    http.Handle("/graphql", h)
    http.ListenAndServe(":8080", nil)
}

Running the Server

You can now run your GraphQL server:

go run main.go

Open your browser and navigate to http://localhost:8080/graphql. You should see the GraphiQL interface, which allows you to interactively test your GraphQL queries.

Testing the GraphQL API

You can test your API using the GraphiQL interface. Here are some example queries:

Fetch all posts:

{
  posts {
    id
    title
    content
    author {
      id
      name
    }
  }
}

Response:

{
  "data": {
    "posts": [
      {
        "id": "1",
        "title": "GraphQL in Go",
        "content": "Learn how to implement GraphQL in Go.",
        "author": {
          "id": "1",
          "name": "John Doe"
        }
      },
      {
        "id": "2",
        "title": "Go Concurrency",
        "content": "Understanding goroutines and channels.",
        "author": {
          "id": "2",
          "name": "Jane Smith"
        }
      }
    ]
  }
}

Best Practices

Error Handling: Always handle errors in your resolvers. This ensures that your API can gracefully manage unexpected situations.
Validation: Validate input data in mutations to prevent invalid data from being processed.
Documentation: Use comments to document your schema and resolvers for better maintainability.
Versioning: Consider versioning your API as it evolves to maintain backward compatibility.

Conclusion

This tutorial provided a comprehensive guide to implementing a simple GraphQL server in Go. You learned how to define a schema, implement resolvers, and run the server. With this foundation, you can expand your API by adding more types and queries.