I Tried GoFr as a Complete Go Beginner — Here’s What Happened

A honest first look at the Go framework that makes microservices surprisingly approachable

I’ll be upfront with you: I’m not a Go developer. I’ve mostly worked with JavaScript and Python. But when I kept seeing GoFr pop up in open-source circles, I got curious enough to spend a weekend trying it out. This is my honest experience as a complete beginner.

What Even Is GoFr?

GoFr is an open-source Go framework built specifically for microservice development. Think of it like Express.js for Node.js, but for Go — it handles all the boring setup stuff so you can focus on actually building things.

Out of the box, GoFr gives you:

• HTTP routing
• Structured logging
• Health checks (great for Kubernetes)
• Database support (MySQL, PostgreSQL, MongoDB, Redis)
• Built-in observability (metrics and tracing)
• Graceful shutdowns

As someone who has spent hours wiring up all this stuff manually in other frameworks, this sounded almost too good to be true.

Getting Started (Even If You Don’t Know Go)

The first thing I did was install Go. If you haven’t already, grab it from golang.org. GoFr requires Go 1.24 or above.

Then create a new project folder and initialize it:

mkdir my-first-gofr-app
cd my-first-gofr-app
go mod init my-first-gofr-app

Add the GoFr package:

go get gofr.dev/pkg/gofr

Now create a main.go file with this code:

package main

import "gofr.dev/pkg/gofr"

func main() {
    app := gofr.New()

    app.GET("/greet", func(ctx *gofr.Context) (any, error) {
        return "Hello from GoFr!", nil
    })

    app.Run()
}

Run it:

go run main.go

Visit http://localhost:8000/greet in your browser and you'll see:

"Hello from GoFr!"

That’s it. Your first microservice. Honestly, I was shocked at how little code that needed.

What Surprised Me

1. The logging is incredible out of the box

The moment you run the app, GoFr starts printing structured JSON logs — request ID, method, path, response time, status code. In other frameworks, this takes an entire middleware setup. Here it just works.

2. The health check endpoint is automatic

GoFr automatically creates a /health endpoint. For anyone building production apps or deploying to Kubernetes, this is massive. You don't write a single line for it.

3. The error handling is clean

Instead of the usual Go error pattern scattered everywhere, GoFr uses a consistent (interface{}, error) return type for all handlers. It feels much more organized.

A Quick Real-World Example: A Simple REST API

Let me show you something slightly more useful — a tiny API that returns user info:

package main

import "gofr.dev/pkg/gofr"

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func main() {
    app := gofr.New()

    app.GET("/user/{id}", func(ctx *gofr.Context) (any, error) {
        id := ctx.PathParam("id")
        return User{ID: 1, Name: "Nitesh"}, nil
    })

    app.Run()
}

Hit http://localhost:8000/user/1 and you get:

{
  "id": 1,
  "name": "Nitesh"
}

No extra JSON marshaling, no manual header setting. GoFr handles it all.

Honest Thoughts: The Good and The Not So Good

What I liked:

• Extremely fast to get started — less than 5 minutes to a running service
• Clean, readable code that doesn’t feel overwhelming for beginners
• Built-in features that would take hours to set up in other frameworks
• Great documentation at gofr.dev
• Active open-source community on GitHub (13k+ stars)

What could be better:

• Smaller community compared to giants like Gin or Echo, so fewer Stack Overflow answers when you get stuck
• Some advanced features require Docker, which adds a learning curve for beginners
• As an opinionated framework, it pushes a specific project structure — great for teams, potentially rigid for solo projects

Should You Try It?

If you’re a Go developer tired of writing the same boilerplate for every microservice — absolutely yes, GoFr is worth your time.

If you’re a beginner to Go like me — GoFr is actually a surprisingly gentle entry point. The minimal code needed to get something running is motivating, and the automatic features (logging, health checks) let you focus on learning the language rather than infrastructure.

The framework is actively maintained, ships to real production environments, and the team genuinely welcomes contributions. I’m already looking at their GitHub issues to see where I can help.

Give it a try: github.com/gofr-dev/gofr

Have you tried GoFr? Drop your thoughts in the comments — I’d love to hear from other beginners or experienced Go devs on what they think.