Top 50 Go (Golang) Interview Questions 2026

Last Updated: June 2026 | Level: Freshers to 3 Years Experience | Read Time: ~22 min

Go is the dominant language for backend microservices at Indian product companies. Razorpay, ShareChat, Meesho, and Flipkart all run Go in production. Candidates report these questions appearing frequently in backend engineering interviews at these companies. This guide covers 50 questions from basic syntax to advanced concurrency, with full code answers and predict-the-output problems. Confirm current Go version requirements on the official careers portal of the company you are targeting.

Pair this with Python Interview Questions 2026 and Docker Interview Questions 2026 for a complete backend preparation stack.

---

Table of Contents

1. Go Basics (Q1-Q12)
2. Functions and Interfaces (Q13-Q22)
3. Concurrency: Goroutines and Channels (Q23-Q35)
4. Memory and Error Handling (Q36-Q43)
5. Advanced Patterns (Q44-Q50)
6. Mock Interview: 5 Questions
7. FAQ

---

Go Basics

Q1. What is Go and what makes it different from Java or Python? Easy

Feature	Go	Java	Python
Compilation	Compiles to native binary	Compiles to JVM bytecode	Interpreted
Concurrency	Goroutines + channels (built-in)	Threads + synchronized	GIL limits true parallelism
Garbage collection	Yes, low-pause	Yes	Yes
Generics	Yes (since 1.18)	Yes	Duck typing
Startup time	Near-instant	JVM warm-up	Near-instant

Go's key advantage: lightweight goroutines (~2 KB stack) let you spawn millions of concurrent tasks without the overhead of OS threads.

---

Q2. What is the zero value of a variable in Go? Easy

var i int       // 0
var f float64   // 0.0
var b bool      // false
var s string    // ""
var p *int      // nil
var sl []int    // nil
var m map[string]int // nil

This prevents uninitialized variable bugs common in C/C++.

---

Q3. What is the difference between var, :=, and const? Easy

// var: explicit declaration, can be at package level
var name string = "Aditya"
var count int  // zero value: 0

// := short assignment, only inside functions
age := 25  // type inferred as int

// const: compile-time constant, cannot be changed
const Pi = 3.14159
const MaxRetries = 3

:= cannot be used at package level. const values must be known at compile time.

---

Q4. What is a slice in Go? How is it different from an array? Easy

// Array: fixed size, value type
arr := [3]int{1, 2, 3}

// Slice: dynamic, reference type
sl := []int{1, 2, 3}
sl = append(sl, 4)  // grows if needed

// Slice from array
sub := arr[1:3]  // [2, 3], shares underlying array
sub[0] = 99
fmt.Println(arr)  // [1 99 3] - modified!

Key insight: slices share the underlying array. Modifying a slice element modifies the original array.

---

Q5. What does make do in Go? Easy

sl := make([]int, 5)        // len=5, cap=5
sl2 := make([]int, 3, 10)   // len=3, cap=10

m := make(map[string]int)   // empty, usable map
ch := make(chan int, 10)     // buffered channel, cap 10

Using a nil map for writes causes a panic - always make your maps.

---

Q6. What is the defer statement? When does the deferred function execute? Medium

func readFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close()  // guaranteed cleanup
    // ... use f
    return nil
}

// LIFO order
func main() {
    defer fmt.Println("third")
    defer fmt.Println("second")
    defer fmt.Println("first")
    // Output: first, second, third
}

---

Q7. What is a pointer in Go? How do you pass by reference? Easy

x := 10
p := &x        // p is *int, holds address of x
fmt.Println(*p) // 10 - dereference
*p = 20
fmt.Println(x) // 20 - original modified

// Passing by reference
func double(n *int) {
    *n *= 2
}
double(&x) // x is now 40

Go has no pointer arithmetic (unlike C), making it safer.

---

Q8. Predict the output: Easy

package main
import "fmt"

func main() {
    s := []int{1, 2, 3}
    a := s
    a[0] = 99
    fmt.Println(s[0])
}

Output: 99

Explanation: Both s and a point to the same underlying array. Modifying a[0] modifies the shared data, so s[0] reflects the change.

---

Q9. What are variadic functions? Easy

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

sum(1, 2, 3)         // 6
sum(1, 2, 3, 4, 5)   // 15

sl := []int{10, 20, 30}
sum(sl...)           // spread slice: 60

---

Q10. What is range in Go? Easy

nums := []int{10, 20, 30}
for i, v := range nums {
    fmt.Printf("index %d = %d\n", i, v)
}

m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
    fmt.Println(k, v)
}

// Ignore index with _
for _, v := range nums {
    fmt.Println(v)
}

---

Q11. How do you handle multiple return values? Easy

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)
}
fmt.Println(result) // 5

This is Go's idiomatic error handling - no exceptions.

---

Q12. What are named return values? Medium

func minMax(arr []int) (min, max int) {
    min, max = arr[0], arr[0]
    for _, v := range arr[1:] {
        if v < min { min = v }
        if v > max { max = v }
    }
    return  // naked return
}

Use sparingly - named returns reduce clarity in longer functions.

---

Functions and Interfaces

Q13. What is an interface in Go? Medium

type Animal interface {
    Sound() string
    Name() string
}

type Dog struct{ name string }
func (d Dog) Sound() string { return "Woof" }
func (d Dog) Name() string  { return d.name }

type Cat struct{ name string }
func (c Cat) Sound() string { return "Meow" }
func (c Cat) Name() string  { return c.name }

func describe(a Animal) {
    fmt.Printf("%s says %s\n", a.Name(), a.Sound())
}

describe(Dog{"Rex"})  // Rex says Woof
describe(Cat{"Luna"}) // Luna says Meow

---

Q14. What is the empty interface interface{} (or any)? Medium

func printAnything(v any) {
    fmt.Printf("type=%T value=%v\n", v, v)
}

printAnything(42)
printAnything("hello")
printAnything([]int{1, 2, 3})

To get the concrete type back, use a type assertion or type switch.

---

Q15. What is a type assertion and a type switch? Medium

var i interface{} = "hello"

// Type assertion
s, ok := i.(string)
if ok {
    fmt.Println(s) // "hello"
}

// Type switch
switch v := i.(type) {
case string:
    fmt.Println("string:", v)
case int:
    fmt.Println("int:", v)
default:
    fmt.Printf("unknown type: %T\n", v)
}

A failed type assertion without ok causes a panic.

---

Q16. What are methods in Go? Explain pointer receivers vs value receivers. Medium

type Counter struct{ count int }

// Value receiver - works on copy
func (c Counter) Value() int {
    return c.count
}

// Pointer receiver - modifies original
func (c *Counter) Increment() {
    c.count++
}

c := Counter{}
c.Increment()
c.Increment()
fmt.Println(c.Value()) // 2

Rule of thumb: if a method needs to mutate the struct or the struct is large, use pointer receiver. Use pointer receivers consistently for a type to avoid interface confusion.

---

Q17. What is function composition and higher-order functions in Go? Medium

// Function type
type Transform func(int) int

func apply(nums []int, fn Transform) []int {
    result := make([]int, len(nums))
    for i, v := range nums {
        result[i] = fn(v)
    }
    return result
}

double := func(n int) int { return n * 2 }
squared := func(n int) int { return n * n }

nums := []int{1, 2, 3, 4}
fmt.Println(apply(nums, double))  // [2 4 6 8]
fmt.Println(apply(nums, squared)) // [1 4 9 16]

---

Q18. What are closures in Go? Medium

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

c1 := counter()
c2 := counter()
fmt.Println(c1(), c1(), c1()) // 1 2 3
fmt.Println(c2(), c2())       // 1 2

Each call to counter() creates an independent count variable captured by the returned closure.

---

Q19. Predict the output: Medium

package main
import "fmt"

func main() {
    funcs := make([]func(), 3)
    for i := 0; i < 3; i++ {
        i := i  // shadow
        funcs[i] = func() { fmt.Println(i) }
    }
    for _, f := range funcs {
        f()
    }
}

Output: 0, 1, 2

Explanation: i := i creates a new variable per iteration. Without the shadowing line, all closures would capture the same i and print 3 3 3.

---

Q20. What is embedding in Go? Medium

type Engine struct{ Horsepower int }
func (e Engine) Start() string { return "vroom" }

type Car struct {
    Engine  // embedded
    Brand string
}

c := Car{Engine: Engine{200}, Brand: "Tesla"}
fmt.Println(c.Start())       // promoted method: "vroom"
fmt.Println(c.Horsepower)    // promoted field: 200

---

Q21. What is init() in Go? Medium

var db *sql.DB

func init() {
    var err error
    db, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        log.Fatal(err)
    }
}

Order: package-level variable declarations -> init() -> main().

---

Q22. What is generics in Go (1.18+)? Advanced

// Generic min function
func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

fmt.Println(Min(3, 5))       // 3
fmt.Println(Min(3.14, 2.72)) // 2.72
fmt.Println(Min("a", "b"))   // "a"

// Generic stack
type Stack[T any] struct{ items []T }
func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() T {
    n := len(s.items)
    v := s.items[n-1]
    s.items = s.items[:n-1]
    return v
}

---

Concurrency

Q23. What is a goroutine? How is it different from a thread? Medium

Feature	Goroutine	OS Thread
Initial stack	~2 KB (grows dynamically)	~1-8 MB fixed
Scheduling	Go runtime (cooperative + preemptive)	OS scheduler
Cost to create	Microseconds	Milliseconds
Count feasible	Millions	Thousands
Communication	Channels	Shared memory + mutex

go func() {
    fmt.Println("I run concurrently")
}()

---

Q24. What is a channel? How do buffered and unbuffered channels differ? Medium

// Unbuffered: sender blocks until receiver is ready
ch := make(chan int)
go func() { ch <- 42 }()
v := <-ch  // synchronized

// Buffered: sender blocks only when buffer is full
bch := make(chan int, 3)
bch <- 1  // no block
bch <- 2
bch <- 3
// bch <- 4  // would block, buffer full

fmt.Println(<-bch) // 1

Unbuffered channels guarantee synchronization. Buffered channels decouple send and receive.

---

Q25. What is the select statement? Medium

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() { time.Sleep(1 * time.Second); ch1 <- "one" }()
    go func() { time.Sleep(2 * time.Second); ch2 <- "two" }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println("received", msg1)
        case msg2 := <-ch2:
            fmt.Println("received", msg2)
        }
    }
}

select with a default case is non-blocking.

---

Q26. What is a WaitGroup? Medium

var wg sync.WaitGroup

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        fmt.Printf("worker %d done\n", id)
    }(i)
}
wg.Wait()
fmt.Println("all workers finished")

---

Q27. What is a Mutex? When do you use it vs channels? Medium

type SafeCounter struct {
    mu sync.Mutex
    v  map[string]int
}

func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.v[key]++
}

Go proverb: "Share memory by communicating, don't communicate by sharing memory." Prefer channels for orchestration, mutex for protecting state.

---

Q28. What is a goroutine leak? How do you prevent it? Advanced

// LEAK: goroutine blocks on channel forever if nobody reads
func leak() {
    ch := make(chan int)
    go func() {
        ch <- compute()  // blocks if main returns
    }()
    // forgot to read from ch
}

// FIX: use context for cancellation
func safe(ctx context.Context) {
    ch := make(chan int, 1)
    go func() {
        select {
        case ch <- compute():
        case <-ctx.Done():
            return
        }
    }()
}

Tools: goleak library in tests, runtime.NumGoroutine() monitoring in production.

---

Q29. What is the Go scheduler (GMP model)? Advanced

• G (Goroutine): unit of work
• M (Machine/OS Thread): executes goroutines
• P (Processor): scheduling context, holds a local run queue

GOMAXPROCS (default = number of CPU cores) controls how many M threads run simultaneously. Each P has a local run queue; stealing from other queues balances load.

---

Q30. Predict the output: Advanced

package main
import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    count := 0
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            count++
            mu.Unlock()
        }()
    }
    wg.Wait()
    fmt.Println(count)
}

Output: 1000

Explanation: The mutex ensures only one goroutine increments count at a time, so no race condition occurs. Without the mutex, the output would be unpredictable (likely less than 1000).

---

Q31. What is context.Context? Why is it important? Advanced

func fetchData(ctx context.Context, url string) ([]byte, error) {
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}

// Caller controls timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
data, err := fetchData(ctx, "https://api.example.com")

---

Q32. What are sync.Once and sync.Pool? Advanced

// sync.Once: execute exactly once, thread-safe singleton
var once sync.Once
var instance *Config

func GetConfig() *Config {
    once.Do(func() {
        instance = &Config{loaded: true}
    })
    return instance
}

// sync.Pool: reuse objects to reduce GC pressure
var bufPool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}

func process(data []byte) {
    buf := bufPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufPool.Put(buf)
    }()
    buf.Write(data)
    // use buf
}

---

Q33. What is a pipeline pattern in Go? Advanced

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

// main
c := generate(2, 3, 4)
out := square(c)
for v := range out {
    fmt.Println(v) // 4, 9, 16
}

---

Q34. What is a fan-out / fan-in pattern? Advanced

func fanOut(in <-chan int, n int) []<-chan int {
    channels := make([]<-chan int, n)
    for i := 0; i < n; i++ {
        channels[i] = worker(in)
    }
    return channels
}

func merge(cs ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    merged := make(chan int)
    output := func(c <-chan int) {
        defer wg.Done()
        for v := range c { merged <- v }
    }
    wg.Add(len(cs))
    for _, c := range cs { go output(c) }
    go func() { wg.Wait(); close(merged) }()
    return merged
}

---

Q35. How do you detect race conditions in Go? Advanced

go run -race main.go
go test -race ./...

The race detector instruments memory accesses at runtime and reports concurrent access without synchronization. Enable in CI, not production (10x slowdown, 10x memory).

---

Memory and Error Handling

Q36. How does garbage collection work in Go? Advanced

• Concurrent: runs alongside application goroutines (low pause times)
• Tri-color marking: white (unreachable), grey (found but not scanned), black (reachable)
• Tunable via GOGC env variable (default 100, meaning GC runs when heap doubles)

// Tune GC for throughput-heavy workloads
os.Setenv("GOGC", "200")  // less frequent GC, more memory

// Force GC (rarely needed)
runtime.GC()

// Disable GC (extreme cases)
debug.SetGCPercent(-1)

---

Q37. What is escape analysis in Go? Advanced

// Stack allocation (no escape)
func sum() int {
    x := 42  // stays on stack
    return x
}

// Heap allocation (escapes)
func newInt() *int {
    x := 42  // escapes to heap because address returned
    return &x
}

Check with: go build -gcflags="-m" main.go

---

Q38. How does Go handle errors? What is the idiomatic pattern? Medium

// Custom error type
type ValidationError struct {
    Field   string
    Message string
}
func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed: %s - %s", e.Field, e.Message)
}

// Wrapping errors (Go 1.13+)
if err := db.Query(query); err != nil {
    return fmt.Errorf("fetchUser: %w", err)
}

// Unwrapping
var ve *ValidationError
if errors.As(err, &ve) {
    fmt.Println(ve.Field)
}

// Check specific value
if errors.Is(err, sql.ErrNoRows) {
    return ErrNotFound
}

---

Q39. What is panic and recover? Medium

func safeDivide(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered: %v", r)
        }
    }()
    return a / b, nil
}

v, err := safeDivide(10, 0) // panic recovered
fmt.Println(v, err) // 0 recovered: runtime error: integer divide by zero

Use panic only for unrecoverable programmer errors (nil pointer on init, etc.). Use errors for expected failure cases.

---

Q40. What is the io.Reader and io.Writer interface? Why are they important? Medium

type Reader interface {
    Read(p []byte) (n int, err error)
}
type Writer interface {
    Write(p []byte) (n int, err error)
}

These interfaces are the foundation of Go's I/O ecosystem. Files, HTTP bodies, network connections, and in-memory buffers all implement them - composable without coupling to concrete types.

func processData(r io.Reader) {
    buf := make([]byte, 4096)
    for {
        n, err := r.Read(buf)
        // process buf[:n]
        if err == io.EOF { break }
    }
}
// Works with os.File, bytes.Buffer, net.Conn, http.Response.Body...

---

Q41. What is the stringer interface (fmt.Stringer)? Easy

type Point struct{ X, Y int }

func (p Point) String() string {
    return fmt.Sprintf("(%d, %d)", p.X, p.Y)
}

p := Point{3, 4}
fmt.Println(p)        // (3, 4) - uses String()
fmt.Printf("%v\n", p) // (3, 4)

Implement String() string to control how your type prints.

---

Q42. Predict the output: Medium

package main
import "fmt"

func main() {
    m := map[string]int{"a": 1, "b": 2}
    delete(m, "a")
    v, ok := m["a"]
    fmt.Println(v, ok)
}

Output: 0 false

Explanation: Accessing a deleted (or never-existing) key returns the zero value of the value type and false for the ok idiom. No panic occurs.

---

Q43. What is encoding/json marshaling in Go? Medium

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Age   int    `json:"age,omitempty"` // omit if zero
    Pass  string `json:"-"`             // never marshal
}

u := User{Name: "Aditya", Email: "[email protected]", Age: 0}
data, _ := json.Marshal(u)
fmt.Println(string(data)) // {"name":"Aditya","email":"[email protected]"}

var u2 User
json.Unmarshal(data, &u2)

---

Advanced Patterns

Q44. What is the functional options pattern? Advanced

type Server struct {
    host    string
    port    int
    timeout time.Duration
}

type Option func(*Server)

func WithPort(p int) Option      { return func(s *Server) { s.port = p } }
func WithTimeout(t time.Duration) Option { return func(s *Server) { s.timeout = t } }

func NewServer(host string, opts ...Option) *Server {
    s := &Server{host: host, port: 8080, timeout: 30 * time.Second}
    for _, opt := range opts {
        opt(s)
    }
    return s
}

s := NewServer("localhost", WithPort(9090), WithTimeout(60*time.Second))

---

Q45. What is the worker pool pattern? Advanced

func workerPool(jobs <-chan int, results chan<- int, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := range jobs {
                results <- j * j
            }
        }()
    }
    go func() {
        wg.Wait()
        close(results)
    }()
}

---

Q46. How does Go module system work? Medium

go mod init github.com/user/myproject  # initialize module
go get github.com/some/[email protected] # add dependency
go mod tidy                            # remove unused, add missing
go mod vendor                          # vendor dependencies locally

go.sum contains cryptographic hashes for tamper detection. Never edit it manually.

---

Q47. What is go generate? Medium

//go:generate stringer -type=Direction
type Direction int
const (
    North Direction = iota
    South
    East
    West
)

Run go generate ./... to trigger all generation commands in the project.

---

Q48. What is the difference between os.Exit and panic? Medium

Feature	os.Exit	panic
Deferred functions	NOT executed	Executed
Recovery	Not possible	recover() can catch
Use case	Intentional exit (main errors)	Unrecoverable programmer error
Stack trace	No	Yes

defer fmt.Println("this runs on panic, NOT on os.Exit")
// os.Exit(1)  → deferred function skipped
// panic("err") → deferred function runs, then stack unwinds

---

Q49. What is sync/atomic? When would you use it? Advanced

var hits int64

func handleRequest() {
    atomic.AddInt64(&hits, 1)
    // ...
}

func getHits() int64 {
    return atomic.LoadInt64(&hits)
}

Use atomic for simple scalars. For complex state, prefer mutex or channels.

---

Q50. What is profiling in Go? How do you use pprof? Advanced

import _ "net/http/pprof"

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    // ... app code
}

# CPU profile
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# Heap profile
go tool pprof http://localhost:6060/debug/pprof/heap

# Visualize
go tool pprof -http=:8080 profile.pb.gz

---

Mock Interview: 5 Questions

Work through these timed (2 minutes each) before your interview:

1. Write a function that finds duplicate integers in a slice using a map.
2. Implement a thread-safe LRU cache using a map + doubly linked list.
3. Given a buffered channel of size 3, what happens when you try to send a 4th value without a receiver?
4. Explain the difference between make(chan int) and make(chan int, 1) with a concrete race condition example.
5. How would you implement graceful shutdown for an HTTP server in Go?

---

FAQ

Q: Do I need to know Go internals for fresher interviews? A: Basic GMP model awareness is enough. Focus on goroutines, channels, interfaces, and error handling for fresher rounds. Escape analysis and GC details come up at senior levels.

Q: Is Go replacing Java at Indian companies? A: Not replacing, but new microservices at Razorpay, Meesho, and Flipkart commonly choose Go for latency-sensitive services. Java remains dominant for enterprise codebases.

Q: What online resources are best for Go practice? A: Go by Example (gobyexample.com), the official Tour of Go, and Exercism Go track. For concurrency specifically, the Go blog's "Concurrency Patterns" series.

---

Related reading: Golang Coding Questions 2026 | Python Interview Questions 2026 | Kubernetes Interview Questions 2026 | AWS Interview Questions 2026