Google Backend Engineer Interview Experience: Bangalore Onsite (Rejected)

GoogleBackend Software Engineer·Bangalore, India·Interviewed April 2021No offer

Updated July 17, 2026

This account covers a Backend Engineer interview loop at Google's Bangalore office. The process opened with a recruiter phone screen, moved through a single technical round the candidate called an "elimination round" that decided onsite eligibility, and closed with a three-round onsite loop roughly three weeks later.

The candidate solved most of the individual problems but was ultimately rejected. Feedback pointed to a missed edge case and slower pacing in the first onsite round, plus running out of time while coding a graph problem in the third round even after explaining the correct approach verbally.

How the process went

Recruiter screen
A recruiter ran a short call covering baseline algorithm-complexity and estimation questions before advancing the candidate to a technical round.
Elimination round
A single technical round, which the candidate described as an elimination round, tested a tree-traversal problem; passing it made the candidate eligible for the onsite loop.
Onsite prep gap
About three weeks passed between the elimination round and the onsite loop, which the candidate spent preparing.
Onsite loop
The onsite consisted of three back-to-back technical rounds covering a trie/DFS string problem, a priority-queue scheduling problem, and a graph/union-find problem.
Decision
The recruiter called the next day to say the team was not moving forward, after mixed results across the three onsite rounds.

Recruiter Screen

Baseline algorithm-complexity and quick estimation, run by the recruiter rather than an engineer

What is the time complexity of merge sort in the best, average, and worst case?
When would you use BFS to find the shortest path, and in what kind of graph does that apply?
Estimate 2^22 without a calculator.

Elimination Round (Technical Phone Screen)

Tree traversal with a custom scoring rule

Given a binary tree, find the length of the longest arithmetic-progression path from a top node down to a bottom node.
Follow-up: how would the approach change if the same idea were applied to a tree that branches sideways, turning it into an n-ary tree instead of top-to-bottom binary levels?

Candidate solved the primary question using a BFS-based approach.

Onsite Round 1

Trie and DFS over a set of strings

Given a set of words, find the longest sequence where each word is the previous word plus exactly one new character (a pattern similar to LeetCode's Longest String Chain).

Candidate solved it using a trie plus depth-first search but missed an edge case and was told the code quality, efficiency, and pace all needed improvement.

Onsite Round 2

Greedy scheduling with a priority queue

Design a single processor that always picks up the queued job with the shortest duration among jobs already available to run, given jobs as [jobId, startTime, duration].
Follow-up: how would the design change with two processors instead of one?

Candidate finished the core solution in about 15 minutes using a priority queue and a timer, then extended it to two processors by adding more timers; feedback on this round was positive.

Onsite Round 3

Graph connectivity / union-find

A problem the candidate later identified as matching LeetCode 947, Most Stones Removed with Same Row or Column.

Candidate had not seen the problem before, explained the approach correctly within 5-10 minutes, but got stuck partway through coding and ran out of time.

Key takeaways

Treat early-stage elimination phone screens as a full gate, not a formality; it decided onsite eligibility on a single problem here.
State edge cases out loud before writing code; a missed edge case was called out even though the overall solution was correct.
Being able to explain a correct approach clearly does not guarantee enough time to finish coding it; practice converting explanation into working code under a visible clock, especially for union-find or graph problems.
Expect follow-up variants that reshape the same problem, such as a top-down binary tree turned into an n-ary structure, rather than a brand-new question.
Recruiter screens can include quick mental-math and complexity questions, not just behavioral talk — be ready for them from the very first call.

Practice a Google interview

Rehearse out loud against the kinds of questions in this story — with an AI interviewer that asks follow-ups.

Practice this interview

Source

The questions and process facts come from the candidate's public write-up, linked below. The retelling above is our own summary.

Candidate's public write-up on LeetCode Discuss