Google Interview Questions 2026 — University Graduate & STEP Intern Guide India
Google hires Indian freshers mainly for Software Engineer, University Graduate roles and STEP internships through its careers site, campus recruitment and referrals. Interviews are structured: candidates write code in real time in a shared document on problems such as graph traversal, intervals and hashing, explain complexity aloud, and answer behavioural 'Googleyness' questions; hiring committees review the feedback.
Preparing for your Google Interview?
Practice a simulated AI Mock Interview using real Google questions and receive instant feedback.
Google is one of the most competitive fresher destinations in India. Most engineering freshers join as Software Engineers through university-graduate roles, and early-year students can target the STEP internship. Google’s India university-graduate postings list Bengaluru, Hyderabad, Gurugram, Mumbai and Pune as possible locations.
This guide separates what Google states officially from what candidates commonly report.
How Google Hires Freshers in India
| Route | Who it is for | Notes |
|---|---|---|
| Software Engineer, University Graduate | Final-year and recent graduates | Postings ask for a bachelor’s degree or equivalent practical experience; preferred qualifications include CS fundamentals and coding in C, C++, Java or Python |
| STEP internship | Early-stage CS students (second year in India) | Google’s internship for students early in their degree |
| Campus recruitment and referrals | Students at visited campuses, referred candidates | A recruiter contacts you if there is a potential match |
What the interviews look like
| Element | What Google says | What candidates commonly report (India) |
|---|---|---|
| Format | Code in real time in a shared interview document; choose from C, C++, Go, Java, JavaScript or Python | An online coding assessment or phone screen in some drives, then several technical interviews |
| Method | Structured interviews: same questions and scoring rubrics for a role | Medium-to-hard DSA: graphs, intervals, sliding windows, heaps, design of data structures |
| Behavioural | Ask clarifying questions, think out loud, check assumptions | ”Googleyness” questions on learning, ambiguity, teamwork and disagreement |
| Decision | Hiring committees review feedback | Team matching may follow approval |
🚀 Start Free Google Mock Interview
Practice Google coding explanations and Googleyness questions with real-time AI feedback on clarity, structure and pacing.
Start Free Mock InterviewTechnical Interview Round: Key Focus Areas
1. Data Structures and Algorithms
- Commonly reported topics: graphs (BFS/DFS, topological sort), arrays and strings, hashing, sliding window, heaps, binary search, recursion and dynamic programming.
- How to prepare: 150+ problems across patterns; for each, explain the brute force, the optimisation, complexity and test cases.
2. Coding in a Plain Document
- Practise writing complete, compilable code without autocomplete, in the language you know best.
Check whether your resume has the keywords Google's screening looks for. Scan Resume with ATS Checker →
3. Communication and Testing
- Clarify, plan, code, then test. Interviewers score how you reason, not only the final answer.
4. Googleyness and Behavioural
- Prepare STAR stories on learning fast, handling ambiguity, disagreement and helping others.
8-Week Google Preparation Plan
- Weeks 1–3 — Patterns: arrays, strings, hashing, two pointers, sliding window, binary search, stacks, linked lists.
- Weeks 4–5 — Graphs and trees: BFS/DFS, topological sort, union-find, BST operations, heaps.
- Week 6 — Dynamic programming and design of data structures: classic DP patterns, LRU cache, tries.
- Week 7 — Mock interviews: at least four timed mocks in a plain document, speaking aloud throughout.
- Week 8 — Behavioural and review: six STAR stories, resume deep-dive, and re-solving problems you got wrong.
Read our technical interview mistakes developers make and off-campus placement strategy guides.
Practice communication, confidence, pacing, filler words, and HR responses. Try Google HR Mock Interview →
Salary and Offer Details
Google does not publish fresher compensation for India, and the figures in online job aggregators conflict sharply, so we have not quoted a number. Use your offer letter as the reference and the CTC to in-hand salary calculator to understand take-home pay.
Resume Tips for Google
- Format: one page, single column, impact-first bullets with numbers. Build your resume and check your ATS score.
- Keywords: Data Structures, Algorithms, C++ or Java or Python, Distributed Systems, Linux, Git, Machine Learning (if relevant), open-source contributions, competitive programming ratings.
- Templates: see the Software Engineer Resume India and Internship Resume India examples.
- Keywords Map: use the Software Engineer and Backend Developer ATS keyword sheets.
- Company Hub: visit the Google Company Hub, and compare with the Amazon India interview guide. Browse live openings on the FundoCareer fresher jobs board.
Sources
Checked November 2026:
- Google Careers — Our hiring process: google.com/about/careers
- Google Careers Help — Apply for a job: support.google.com
- Google — Preparing for Google technical internship interviews (2018 candidate guide): services.google.com
- Google re:Work — A guide to structured interviewing: rework.withgoogle.com
- Fortune — How Google attracts the world’s best talent (2014, on Google’s four hiring attributes): fortune.com
- LinkedIn Talent Blog — Google’s hiring secrets revealed (2014): talent.linkedin.com
Process details marked “commonly reported” come from candidate accounts, not from Google, and can differ for your drive. The 2018 interview guide is older, so confirm current details in your recruiter’s preparation email.
Google Interview Questions with Model Answers
These are real questions asked in Google interviews in India, with model answers that interviewers have told us they score highly. Each answer is self-contained.
Iterate over every cell. When you find an unvisited '1', increment the island count and run a BFS or DFS from it, marking every connected land cell (up, down, left, right) as visited — either by changing it to '0' or using a visited set. Each cell is visited once, so time is O(rows × cols); space is O(rows × cols) in the worst case for the recursion stack or queue. Discuss the trade-off: recursive DFS is concise but can overflow the stack on large grids, so iterative BFS is safer. A union-find approach also works and is useful if land cells are added dynamically.
Ask whether diagonal cells count as connected and whether you may modify the input. Clarifying questions are explicitly part of what Google evaluates.
Sort intervals by start time. Initialise the result with the first interval. For each next interval, if its start is less than or equal to the end of the last interval in the result, they overlap — update the last end to max(last end, current end). Otherwise append the current interval. Sorting costs O(n log n), the scan O(n), and the output needs O(n) space. Edge cases: empty input, intervals that only touch (decide with the interviewer whether [1,2] and [2,3] merge), and fully nested intervals.
Walk through a small example before coding, then test with nested and touching intervals once you finish.
Use a sliding window with a hash map from character to its last-seen index. Keep a left pointer. For each right index, if the character was seen at an index >= left, move left to that index + 1. Update the map with the current index and the best length with right - left + 1. Each character is processed once, so time is O(n) and space is O(min(n, alphabet size)).
State the brute-force O(n³) or O(n²) approach first, then explain why the window only moves forward. Narrating the optimisation is the point.
Combine a hash map with a doubly linked list. The map stores key → list node. The list keeps nodes in order of use, with the most recently used at the head. get(key): if absent, return -1; otherwise move the node to the head and return its value. put(key, value): if the key exists, update the value and move it to the head; otherwise create a node at the head and add it to the map, and if the size exceeds capacity, remove the tail node (least recently used) from both the list and the map. Dummy head and tail nodes simplify edge cases. Every operation is O(1).
Explain why a singly linked list is not enough — you need O(1) removal of an arbitrary node.
Model courses as nodes and prerequisites as directed edges; the question becomes 'does the graph contain a cycle?'. Use Kahn's algorithm: compute the in-degree of every node, push all zero-in-degree nodes into a queue, and repeatedly pop a node, decrement the in-degree of its neighbours and push any that reach zero. If the number of processed nodes equals the number of courses, all can be finished; otherwise a cycle exists. Time and space are O(V + E). DFS with three colours (unvisited, visiting, done) is an equivalent alternative.
Follow-ups commonly ask you to return a valid order — Kahn's algorithm gives the topological order for free.
Option 1: sort and index — O(n log n). Option 2: maintain a min-heap of size k; push each element and pop when the heap exceeds k; the top is the answer — O(n log k) time, O(k) space, and it works on streams. Option 3: Quickselect — partition around a pivot as in quicksort and recurse only into the side that contains the kth position — average O(n), worst case O(n²), improved with a random pivot.
Present the options with their trade-offs and let the interviewer steer. Google interviewers often ask 'can you do better?' after your first answer.
Start with normal cases that follow the specification, then boundary cases (empty input, a single element, maximum sizes, negative numbers, duplicates), then invalid inputs. Trace at least one example through the code line by line to catch off-by-one errors. Mention complexity under worst-case input and how you would write unit tests — one assertion per behaviour, with clear names. If the code handles concurrency or I/O, mention how you would isolate those parts.
Google's interview-preparation advice for candidates includes testing your code for bugs. Do it unprompted before you say you are done.
Use STAR with a learning focus. Situation: a project or internship where you needed an unfamiliar tool, such as a new framework or cloud service. Task: what had to be delivered and by when. Action: how you learned — documentation, small experiments, asking a senior — and how you applied it, including a mistake you corrected. Result: the delivered outcome with a measurable effect, and what you would do differently. Show intellectual humility: what you did not know and how you closed the gap.
Learning ability, comfort with ambiguity and humility are the traits Google's former people-operations leadership publicly associated with 'Googleyness'.
Pick a real technical or product disagreement. Explain both positions fairly, how you gathered data (a quick benchmark, a user test, a review of requirements), how you listened and what compromise or decision you reached. End with the result and what the relationship was like afterwards. Avoid stories where you were simply right and the other person was wrong — interviewers look for respect, collaboration and willingness to change your mind.
Keep it to about two minutes. Behavioural answers are scored against a rubric, so structure helps.
Be concrete. Name a Google product, open-source project (for example Android, TensorFlow, Kubernetes or Go) or research area you have actually used or contributed to, and what you learned from it. Connect it to the kind of problems you want to work on — scale, reliability, ML, developer tools — and to what you have already built. Avoid generic praise of perks or brand; one specific, verifiable detail is stronger.
If you have taken part in Google programmes or used Google developer resources, mention them briefly — but only if true.
Common Mistakes in Google Interviews
These are the mistakes that eliminate candidates at this stage — often before the technical round even begins.
- Starting to code before clarifying the input, constraints and edge cases.
- Coding silently — Google evaluates your reasoning, so think out loud.
- Relying on IDE autocomplete; practise writing compilable code in a plain document.
- Stopping at a working solution without discussing complexity or testing.
- Preparing only DSA and skipping behavioural stories about learning, ambiguity and teamwork.
Frequently Asked Questions
Ready to Land Your Offer at Google?
Practice with real interview questions and optimize your resume using FundoCareer's placement prep suite.