Yuno
Backend Engineer
Referral-driven backend process — 3 rounds. R1 was an OA mixing DSA and API aggregation. R2 went deep on Node.js vs Go, goroutines, and databases. R3 covered SOLID, deployment (Docker, AWS ECS/EC2, blue-green, canary), and a live palindrome in Go. Did well but was ultimately rejected.
Online assessment with two problems: a basic DSA question and a practical problem involving calling an external API, collecting and aggregating the response data, sorting it, and returning the top-N elements.
Questions asked
- Basic DSA problem (arrays / strings)
- Call an API endpoint, collect paginated/batched response data, sort the results, and return the top-N elements efficiently
Tips
For the API aggregation problem, handle pagination cleanly and think about sort stability and efficiency when N is much smaller than the total dataset — a min-heap of size N beats sorting everything.
Deep technical round covering Go internals, concurrency, Node.js vs Go trade-offs, and database fundamentals. Also included an experience discussion.
Questions asked
- Comparison of Node.js and Golang — when would you pick one over the other?
- Defer in Golang — how does it work and what are common use cases?
- Goroutines — how they differ from threads, the Go scheduler (M:N model)
- Mutex in Golang — when to use sync.Mutex vs channels for synchronisation
- ACID properties — explain each and how they apply to real transactions
- Experience discussion — walked through past projects and technical decisions
Tips
Be precise about goroutines vs OS threads — interviewers at Go-heavy companies probe deeper than just 'goroutines are lightweight'. Know when to use mutex vs channels: mutex for shared state, channels for communication.
Broad round covering software design principles, deployment pipelines, Go language specifics, seniority/career questions, and a live coding problem — writing a palindrome checker in Go.
Questions asked
- SOLID principles — explain each with examples from your own codebase
- Describe your current company's deployment process
- Docker — how you use it and how images/containers work
- AWS ECS vs EC2 — when would you choose one over the other?
- Blue-green deployment vs canary deployment — differences and trade-offs
- Definition of interfaces and structs in Go — how they differ and when to use each
- How do you assess your own seniority as an engineer?
- Why are you leaving your current job?
- Live code: write a palindrome checker in Golang
Tips
The seniority question is a maturity check — talk about ownership, impact, and knowing what you don't know rather than just years of experience. For the palindrome in Go, use a two-pointer approach on a rune slice to handle Unicode correctly.
Overall advice
Yuno's process is Go-heavy from R2 onwards — brush up on goroutines, mutexes, defer, and interfaces before interviewing. R3 mixes deployment knowledge with soft questions; have a clear, honest answer for why you're switching. Three strong rounds and still rejected — the bar is high, possibly headcount-driven.