Go (Golang) Interview Questions

1. What is Go and what problems was it designed to solve?

2. What are goroutines and how do they differ from OS threads?

3. What are channels in Go and how do they enable communication between goroutines?

4. What is the difference between buffered and unbuffered channels in Go?

5. What is the select statement in Go and when do you use it?

6. What is a slice in Go and how does it differ from an array?

7. How does the underlying array, length, and capacity of a Go slice work?

8. What is a map in Go and is it safe for concurrent use?

9. What are Go interfaces and how does implicit implementation work?

10. What is the empty interface (interface{} / any) in Go and when is it used?

11. What is a struct in Go and how does struct embedding provide composition?

12. What is the difference between a value receiver and a pointer receiver in Go?

13. How does error handling work in Go and why does it not use exceptions?

14. What are panic, recover, and defer in Go and how do they interact?

15. How does the defer statement work and in what order do deferred calls run?

16. What is the Go garbage collector and how does it manage memory?

17. What is escape analysis in Go and how does it decide stack vs heap allocation?

18. What is a WaitGroup in Go and how does it coordinate goroutines?

19. What is a Mutex in Go and how does it differ from a channel for synchronization?

20. What is the Go memory model and what does the happens-before relationship mean?

21. What is a context in Go and how is it used for cancellation and deadlines?

22. What is the difference between concurrency and parallelism in Go?

23. How does the Go scheduler work with its GMP model?

24. What are Go generics and how do type parameters and constraints work?

25. What is the difference between make and new in Go?

26. How do you detect and avoid race conditions in Go?

27. What is a nil pointer, nil slice, and nil map in Go and how do they behave?

28. What are Go modules and how does dependency management work?

29. What is the difference between exported and unexported identifiers in Go?

30. How does Go handle testing and what does the testing package provide?

31. What is a goroutine leak and how do you detect one in production?

32. How does context cancellation propagate through a Go call tree, and where does propagation typically break?

33. What causes channel deadlocks in Go, and what are the subtle pitfalls of select?

34. When should you use sync.Pool, and how does it interact with escape analysis and the GC?

35. How does the Go race detector work, and what are its limits in a real codebase?

36. How does slice aliasing with append cause surprising bugs in Go, and how do you avoid them?

37. Why can a Go interface value be non-nil while holding a nil pointer, and how do you avoid the trap?

38. How do you design error wrapping in Go, and when do you use errors.Is versus errors.As?

39. How do you profile a Go service with pprof to find a real bottleneck?

40. How do you implement graceful shutdown in a Go service so in-flight work is not lost?

41. Why does GOMAXPROCS matter when running Go in containers with CPU limits?

42. How do you tune the Go garbage collector with GOGC and GOMEMLIMIT in a memory-constrained service?

43. How do you write Go benchmarks you can actually trust, and what makes a benchmark misleading?

44. How do you configure timeouts and connection reuse correctly for net/http servers and clients in Go?

45. How does the database/sql connection pool behave in Go, and how do you configure it for a production service?

46. When do you reach for the Go execution tracer instead of pprof, and what does it show you?

47. When does sync.RWMutex hurt more than it helps, and what are the alternatives under contention?

48. How do you bound concurrency and propagate the first error across parallel work in Go?

49. What goes wrong with encoding/json in production Go services, and how do you handle it?

50. How do you manage dependency upgrades, private modules and supply-chain safety in Go?

51. How do you build small, reproducible Go binaries for containers, and what breaks with CGO and cross-compilation?

52. How do you keep a large Go test suite deterministic, parallel and free of flakes?

53. How does sync.Once work, and where does lazy initialisation go wrong in Go?

54. When should you use sync/atomic instead of a mutex in Go?

55. How do goroutine stacks grow in Go, and what does that cost?

56. Why can time.After leak in a select loop, and what should you use instead?

57. How do method sets and addressability decide whether a Go type satisfies an interface?

58. What does reflection cost in Go, and when is it justified?

59. How do struct field alignment and padding affect memory use in Go?

60. Why do string and []byte conversions allocate in Go, and how do you avoid the cost?

61. How does a Go map grow, and why does deleting keys not return memory?

62. When is sync.Map the right choice over a mutex-guarded map in Go?

63. What are the rules for using unsafe.Pointer, and where does runtime.KeepAlive come in?

64. What does cgo actually cost in a Go service, and when would you still use it?

65. How do build tags and cross-compilation work in Go, and where do they bite?

66. How do you tune http.Transport for outbound traffic in a Go service?

67. What are the io.Reader and io.Writer contracts, and how do people break them?

68. What goes wrong with t.Parallel and table-driven subtests in Go?

69. Which GODEBUG and runtime knobs actually help during a Go production incident?

70. Why does a panic in a background goroutine kill the whole Go process, and how do you handle it?

71. How do vendoring, go.sum and workspaces change what a Go build actually compiles?

72. How does profile-guided optimisation work in Go, and how would you adopt it?

73. How do you design a worker pool with real backpressure in Go?