Question 1

Is Gin still the best choice for Go APIs in 2026, or should I use Echo / Fiber / stdlib?

Accepted Answer

For most general-purpose microservices, Gin remains the safe default in 2026 — the largest community, the most middleware (gin-contrib/*), and almost every Go shop in India runs it somewhere. Pick Echo if you prefer its slightly cleaner API, Fiber only when fasthttp's tradeoffs are acceptable (no HTTP/2, no http.Handler compat), and stdlib net/http (with Go 1.22's improved ServeMux) for tiny services or libraries where dependencies matter.

Question 2

How much does a Go/Gin developer earn in India?

Accepted Answer

₹10-28 LPA in 2026 for mid-to-senior backend developers with Go + Gin as primary stack. Top payers are fintechs and crypto: Razorpay, PhonePe, CRED, Zerodha, CoinSwitch, CoinDCX. Microservices and infra-platform roles trend towards the upper end.

Question 3

Which Go version should I use with Gin in 2026?

Accepted Answer

Go 1.23 is the sweet spot — Gin v1.10+ works on Go 1.21+, and 1.23 gives you better PGO support, improved range-over-function iterators, and the production-ready slog package. Go 1.22's improved ServeMux is also stable now, which is good to know for comparison questions in interviews.

Question 4

Should I learn net/http before Gin?

Accepted Answer

Yes, briefly. Understanding http.Handler, http.ResponseWriter, and *http.Request gives you the mental model for why Gin works the way it does — gin.Context wraps these, and any production deployment uses http.Server directly for graceful shutdown. You don't need to be expert in stdlib routing, just the request/response types.

Question 5

How does Gin handle HTTP/2 and HTTP/3 (QUIC)?

Accepted Answer

Gin sits on top of Go's net/http, which has had HTTP/2 since 2016 (automatic over TLS). HTTP/3 is supported via the third-party quic-go/http3 package — you wrap your Gin engine in http3.Server. In most production deployments, HTTP/2 and HTTP/3 are terminated at a load balancer (Cloudflare, GCP L7 LB) and the backend speaks HTTP/1.1 internally, so Gin's protocol support rarely matters in practice.

Question 6

What is Gin and what problems does it solve?

Accepted Answer

Gin is a high-performance HTTP web framework for Go, released in 2014. It solves three problems with the standard library's net/http: (1) routing is verbose — net/http doesn't support path parameters or method-based dispatch natively, (2) repetitive plumbing — parsing JSON, validating input, writing responses, and handling errors needs the same boilerplate in every handler, (3) middleware composition is awkward — you end up wrapping http.Handler in a chain of closures. Gin replaces this with a httprouter-derived radix tree for O(log n) route matching, a single gin.Context that exposes binding/validation/response helpers, and a clean Use()/group middleware chain. It claims ~40× the throughput of Martini and stays competitive with Fiber and Echo in benchmarks while keeping the API surface small.

Question 7

How do you set up a basic Gin server with routes?

Accepted Answer

Create a *gin.Engine via gin.Default() (includes Logger + Recovery middleware) or gin.New() (no middleware), register handlers with HTTP-verb methods, then call Run(). Each handler takes a *gin.Context. Path parameters are declared with :name and accessed via c.Param("name"). Wildcards use *name and capture the remainder of the path.

Question 8

What is gin.Context and what does it contain?

Accepted Answer

gin.Context is the per-request struct passed to every handler. It wraps the underlying http.Request and http.ResponseWriter and adds Gin-specific helpers: path/query/form parameters (Param/Query/PostForm), request body binding (ShouldBindJSON, ShouldBindQuery), response writers (JSON, XML, String), the middleware control flow (Next, Abort, IsAborted), per-request key/value storage (Set/Get) for sharing data across middleware, and access to the chain of errors via c.Errors. Crucially, the *gin.Context is only valid for the duration of the request — Gin pools and reuses them via sync.Pool, so you must NEVER store one past the handler return, and must call c.Copy() before passing it into a goroutine.

Question 9

How do you bind JSON request bodies in Gin?

Accepted Answer

Define a Go struct with json tags and (optionally) binding tags, then call c.ShouldBindJSON(&dst). Gin reads the body, unmarshals JSON, and runs validator.v10 on the binding tags. Use ShouldBindJSON over the older BindJSON — the latter automatically writes a 400 response on failure, which breaks any handler that wants to format its own error envelope. Always check the returned error and return early.

Question 10

How do you handle query, form, and URI parameters?

Accepted Answer

Three distinct binding paths: c.ShouldBindQuery for ?a=1&b=2 query strings, c.ShouldBind (auto-detects from Content-Type) for application/x-www-form-urlencoded or multipart, and c.ShouldBindUri for path parameters declared as :name. Each uses a different struct tag — `form:"a"` for query/form, `uri:"id"` for path. For one-off reads without a struct, c.Query("a") and c.PostForm("b") work too. The struct-binding form is preferred for anything more than two fields because validator.v10 runs only on tags.

Question 11

What is middleware in Gin and how is it registered?

Accepted Answer

Middleware in Gin is just a func(*gin.Context) — same signature as a handler. Register it with Use() on the engine (applies globally), on a RouterGroup (applies to all routes in the group), or in the handler list of a single route. Inside, call c.Next() to invoke the next handler in the chain and run code after it returns, or c.Abort() to short-circuit. gin.Default() pre-wires Logger and Recovery; in production you typically add auth, request-ID, CORS, GZIP, and tracing middleware on top.

Question 12

How do you serve static files and HTML templates in Gin?

Accepted Answer

Use r.Static("/assets", "./public") to mount a directory under a URL prefix, r.StaticFile("/favicon.ico", "./favicon.ico") for a single file, and r.StaticFS for a custom http.FileSystem (useful with embed.FS in Go 1.16+). For HTML, call r.LoadHTMLGlob("templates/*.html") at startup and render with c.HTML(200, "index.html", gin.H{...}). In production, you'd usually offload static serving to nginx or a CDN — r.Static is convenient but not optimised for high-fanout asset delivery.

Question 13

How do you handle file uploads in Gin?

Accepted Answer

Single-file uploads use c.FormFile("field") which returns a *multipart.FileHeader, then c.SaveUploadedFile(file, dst) to persist. For multiple files use c.MultipartForm(). Set the engine's MaxMultipartMemory (default 32 MiB) to bound how much is buffered in RAM before spilling to disk. For streaming uploads larger than ~50 MiB, open the file with hdr.Open() and io.Copy into the destination yourself instead of using SaveUploadedFile.

Question 14

How do you set status codes and return different response types?

Accepted Answer

Gin provides typed helpers on *gin.Context: c.JSON(code, obj), c.XML, c.YAML, c.ProtoBuf, c.String(code, format, args...), c.Data(code, mime, bytes) for raw bytes, c.Redirect(code, url), and c.Status(code) when you'll write the body manually. c.AbortWithStatusJSON(code, obj) is a common shortcut from middleware — it writes the response AND prevents downstream handlers from running. Once you've written headers (via Status or any of the writers), you cannot change them — Gin's Writer wraps http.ResponseWriter and tracks Written() to enforce this.

Question 15

What's the difference between gin.Default() and gin.New()?

Accepted Answer

gin.New() returns an Engine with NO middleware attached. gin.Default() returns the same Engine but pre-registered with two middlewares: gin.Logger() (writes a one-line access log per request to os.Stdout) and gin.Recovery() (recovers from any panic in a handler and returns 500 instead of crashing the server). For production, most teams use gin.New() and add their own structured logger (zerolog, zap) and a customised recovery middleware that reports to Sentry / OTel. The default Logger uses fmt.Fprintf to stdout — fine for dev, slow and unstructured for production.

Gin Interview Questions

What is Gin and what problems does it solve?

How do you set up a basic Gin server with routes?

What is gin.Context and what does it contain?

How do you bind JSON request bodies in Gin?

How do you handle query, form, and URI parameters?

What is middleware in Gin and how is it registered?

How do you serve static files and HTML templates in Gin?

How do you handle file uploads in Gin?

How do you set status codes and return different response types?

What's the difference between gin.Default() and gin.New()?

How do you organise routes into groups in Gin?

How does Gin's router (httprouter trie) work under the hood?

What is the difference between c.Next() and c.Abort() in Gin middleware?

Why must you call c.Copy() before passing *gin.Context into a goroutine?

How does panic recovery work in Gin, and how would you customise it?

How do custom validators work with validator.v10 in Gin?

How do you propagate context cancellation through a Gin handler?

How do you implement JWT authentication middleware in Gin?

How would you implement graceful shutdown in a Gin server?

How do you write unit and integration tests for Gin handlers?

How does Gin compare to Echo, Fiber, Chi, and net/http stdlib?

How do you implement structured logging in Gin (zap, zerolog, slog)?

How do you build idiomatic error handling using c.Error and the Errors stack?

How do you handle CORS in Gin?

How would you integrate OpenTelemetry / distributed tracing with Gin?

How do you optimise a Gin service for high-throughput (50k+ RPS) production workloads?

How would you architect a multi-tenant SaaS on Gin with strong isolation guarantees?

How do you achieve goroutine-safe access to shared state in Gin handlers (sync.Pool, sync.Map)?

How do you implement distributed rate limiting across multiple Gin instances?

How do you implement end-to-end distributed tracing in a fleet of Gin microservices (e.g. payments → inventory → fulfilment)?

Companies Hiring Gin

Salary Insights

Frequently Asked Questions

Is Gin still the best choice for Go APIs in 2026, or should I use Echo / Fiber / stdlib?

How much does a Go/Gin developer earn in India?

Which Go version should I use with Gin in 2026?

Should I learn net/http before Gin?

How does Gin handle HTTP/2 and HTTP/3 (QUIC)?

Introduction