What Real Golang Interview Questions Reveal About Candidate Skills

Interview Context

The interviewee had five years of professional experience, including more than three years of Go (Golang) development, and was being considered for a senior position that could lead technical direction.

Technical Questions and Expected Answers

Encryption used when integrating third‑party payment channels

In most payment‑gateway integrations the common pattern is to use an asymmetric algorithm (e.g., RSA or ECC) to exchange a symmetric session key, then encrypt the actual payload with a fast symmetric cipher such as AES‑CBC/CTR/GCM. The client typically calls a library‑provided wrapper that performs the RSA key‑exchange, derives the AES key, and encrypts the request body before sending it over HTTPS.

Photo‑search (image‑to‑question) implementation

A typical workflow consists of the following steps:

Client captures an image and sends the binary data (often base64‑encoded) to a backend service.

The service performs preprocessing (resize, normalization) and runs a convolutional neural network (CNN) to extract a feature vector.

The vector is compared against an indexed database of question embeddings using a similarity metric such as cosine similarity or Euclidean distance.

The service returns the top‑N most similar questions, optionally with a confidence score.

Understanding each stage—data transfer, feature extraction, indexing, and similarity scoring—demonstrates depth of knowledge.

HTTP vs gRPC for microservice communication

Key trade‑offs include:

Protocol format : HTTP/1.1 uses text‑based headers and typically JSON payloads; gRPC uses HTTP/2 with binary protobuf messages, which reduces payload size and parsing overhead.

Performance : gRPC generally offers lower latency and higher throughput because of multiplexed streams and binary encoding.

Streaming : gRPC natively supports client‑, server‑, and bidirectional streaming, which is cumbersome with plain HTTP.

Tooling and ecosystem : HTTP is universally supported and easier to debug with browsers; gRPC requires protobuf definitions and generated stubs but provides strong typing.

Interoperability : If external consumers are not Go‑centric, HTTP/JSON may be preferred.

Passing structs by pointer vs by value in Go

Guidelines:

Use a pointer when the struct is large (e.g., > 64 bytes) to avoid copying the entire value on each call.

Use a pointer when the function needs to modify the original struct or share mutable state.

Use a value when the struct is small, immutable, or when you want to guarantee that the callee cannot affect the caller’s data.

Passing a value creates a copy of the struct’s fields; the copy’s underlying data (e.g., slices, maps) still references the same backing arrays or maps, which can lead to subtle sharing bugs.

Arrays vs slices and slice capacity growth

Differences:

An array has a fixed length that is part of its type (e.g., [5]int); a slice is a descriptor containing a pointer to an underlying array, a length, and a capacity.

Slices provide dynamic resizing; when append exceeds the current capacity, Go allocates a new underlying array, typically doubling the capacity (or 1.5× for large slices), copies existing elements, and updates the slice header.

Because slices hide the underlying array, they are safer and more ergonomic, which is why most Go code prefers slices over raw arrays.

Deeper topics that may follow

Interviewers often probe further into Go’s concurrency model, such as:

The implementation of goroutine as a lightweight user‑space thread managed by the Go scheduler (M:N model).

How the scheduler maps goroutines (M) onto OS threads (N) and performs work‑stealing.

Comparison of goroutine scheduling overhead with traditional OS threads in languages like Java or C++.

Key Observations from the Interview

The candidate answered most questions at a superficial implementation level, without discussing underlying principles, architectural trade‑offs, or upstream/downstream interactions. This limited the interviewer's ability to assess depth of understanding.

Practical Recommendations for Candidates

When describing projects, focus on concrete technical challenges, design decisions, and the rationale behind chosen solutions.

Strengthen core Go fundamentals: pointer semantics, slice internals, concurrency primitives, and the differences between HTTP/JSON and gRPC/protobuf.

Be prepared to explain end‑to‑end workflows (e.g., payment encryption, image‑search pipelines) rather than only the API call you made.

Practice articulating trade‑offs (performance, compatibility, maintainability) for architectural choices.

During the interview, ask clarifying questions about the problem domain to demonstrate curiosity about the larger system.