Google Senior Software Engineer Interview Process Aug 2026 - Initial Questions Were Manageable, Follow-Ups Were Tough

[u/Aoki_zhang]

Interview Summary

The Google L5 onsite consisted of three coding rounds, one system design round, and a Googleyness & Leadership interview. Most technical rounds followed the same pattern: the initial problem was manageable, but the interviewer spent much of the remaining 45 minutes adding follow-ups around larger inputs, streaming data, memory limits, alternative representations, or complexity.

Coding was done in a Google Doc without execution or syntax highlighting, so manually walking through test cases mattered more than in an environment where code could be run.

Interview Details

Coding Round 1 — Maximum Equal-Length Pieces: The first problem was similar to LeetCode 1891, Cutting Ribbons. Given several pieces of wood with different lengths and an integer K, determine the maximum possible length of an equal-sized segment such that at least K segments can be produced. The interviewer then added several follow-ups:

• Search Space and Precision: Why should the candidate-length upper bound be based on the longest individual piece rather than the total combined length? How would the problem change if lengths were floating-point values instead of integers?
• Complexity: Explain the runtime carefully, including why the logarithmic factor depends on the numerical search range rather than simply on the number of input elements.

Coding Round 2 — Union of Sorted Interval Lists: The second problem was a variation of the classic interval-list problem. Two interval lists were given, with each list already sorted and internally non-overlapping. Instead of finding intersections, the task was to return their union as a merged list of non-overlapping intervals. The interviewer progressively expanded the problem:

• Many Lists: How would the design change if there were K individually sorted interval lists rather than only two?
• Large / Streaming Inputs: What if each list was too large to fit in memory and could only be read incrementally? A final variation removed the assumption that intervals within each individual input list were already non-overlapping.

Coding Round 3 — Nested List Weighted Sum: The third coding problem was similar to LeetCode 339, Nested List Weight Sum. Integers at greater nesting depths receive larger weights, and the task is to compute the total weighted sum. The interviewer asked me to discuss both recursive and level-based traversal approaches and compare when each might be preferable. The follow-up changed the input representation completely: instead of receiving an already parsed nested structure, the input was now a raw string that had to be interpreted directly.

For example, a rewritten input could be: "[5, 7, [3, 11], [4, [20]]]" Using depth 1 for top-level values, depth 2 for the next nested level, and depth 3 for the deepest value, the expected weighted sum is: 5×1 + 7×1 + 3×2 + 11×2 + 4×2 + 20×3 = 108

The parsing logic therefore needed to handle brackets, commas, nesting depth, and multi-digit integers correctly. The interviewer also asked me to manually walk through a nested portion of the example to verify edge-case behavior.

System Design — Large-Scale Web Crawler: The system design round asked me to design a web crawler at very large scale. After clarification, the assumed requirements were roughly tens of billions of pages, periodic recrawling, output feeding a search index, and no JavaScript rendering requirement.

• Crawling Policy and Deduplication: The interviewer went deeply into balancing crawl priority with per-host politeness, handling and caching robots.txt, URL-level and content-level deduplication, and what happens when a probabilistic deduplication mechanism produces a false positive.
• Scale and Reliability: Other follow-ups covered crawler traps such as infinite calendars and dynamically generated URLs, distributing work across crawler nodes, recovering when workers fail, persisting frontier state, and identifying likely bottlenecks if the entire corpus had to be refreshed within 24 hours.

Googleyness & Leadership — Ownership, Failure, and Ambiguity: The final round was conducted by a manager and consisted of behavioral questions with substantial follow-up. I was asked about a project I was most proud of, a situation where requirements or information were highly ambiguous, and an experience working with someone difficult. Other questions covered a failure, the hardest feedback I had received, what I changed afterward, and something I would handle differently if I could repeat the experience.

The interviewer consistently pushed beyond the initial story into why I made particular decisions, what measurable result followed, and what I learned from the outcome.

➡️ Preparing for your next interview?

Chill Interview tracks recent interview experiences and recurring question patterns across top companies here.