Hi everyone, this topic is for sharing Preparation guidelines and interview experience for Google Software Engineer
The Software Engineer role at Google involves a multi-stage assessment and interview process, designed to evaluate both technical skills and business proficiency. Below is a summary of the process and key points from the interviews you provided:
Assessment Test Rounds:
Round 1: Coding Test (YMCA campus, Aug 2024)
2 DSA problems on HackerRank within 90 minutes.
Round 1: Coding Test (ISM Dhanbad, before Apr 2023)
2 questions focusing on Graphs and Dynamic Programming (LeetCode Medium/Hard level).
Interview Rounds:
Round 2: Technical Interview (YMCA)
Array/algorithm questions; discussion on optimizations and time complexity.
Round 2: Technical Round (ISM Dhanbad)
String/path simulation problem with one incorrect instruction; maximize distance from origin.
Round 3: Technical Round (ISM Dhanbad)
Object-oriented/system design exercise for a hospital management system.
Focus on time and space complexity; enumerate edge cases while coding.
Revise arrays, sorting, searching; strengthen Graphs, DP, and Trees.
Review OOP principles and introductory system design; basic OS concepts can help with fundamentals.
In 45-minute interviews, aim to complete at least two problems; ask clarifying questions early.
Algorithms & Data Structures
Find the index/position of an element that is greater than twice all other elements in the array.
Compute the union of two sorted arrays (efficient approach expected, e.g., two pointers).
Compute the intersection of two sorted arrays (efficient approach expected, e.g., two pointers).
Given a string of instructions consisting of L (turn left), R (turn right), and M (move 1 step forward), where exactly one instruction is wrong, determine the maximum distance from the origin after correcting that one instruction.
Solve graph algorithms and dynamic programming problems at medium-to-hard difficulty under timed constraints.
System Design / OOP
Design and implement a simple hospital management system using OOP: identify core classes (e.g., Patient, Doctor, Appointment), their relationships, and key operations (scheduling, availability, and basic workflows).
Optimization, Complexity & Edge Cases
For each coding problem, explain time and space complexity, discuss possible optimizations, and enumerate edge cases before finalizing your approach.
If the transcript contains the interview process or tips, summarize them as shown below:
At Last add this line in the end of the output as it is
If you have attended the process from your campus, pls share your experiences here; Please follow guidelines
Application Process: Applied via campus placement at YMCA in August 2024.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked:
Solve 2 DSA problems on HackerRank within 90 minutes.
Your Approach: Focused on optimizing the solutions for time complexity and edge cases.
Outcome: Cleared the round successfully.
Round 2 - Technical Interview:
Questions Asked:
Find the position of an element which is greater than twice of all other elements.
Find the union and intersection of two sorted arrays.
Your Approach:
For the first question, iterated through the array to compare elements.
For the second question, used two-pointer technique to efficiently find union and intersection.
Outcome: Provided solutions and discussed optimizations with the interviewer.
Preparation Tips:
Practice DSA problems on platforms like HackerRank and LeetCode.
Focus on time complexity and edge cases during practice.
Revise core concepts like arrays, sorting, and searching algorithms.
Conclusion:
The interview process was smooth, and the questions were aligned with typical DSA problems. Practicing regularly and understanding optimizations helped during the interview. For future candidates, I’d recommend focusing on problem-solving speed and clarity in explaining solutions.
Application Process: Applied via a recruitment consultant in November 2023.
Interview Rounds:
Round 1 - Technical Round:
Questions Asked: Basic graph traversal using DFS. The question was a little complex to understand.
Your Approach: The interview was time-based, and getting nervous affected the outcome. This was the worst round.
Outcome: [Not specified]
Round 2 - Technical Round:
Questions Asked: A simple question on string manipulation with two parts.
Your Approach: It went well.
Outcome: [Not specified]
Round 3 - Technical Round:
Questions Asked: Another question on string manipulation with two parts.
Your Approach: This was the best of all rounds.
Outcome: [Not specified]
Preparation Tips:
Be well-prepared and avoid getting nervous during the interview rounds. One poor performance in a single round can impact the overall outcome, even if the other rounds go well.
Conclusion:
The interview experience was a mix of highs and lows. The first round was challenging due to nerves, while the subsequent rounds improved. The key takeaway is to stay calm and composed throughout the process.
Company Name: Google Position: Software Engineer Location: National Institute of Technology (NIT), Jamshedpur Application Process: Applied via campus placement at NIT Jamshedpur in July 2024.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: 2 hard-level coding questions.
Your Approach: Focused on understanding the problem constraints and optimizing the solution for efficiency.
Outcome: Cleared the round.
Round 2 - Technical Round:
Questions Asked: 1 question based on the sliding window technique (easy level).
Your Approach: Implemented the sliding window approach to solve the problem efficiently.
Outcome: Successfully cleared the round.
Round 3 - Technical Round:
Questions Asked: Another sliding window-based question (easy level).
Your Approach: Applied the sliding window technique again, ensuring the solution was optimal.
Outcome: Cleared the round.
Round 4 - Technical Round:
Questions Asked: 1 question involving strings and hashing (easy to medium level).
Your Approach: Used hashing to optimize the string manipulation problem.
Outcome: Cleared the round.
Preparation Tips:
Focus on mastering data structures and algorithms, especially sliding window and hashing techniques.
Practice coding problems from platforms like LeetCode and CodeChef to improve problem-solving speed and accuracy.
Revise core computer science concepts, as they might be tested indirectly in technical rounds.
Conclusion:
The interview process was rigorous but fair. The questions were aligned with the role’s requirements, and the interviewers were supportive. I could have practiced more diverse problems to handle unexpected twists better. For future candidates, consistency in coding practice and a strong grasp of fundamentals are key to cracking such interviews.
Application Process: I applied through a referral and was interviewed in April 2024.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked:
Two coding questions from LeetCode (one easy and one medium difficulty).
Your Approach: I practiced similar problems on LeetCode beforehand, so I was able to solve both questions efficiently. I focused on optimizing my solutions for time and space complexity.
Outcome: Passed this round.
Round 2 - Technical Round:
Questions Asked:
A task to solve, followed by a discussion about Object-Oriented Programming (OOP).
Questions about the Angular framework.
Your Approach: For the OOP task, I explained my thought process clearly and demonstrated my understanding of OOP principles. For the Angular questions, I shared my hands-on experience with the framework and its core concepts.
Outcome: The interviewer seemed satisfied with my responses, but I haven’t received the final results yet.
Preparation Tips:
Practice coding problems on platforms like LeetCode, focusing on easy and medium difficulty questions.
Brush up on core OOP concepts and frameworks relevant to the role (e.g., Angular).
Be prepared to explain your thought process and approach during technical discussions.
Conclusion:
Overall, the interview process was smooth and well-structured. I felt prepared for the coding test, but the technical round required deeper knowledge of frameworks and OOP. If I could do anything differently, I would spend more time on Angular-specific concepts. For future candidates, I recommend thorough preparation in both coding and framework-related topics.
Application Process: Applied via a job portal in April 2024.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: Data Structure & Algorithms
Your Approach: Focused on solving problems efficiently, ensuring optimal time and space complexity.
Outcome: Passed to the next round.
Round 2 - One-on-one Round:
Questions Asked:
Array-based question (specific details not provided).
Binary Tree question (specific details not provided).
Your Approach: Used standard algorithms and data structure techniques to solve the problems, explaining the thought process clearly.
Outcome: Awaiting results.
Preparation Tips:
Practice coding problems on platforms like LeetCode and HackerRank.
Focus on understanding core data structures (arrays, trees, graphs) and algorithms (sorting, searching, dynamic programming).
Mock interviews can help in improving communication and problem-solving speed.
Conclusion:
The interview process was challenging but rewarding. I felt well-prepared for the coding rounds, but I could have practiced more on explaining my thought process aloud during the one-on-one round. For future candidates, I recommend balancing problem-solving with clear communication to stand out.
Application Process: I applied through campus placement in March 2024.
Interview Rounds:
Round 1 - Aptitude Test:
Questions Asked: QA-type questions with multiple-choice options.
Your Approach: I focused on logical reasoning and time management to answer the questions efficiently.
Outcome: Passed this round.
Round 2 - Coding Test:
Questions Asked: Python programming questions.
Your Approach: I practiced Python extensively beforehand and ensured my code was optimized for performance.
Outcome: Passed this round.
Round 3 - Technical Round:
Questions Asked:
What is software computing?
Difference between software computing and hardware computing.
Are there any network variations?
How do you determine if a software product is of good or bad quality?
Your Approach: I answered based on my understanding of software fundamentals and real-world examples.
Outcome: Passed this round.
Round 4 - Aptitude Test:
Questions Asked: QA-type questions with multiple-choice options.
Your Approach: Similar to Round 1, I focused on accuracy and speed.
Outcome: Passed this round.
Round 5 - Group Discussion:
Questions Asked: Discussion on different projects.
Your Approach: I actively participated, shared my ideas, and listened to others’ perspectives.
Outcome: Passed this round.
Round 6 - Case Study Round:
Questions Asked: New projects like coding platforms and other related topics.
Your Approach: I analyzed the case thoroughly and proposed practical solutions.
Outcome: Passed this round.
Round 7 - Coding Test:
Questions Asked: Questions from different coding platforms for testing.
Your Approach: I relied on my problem-solving skills and coding practice.
Outcome: Passed this round.
Preparation Tips:
Focus on Python programming and coding challenges.
Brush up on software computing fundamentals and quality assessment.
Practice aptitude and logical reasoning questions.
Participate in group discussions and case study exercises to improve communication and analytical skills.
Conclusion:
Overall, the interview process was rigorous but well-structured. I felt prepared for most rounds, but I could have practiced more case studies to improve my confidence. My advice to future candidates is to focus on both technical and soft skills, as Google evaluates a holistic skill set. Keep practicing and stay calm during the interviews!
Application Process: I applied via LinkedIn and was interviewed in August 2024.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: How to reverse a linked list.
Your Approach: I explained the iterative approach first, detailing how to traverse the list and reverse the pointers. Then, I also mentioned the recursive approach for completeness.
Outcome: Passed this round.
Round 2 - HR Round:
Questions Asked: How do you grow in your job?
Your Approach: I discussed my commitment to continuous learning, seeking mentorship, and taking on challenging projects to expand my skills.
Outcome: Awaiting results.
Preparation Tips:
Focus on mastering data structures, especially linked lists, as they are commonly tested.
Practice explaining your thought process clearly during coding interviews.
For HR rounds, prepare to articulate your career goals and how you plan to contribute to the company.
Conclusion:
Overall, the interview process was smooth and well-structured. I felt confident in the coding round but realized I could have prepared more for the HR round by researching Google’s culture and values. My advice to future candidates is to balance technical and soft-skills preparation.
Application Process: I was approached by the company for this role.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: A 45-minute coding test with a Leetcode medium-level question.
Your Approach: I solved the problem using efficient algorithms and data structures to ensure optimal performance.
Outcome: Passed this round.
Round 2 - Technical Round:
Questions Asked: A medium-level DSA (Data Structures and Algorithms) coding question.
Your Approach: I carefully analyzed the problem, broke it down into smaller sub-problems, and implemented a solution with clean code.
Outcome: Successfully cleared this round.
Round 3 - Coding Test:
Questions Asked: Another 45-minute coding test with a Leetcode medium-level question.
Your Approach: I focused on writing bug-free code and ensured my solution was scalable.
Outcome: Passed this round as well.
Preparation Tips:
Set interviews during the evening time in IST to increase the chances of getting global interviewers. Indian interviewers are infamously tough.
Conclusion:
Overall, the interview process was challenging but fair. The questions were aligned with what I had prepared, and I felt confident in my approach. For future candidates, I recommend practicing Leetcode medium-level problems thoroughly and ensuring you can write clean, efficient code under time constraints.
Application Process: I was approached by the company for this role and interviewed in August 2024.
Interview Rounds:
Round 1 - One-on-one Technical Round:
Questions Asked:
A graph problem using disjoint set union.
Your Approach: I tackled the problem by first understanding the requirements and then applying the disjoint set union (DSU) data structure to efficiently solve the graph problem. I explained my thought process clearly and walked through the solution step-by-step.
Outcome: The round went well, and I received positive feedback on my problem-solving approach and clarity of explanation.
Preparation Tips:
Focus on mastering data structures, especially graphs and advanced topics like DSU.
Practice explaining your thought process out loud while solving problems.
Solve problems from coding platforms to get comfortable with time constraints.
Conclusion:
Overall, the interview experience was smooth, and the interviewer was very supportive. I felt confident in my approach, but I could have practiced more variations of graph problems to be even better prepared. For future candidates, I’d recommend diving deep into data structures and practicing problem-solving under timed conditions.
Application Process: Applied via LinkedIn and was interviewed in September 2024.
Interview Rounds:
Round 1 - HR Round:
Questions Asked:
Asked about my interest in AI technologies.
General “getting to know you” questions.
Your Approach:
For the AI interest question, I discussed my coursework and personal projects related to AI.
For the general questions, I kept my answers concise and professional, highlighting my passion for software engineering.
Outcome: Passed to the next round.
Round 2 - Coding Test Round:
Questions Asked:
A 45-minute coding algorithm question.
Your Approach:
I practiced similar problems on LeetCode beforehand, so I felt prepared. I focused on understanding the problem first, then wrote clean and efficient code.
Outcome: Awaiting results.
Preparation Tips:
Practice coding problems on platforms like LeetCode to get comfortable with algorithm questions.
Conclusion:
Overall, the interview process was smooth and well-structured. I felt prepared for the coding round due to my practice, but I could have spent more time researching Google’s specific tech stack to tailor my answers better. For future candidates, I recommend focusing on both general coding skills and the company’s core technologies.
Application Process: [Application process details not provided]
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: Leetcode hard, Leetcode medium, and puzzles.
Your Approach: Prepared by practicing similar problems on Leetcode and focusing on optimizing solutions for efficiency.
Outcome: Successfully cleared the round by solving the problems within the given time.
Round 2 - Technical Interview:
Questions Asked:
Word search (Leetcode hard)
Burst balloons (Leetcode hard)
Your Approach: Broke down the problems into smaller sub-problems and used dynamic programming for the “Burst balloons” question. For the “Word search,” employed backtracking to explore all possible paths.
Outcome: Performed well and received positive feedback on problem-solving skills.
Preparation Tips:
Focus on mastering data structures and algorithms, especially dynamic programming and backtracking.
Practice Leetcode hard and medium problems regularly.
Time yourself during practice to simulate interview conditions.
Conclusion:
The interview process was challenging but rewarding. The key to success was consistent practice and understanding the underlying patterns in problems. For future candidates, I’d recommend dedicating ample time to problem-solving and not shying away from tough questions.
Application Process: Applied through an online application process.
Interview Rounds:
Round 1 - One-on-One Technical Interview:
Questions Asked:
Tell me about yourself.
What’s your most complex project?
Your Approach:
For the “Tell me about yourself” question, I focused on my academic background, relevant projects, and my passion for software engineering.
For the “most complex project” question, I discussed a project involving Linux Kernel and automation, highlighting the challenges and how I overcame them.
Outcome: The interviewer seemed engaged, and I felt confident about my responses. Awaiting further updates.
Preparation Tips:
Brush up on Linux Kernel and automation concepts.
Practice explaining your projects clearly, focusing on complexity and problem-solving.
Conclusion:
The interview was a great learning experience. I realized the importance of articulating my thoughts clearly and concisely. For future candidates, I’d recommend preparing thoroughly for technical questions and being ready to discuss your projects in detail.
Application Process: Applied through the company’s career portal.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: Graph and Dynamic Programming (DP) problems, ranging from easy to medium difficulty.
Your Approach: Focused on understanding the problem requirements first, then breaking them down into smaller subproblems. Used standard algorithms and optimized the solutions for time and space complexity.
Outcome: Cleared the round successfully.
Round 2 - One-on-One Technical Interview:
Questions Asked:
Graph problem (Leetcode easy level).
Dynamic Programming problem (Leetcode easy level).
Your Approach: For the graph problem, used BFS/DFS as applicable. For the DP problem, identified the recurrence relation and built the solution bottom-up.
Outcome: Cleared the round and moved forward in the process.
Preparation Tips:
Practiced extensively on Leetcode, focusing on Graph and DP problems.
Revised core algorithms and data structures.
Mock interviews helped in improving problem-solving speed and clarity of thought.
Conclusion:
Overall, the interview process was smooth and well-structured. The key was to stay calm and think logically during the problem-solving rounds. Practicing similar problems beforehand gave me the confidence to tackle the questions effectively. For future candidates, I’d recommend focusing on problem-solving fundamentals and practicing under timed conditions.
Application Process: I applied via LinkedIn and was interviewed in June 2024.
Interview Rounds:
Round 1 - Assignment Round:
Questions Asked: Data structures-related questions.
Your Approach: I tackled the questions by revisiting fundamental data structures concepts and practicing problem-solving techniques.
Outcome: I passed this round and moved on to the next stage.
Round 2 - Coding Test Round:
Questions Asked: Algorithms-based questions, similar to what we covered in classes.
Your Approach: I focused on optimizing my solutions and ensuring I understood the underlying algorithmic principles.
Outcome: The round went well, and I felt confident about my performance.
Preparation Tips:
Revisit core data structures and algorithms concepts.
Practice coding problems regularly to improve problem-solving speed and accuracy.
Focus on understanding the time and space complexity of your solutions.
Conclusion:
Overall, the interview process was challenging but rewarding. I felt well-prepared, but I could have practiced more advanced algorithmic problems to feel even more confident. My advice to future candidates is to start early and practice consistently!
Application Process: Applied through the company’s online portal.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: Find the shortest path in a given scenario. The coding was to be done in a Google doc.
Your Approach: Focused on implementing an efficient algorithm (likely Dijkstra’s or BFS, depending on the problem constraints) and ensuring clarity in the code since it was written in a doc.
Outcome: Passed the round.
Preparation Tips:
Brush up on data structures, especially graphs and algorithms like Dijkstra’s and BFS.
Practice coding in a shared document or whiteboard to simulate the interview environment.
Review system design basics as it might come up in later rounds.
Conclusion:
The interview was challenging but fair. Practicing coding in a doc was a bit different but manageable. Would recommend focusing on problem-solving speed and clarity in explanations.
Application Process: Applied through an online application process.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked:
4 coding questions
Some aptitude questions
Your Approach: Focused on solving the coding questions efficiently, ensuring optimal time and space complexity. For the aptitude questions, relied on logical reasoning and problem-solving skills.
Outcome: Cleared the round successfully.
Preparation Tips:
Strong grasp of algorithms and data structures is crucial.
Practice coding problems on platforms like LeetCode and HackerRank.
Brush up on aptitude and logical reasoning skills.
Familiarize yourself with JavaScript, Computer Science fundamentals, and Software Design principles.
Conclusion:
The interview process was challenging but well-structured. Preparing thoroughly for coding and aptitude questions was key to clearing the first round. For future candidates, I’d recommend dedicating ample time to practice and understanding core concepts deeply.
Application Process: I applied through a recruitment consultant and was interviewed in January 2024.
Interview Rounds:
Round 1 - Technical Round:
Questions Asked: Easy technical question (specific details not provided).
Your Approach: Answered the question confidently, focusing on clarity and correctness.
Outcome: Passed the round.
Round 2 - Aptitude Test Round:
Questions Asked: Questions on Java Spring Boot, Data Structures and Algorithms (DSA), and output-based problems.
Your Approach: Prepared thoroughly with DSA concepts and practiced Spring Boot fundamentals.
Outcome: Successfully cleared the round.
Round 3 - Coding Test Round:
Questions Asked: A 2-hour coding test on HackerRank with camera monitoring.
Your Approach: Focused on problem-solving efficiency and wrote clean, optimized code.
Outcome: Cleared the round.
Preparation Tips:
Brush up on core DSA concepts and algorithms.
Practice coding problems on platforms like HackerRank.
Understand the basics of Java Spring Boot if applying for related roles.
Stay calm and manage time effectively during the coding test.
Conclusion:
Overall, the interview process was smooth, and the questions were aligned with the role’s requirements. I could have practiced more coding problems under time constraints. My advice to future candidates is to focus on problem-solving speed and clarity in technical explanations.
Application Process: Applied via campus placement at ISM Dhanbad before April 2023.
Interview Rounds:
Round 1 - Coding Test:
Questions Asked: 2 questions focusing on Graphs and Dynamic Programming (DP). Difficulty level: Leetcode Medium and Hard.
Your Approach: Prepared by practicing similar problems on Graphs and DP.
Outcome: Cleared the round.
Round 2 - Technical Round:
Questions Asked: Given a string of L, M, R (L: turn left, R: turn right, M: take 1 step forward). One instruction in the string is wrong. Find the maximum distance from the origin after following the path.
Your Approach: Analyzed the problem by considering all possible wrong instructions and calculating the resultant distance.
Outcome: Provided a solution and cleared the round.
Round 3 - Technical Round:
Questions Asked: Write code to effectively manage a hospital system.
Your Approach: Designed a system using OOP principles, focusing on classes like Patient, Doctor, and Appointment.
Outcome: Presented the solution and cleared the round.
Preparation Tips:
Practice Graphs, DP, Trees, and other core data structures.
Learn about system design, OOPs, and OS concepts.
Aim to solve at least 2 questions in the 45-minute interview window. Don’t hesitate to ask the interviewer for clarifications.
Conclusion:
The interview process was challenging but rewarding. Practicing problem-solving and system design helped a lot. For future candidates, focus on core concepts and clear communication during interviews.