Google Interview Questions & How to Prepare (2026)

A Google interview is less about trick puzzles and more about whether you can reason through ambiguous problems out loud, write clean code, and show “Googleyness” under pressure. If you know the structure and rehearse the right questions, you can walk in calm instead of crammed. Here’s exactly what to expect in 2026 and how to prepare.

The Google interview process in 2026

For most software-engineering roles the loop looks like this:

1. Recruiter screen (30 min) — background, motivation, logistics, and a quick technical sanity check.
2. Technical phone screen (45 min) — one or two coding problems on a shared editor, no autocomplete, no running the code.
3. Onsite / virtual loop (4–5 rounds, 45 min each):
   • 2–3 coding rounds (data structures and algorithms).
   • 1 system design round (for mid-level and above; juniors get a second coding round instead).
   • 1 behavioural / “Googleyness & leadership” round.
4. Hiring committee — a packet of your interviewer feedback is reviewed by people who never met you, so written signal matters. Interviewers literally transcribe what you say.
5. Team match + offer — you’re matched to a team, then levelled and compensated.

The big mindset shift: Google hires for the committee, not the room. Narrate your thinking clearly so your interviewer can write it down.

Sample coding questions (with how to attack them)

Google coding rounds skew toward arrays, strings, trees, graphs, hash maps, and dynamic programming. Expect medium-to-hard difficulty.

Q: Given an array of integers and a target, return indices of the two numbers that add up to the target. Brute force is O(n²). The expected answer: one pass with a hash map storing value → index. For each number, check whether target − num is already in the map. O(n) time, O(n) space. Always state complexity before you’re asked.

Q: Serialize and deserialize a binary tree. Pick a traversal (pre-order with null markers is cleanest), write a recursive serialize that emits node,left,right, and a deserialize that consumes the stream. The interviewer is watching whether you handle nulls, edge cases (empty tree), and keep your two functions symmetric.

Q: Find the number of islands in a 2D grid of land/water. Iterate every cell; on unvisited land, run DFS or BFS to sink the whole island, incrementing a counter. Mention the trade-off: recursion risks stack overflow on huge grids, so a BFS queue is safer. This signals production awareness, which Google loves.

Q: Given a stream of numbers, return the running median. The strong answer uses two heaps — a max-heap for the lower half and a min-heap for the upper half — balanced so their sizes differ by at most one. O(log n) insert, O(1) median.

For every problem, run this loop out loud: clarify inputs and constraints → state a brute-force baseline → optimise → walk through an example → code → test with edge cases. The process is the score.

Sample system design questions

System-design rounds check whether you can scope a vague prompt and make defensible trade-offs.

Q: Design a URL shortener (like TinyURL). Cover: API (POST /shorten, GET /{code}), key generation (base-62 of an auto-increment ID, or a hash with collision handling), storage (a key-value store given the read-heavy pattern), caching the hot links, and scale estimates (reads ≫ writes, so a CDN/cache layer in front). Close with how you’d handle custom aliases and analytics.

Q: Design YouTube / a video-streaming service. Talk through upload + transcoding pipeline, object storage for video chunks, a CDN for delivery, metadata in a database, and the read path for recommendations. Always state your assumptions (users, QPS, storage) at the top.

The rubric: requirements gathering, high-level architecture, deep dive on one component, and trade-offs (consistency vs. availability, cost vs. latency). Drawing a clear box-and-arrow diagram early earns trust fast.

Sample behavioural questions

Google’s behavioural round maps to leadership and “Googleyness.” Use the STAR method (Situation, Task, Action, Result) and bring metrics.

• “Tell me about a time you disagreed with a teammate. How did you resolve it?”
• “Describe a project that failed. What did you learn?”
• “When did you have to make a decision with incomplete information?”
• “Tell me about the most technically challenging thing you’ve built.”

Prepare 6–8 concrete stories you can flex across questions. Vague answers (“we worked hard and shipped it”) score poorly; specific ones (“I cut p95 latency from 800ms to 120ms by adding a read cache, which lifted conversion 4%”) score well.

An 8-week prep plan

• Weeks 1–2: Refresh core data structures and Big-O. Solve 5 easy/medium problems daily, focusing on patterns (two pointers, sliding window, BFS/DFS).
• Weeks 3–4: Graduate to mediums and a few hards. Time yourself to 30–35 minutes per problem.
• Weeks 5–6: System design fundamentals — load balancing, caching, sharding, queues. Design two systems end to end each week.
• Week 7: Behavioural stories. Write them out, then rehearse aloud.
• Week 8: Full mock loops under real conditions, then rest the day before.

The single highest-leverage habit is talking while you solve. Practise these rounds with OnJob’s AI mock interviews and get a confidence score plus feedback on whether you clarified, narrated, and tested your code — the exact things the committee reads. When you’re ready, create a free account and browse matched Google-tier roles. For pay expectations, see our software engineer salary breakdown.

FAQ

How many rounds are in a Google software engineer interview? Typically a recruiter screen, one technical phone screen, and a 4–5 round onsite loop (2–3 coding, one system design for mid-level and above, and one behavioural round), followed by a hiring committee review and team match.

What kind of coding questions does Google ask? Medium-to-hard data-structures-and-algorithms problems on arrays, strings, trees, graphs, hash maps, heaps and dynamic programming — solved live in a shared editor without running the code. Stating complexity and edge cases unprompted is part of the score.

How long should I prepare for a Google interview? Most candidates need 6–8 weeks of focused practice: two weeks on fundamentals, two on harder algorithm problems, two on system design, and the last two on behavioural stories and full mock loops.

Free OnJob tools & guides

Interview questions by role Real questions + what a strong answer covers. Free mock tests Practice and benchmark before the real thing. ATS resume checker Clear the filters before you interview.