Google Interview Questions: 10 Real Q&A + Prep Tips (2026)
Curated Google (Google India) interview questions with model answers.
Industry: Tech Product. Difficulty: Hard. Hiring for: Software Engineer, L3, Software Engineer, L4, Site Reliability Engineer, L3, Technical Solutions Engineer. Average package: ₹40-65 LPA (fresher L3), ₹70-100 LPA (experienced L4).
Selection process
- Online Assessment (Coding + Aptitude/Behavioral)
- Technical Phone Screen (1-2 rounds, DSA focus)
- Onsite Interview Loop (4-5 rounds: 3-4 DSA, 1 System Design, 1 Googleyness/Behavioral)
- Team Matching
- Compensation Negotiation & Offer
Real interview questions and answers
Technical: Given a binary tree, find the maximum path sum. A path can start and end at any node in the tree.
This problem uses recursion. For each node, recursively calculate the maximum path sum for its left and right children. A path through the current node can be: node value alone, node + left path, node + right path, or node + left path + right path. The global maximum path sum is updated at each node. The function should return the maximum path sum that *can be extended upwards* (node + max(left_path, right_path, 0)) to avoid negative contributions, while simultaneously updating a global variable for the overall maximum.
Technical: Design a data structure that supports insert, delete, search, and `getRandom` in O(1) average time.
Use a combination of a `HashMap` and an `ArrayList`. The `HashMap` stores `(value, index_in_list)` pairs, allowing O(1) insert and search. The `ArrayList` stores the actual values. For `getRandom`, pick a random index from the `ArrayList`. For `delete(val)`, find its index `idx` from the map. Swap `val` with the last element in the `ArrayList`, update the map for the swapped element, then remove the last element from the list and `val` from the map. This ensures O(1) average time.
Technical: You are given `n` jobs and `m` workers. Each job `i` has a profit `p[i]` and a difficulty `d[i]`. Each worker `j` has an ability `a[j]`. A worker can only complete a job if their ability is greater than or equal to the job's difficulty. What is the maximum profit you can achieve?
Sort jobs by difficulty and workers by ability. Iterate through sorted workers. For each worker, add all jobs they can perform (difficulty <= worker ability) to a max-heap, tracking the maximum profit seen so far among these eligible jobs. The worker then takes the job with the highest profit from the max-heap. This greedy approach maximizes profit by assigning the best available job to each worker, considering their increasing abilities.
Technical: Design a URL shortening service like Bitly.
Key components include a frontend for URL submission, a backend service, and a database. The backend generates a unique short code (e.g., 6-8 alphanumeric characters) for each long URL. This mapping (`short_code` -> `long_url`) is stored in a NoSQL database like Cassandra or Redis for fast lookups. When a short URL is accessed, the service retrieves the long URL from the database and performs a 301/302 redirect. Considerations include collision handling, custom URLs, analytics, and rate limiting.
Behavioral: Tell me about a time you failed or made a mistake. What did you learn?
During a college project, I misestimated the complexity of integrating a third-party API, leading to a significant delay. I learned the importance of thorough upfront research and breaking down complex tasks into smaller, manageable sub-tasks with clear dependencies. Now, I always create detailed technical specifications and seek early feedback, especially for unfamiliar components, to prevent similar issues and improve project planning accuracy.
Behavioral: Describe a complex technical problem you solved. What was your approach?
In my internship, optimizing a legacy data processing script was challenging due to its intertwined logic and poor documentation. My approach involved first profiling the script to identify bottlenecks, then breaking it down into modular functions. I systematically refactored each module, introducing caching and parallel processing where feasible. This reduced execution time by 60% and improved maintainability, demonstrating my ability to dissect and optimize complex systems effectively.
Behavioral: How do you handle disagreement with a team member on a technical decision?
I prioritize understanding their perspective first, asking clarifying questions about their reasoning and underlying assumptions. Then, I present my own arguments, backed by data, benchmarks, or design principles. If we still disagree, I suggest a small-scale prototype or a time-boxed experiment to compare both approaches objectively. Ultimately, I respect the team lead's decision, ensuring we move forward cohesively while documenting the rationale for future reference.
Behavioral: Why Google? What interests you about this role?
Google's unparalleled impact on global technology and its culture of innovation deeply resonate with me. Specifically, the Software Engineer role here offers the opportunity to work on large-scale, challenging problems that affect billions, using cutting-edge technologies. I'm particularly excited by cloud infrastructure and believe my DSA skills and passion for building robust, scalable systems align perfectly with Google's mission to organize the world's information.
HR: Where do you see yourself in five years?
In five years, I aim to be a highly proficient Software Engineer at Google, contributing significantly to impactful projects. I envision myself deepening my expertise in distributed systems and potentially mentoring junior engineers. I'll be continuously learning, taking on more complex challenges, and leveraging Google's resources to grow into a technical leader who can drive innovation and solve critical user problems efficiently and elegantly.
HR: What are your salary expectations?
Based on my research for a Software Engineer L3 role at Google India, the typical total compensation for freshers ranges from ₹40-65 LPA, including base, stock, and bonus. I am looking for a competitive package within this range that reflects my skills and potential contribution to Google. I'm open to discussing the full compensation structure, including equity and benefits, to find a mutually agreeable offer.
Preparation tips
- Master LeetCode Hard DSA: Focus on dynamic programming, graphs, trees, and advanced data structures like segment trees or tries.
- Practice Mock Interviews: Utilize platforms like Pramp or interviewing.io to simulate real interview conditions, focusing on clear communication and thought process.
- System Design Fundamentals: Understand core distributed systems concepts (CAP theorem, load balancing, caching, databases) even for fresher-level awareness.
- Googleyness Preparation: Research Google's core values (e.g., 'smart creatives,' 'user focus') and prepare STAR method stories demonstrating these traits.
- Resume & Project Deep Dive: Be ready to discuss every line on your resume in detail, especially your projects, their challenges, and your specific contributions.
Common questions about Google interviews
What is the typical salary package for a fresher Software Engineer at Google India?
For a fresher Software Engineer (L3) at Google India, the total compensation generally ranges from ₹40 to ₹65 LPA. This typically includes a base salary, restricted stock units (RSUs) vested over four years, and a performance bonus. The exact figures depend on your interview performance and market conditions.
How difficult are Google India's SWE interviews compared to other top product companies?
Google India's SWE interviews are considered among the hardest globally, even compared to other top product companies. The difficulty stems from extremely challenging Data Structures & Algorithms questions, rigorous system design rounds for experienced roles, and a strong emphasis on "Googleyness" behavioral aspects. Thorough preparation is crucial.
Do I need to be from a Tier-1 college to get hired by Google India?
While a significant number of hires come from Tier-1 colleges, it's not an absolute requirement. Google India values talent and problem-solving skills above all. Candidates from Tier-2/3 colleges with strong competitive programming profiles, impactful projects, or relevant internship experience are definitely considered and hired. Focus on demonstrating your technical prowess.
How long does the entire Google India hiring process typically take?
The Google India hiring process can vary significantly but typically takes anywhere from 1 to 4 months, sometimes longer. This includes the online assessment, phone screens, onsite interviews, team matching, and offer stages. Factors like the number of open roles, interviewer availability, and your interview performance can influence the timeline.