A Rock‑Solid Go Tech Stack: Minimal Frameworks, Maximum Stability

Go projects don’t need flashy frameworks, but choosing the right toolchain can reduce overtime and make development smoother. The author argues that the myth "use the standard library whenever possible" leads to duplicated effort when handling configuration, CLI parsing, panic recovery, CORS, logging, and error codes.

Why not use the minimal standard library?

Manually parsing YAML, environment variables, and command‑line flags; hand‑crafting flag parsing and sub‑commands; and writing custom middleware for panic recovery and CORS are all error‑prone and time‑consuming. The goal is fast delivery, stable operation, and easy maintenance.

Core toolchain

1️⃣ Viper – unified configuration management

Supports YAML/TOML/JSON/Env/Flag merging with priority order: flag > env > file > defaults, eliminating manual os.Getenv calls and type conversions.

viper.SetDefault("port", 8080)
viper.AutomaticEnv() // reads PORT=9090 etc.
port := viper.GetInt("port")

2️⃣ Cobra + Viper – CLI powerhouse

Provides structured commands, sub‑commands, and flag parsing; Viper injects configuration.

var serveCmd = &cobra.Command{
    Use:   "serve",
    Short: "Start the HTTP server",
    RunE: func(cmd *cobra.Command, args []string) error {
        port := viper.GetInt("port")
        // start server …
        return nil
    },
}

Using RunE returns errors only on validation failures, keeping the process alive.

3️⃣ Uber Fx – dependency injection & lifecycle

When dozens of services depend on each other, manual construction becomes unmanageable. Fx assembles dependencies declaratively and manages start/stop order.

fx.New(
    fx.Provide(NewMux, NewHTTPServer),
    fx.Invoke(StartHTTPServer),
).Run()

4️⃣ Echo – lightweight yet full‑featured web framework

Provides route groups, built‑in middleware (logger, recovery, CORS), request binding & validation, and unified error handling.

if errors.Is(err, gorm.ErrRecordNotFound) {
    c.JSON(404, map[string]string{"error": "resource not found"})
}

5️⃣ GORM – pragmatic ORM

Defines tables with structs, handles associations, supports hooks for soft‑delete and audit logs, and is used only in the repository layer to keep higher layers interface‑driven.

6️⃣ Testify – robust testing utilities

Provides testify/mock for auto‑generated mocks and testify/suite for shared setup/teardown, making service‑layer tests easy and coverage high.

7️⃣ Asynq – Redis‑backed background tasks

Handles email sending, data sync, reporting, etc., without blocking HTTP requests. Offers enqueue/consume, automatic retries, delayed execution, and failure alerts.

8️⃣ Zerolog – zero‑allocation structured logging

Outputs JSON suitable for Loki, Datadog, or ELK, with context propagation (request ID, trace ID) and colored output in development.

Putting it together – a real project skeleton

main.go
├── cmd/
│   └── root.go          # Cobra entry
├── internal/
│   ├── config/          # Viper init
│   ├── server/          # Echo + handlers
│   ├── service/         # Business logic (DI interfaces)
│   ├── repository/      # GORM implementation
│   └── worker/          # Asynq task processors
└── pkg/
    └── di/              # Fx modules

Startup flow:

Cobra parses the command.

Viper loads configuration.

Fx injects all dependencies.

Echo starts the HTTP server.

Asynq launches background workers.

Zerolog provides global logging.

Conclusion

The stack is not about using the newest toys; it is battle‑tested over years, enabling rapid iteration, lower bug rates, faster onboarding, and less painful on‑call duties. The philosophy is not "less is more" but "clarity beats cleverness".