Google

I applied for the Software Engineering Intern role through Google's on-campus hiring process. The selection process started with an online coding assessment and was followed by multiple technical interviews. The overall process was heavily focused on Data Structures and Algorithms, with behavioral and Googleyness-related questions also appearing during the later stages. Online Assessment The first stage was the online coding assessment. The assessment consisted of two DSA problems that had to be solved within the given time limit. The problems required careful analysis of the constraints and efficient implementation. I focused on identifying the expected complexity before starting the implementation rather than immediately coding a brute-force solution. After the assessment, a limited number of students were shortlisted for the interview rounds. Technical Round 1 The first technical interview lasted around 45 minutes. The interviewer started with a graph-based problem involving finding a shortest route between two locations subject to a deadline. I modeled the problem as a graph and discussed using BFS because the transitions could be treated uniformly. Before coding, I explained the state representation, traversal strategy and complexity. The interviewer also asked me to consider edge cases and situations where the destination could not be reached within the required time. While dry-running the implementation, I encountered an edge case that required modifying the initial approach. I walked through the issue and adjusted the implementation accordingly. The interviewer also asked a couple of behavioral questions related to leadership and managing college activities. I explained examples from my college experience and how I approached coordinating with other students. The round was challenging because I had to balance algorithmic reasoning, implementation and communication within a limited amount of time. Technical Round 2 The second technical round again focused on DSA. The interviewer gave me another problem involving graph traversal. I first analyzed the possible approaches and explained the complexity before writing the implementation. The problem required careful handling of visited states and graph traversal. I discussed both BFS/DFS-style approaches and selected the one that fit the problem constraints better. The interviewer asked follow-up questions about the complexity and how the solution would behave for larger inputs. The main focus of this round was algorithmic reasoning. The interviewer was interested in how I derived the solution rather than simply whether I knew a particular standard problem. Technical Round 3 The third round was the strongest technical round for me. I was given a Dynamic Programming problem involving a sequence of days, a changing resource level and a fixed number of rest days. The objective was to maximize the total distance covered. I initially formulated the problem recursively by defining the state based on the current day, remaining resource and number of remaining holidays. After establishing the recursive relation, I identified overlapping subproblems and converted the solution into memoized DP. The interviewer then introduced multiple follow-up constraints. These gradually increased the number of parameters in the state, effectively turning the original two-dimensional DP into a three-dimensional DP formulation. I explained the state transition and discussed the resulting time and space complexity before implementing the optimized version. The last part of the interview included Googleyness and leadership questions. I was asked how I would react in situations such as not receiving credit for my work and when I had taken a leadership role in college. I answered these using actual situations rather than giving overly idealized responses. After completing the interview rounds, the results were announced and I was selected for the Google Software Engineering Internship. The process taught me that Google's internship interviews are heavily dependent on the ability to reason about unfamiliar problems. The questions were not simply about recalling standard algorithms. I had to establish the state or graph representation, explain the invariant, analyze complexity, handle edge cases and modify the solution when the interviewer introduced follow-ups. For preparation, I would focus heavily on graphs, trees, BFS/DFS, dynamic programming, binary search, sliding window and common array/string patterns. I would also practice solving problems while explaining the reasoning out loud. Another important part is code quality. During the interviews, I was expected to write readable code and explain the implementation rather than treating the interview as a silent coding contest. The behavioral questions should also not be ignored. Googleyness and leadership questions can appear alongside technical discussions, so having genuine examples from projects, college activities and teamwork experiences is useful. Overall, the process was technically demanding but also very interactive. The interviewers focused on understanding my reasoning and gave follow-up questions that progressively increased the difficulty. Clearing all the rounds and receiving the offer made the entire preparation worthwhile.