Interview Experience - 162 - Google | Software Engineer | SWE III
Summary
📌 Job Role: Software Engineer
🔢 Number of Rounds: 5 (including multiple technical rounds and a behavioral round)
📜 Offer Status: Rejected
📍 Location: Warsaw
👤 Candidate Name: Not disclosing due to confidentiality
Interview Process
The overall process at Google was structured and well-coordinated, though it stretched out because of the holiday season. It began with a recruiter phone screen, moved into a coding interview, followed by another recruiter call to share feedback, and finally culminated in five interviews that included four technical and one behavioral (Googliness) round.
Despite the rejection, the experience was insightful and helped me understand the type of problem-solving mindset and structured thinking Google looks for in candidates.
Preparation Guide
I was given one month of preparation time after the initial phone screen, which was longer than usual (normally one to two weeks) due to the Christmas holidays. After each round, the recruiter was proactive in sharing feedback and allowing me additional time to prepare.
For the technical rounds, the questions heavily leaned on data structures, algorithms, and system-level problem-solving. Topics included arrays, trees, interval operations, system simulations, and handling file-system-like data.
The behavioral (Googliness) round focused on team dynamics, problem-solving, conflict resolution, and decision-making under challenging circumstances.
Interview Rounds
Round 1 : Phone Screen
Duration: 15–20 minutes
Difficulty Level: Easy
Experience:
The initial round was with the recruiter. It was a short introductory call where I talked about my background, professional experience, expectations from the role, and reasons for considering a switch. Since this was just before the holiday season, I was given one month to prepare for the next technical round (typically Google provides only 1–2 weeks).
Key Learnings:
Be clear and concise while explaining your background.
Align your motivations with the company’s vision and opportunities.
Round 2 : Coding Interview
Duration: 45 minutes
Difficulty Level: Medium
Experience:
The problem given was:
Given a tree, find the length of the longest outgoing path for a given node.
Example tree:
[1]
/ \ / \
v v [2] [3]
/ \
v v [4] [5]
Follow-up: What if in the above tree we add an edge [2] -> [3]?
The task required a deep understanding of tree traversal, pathfinding, and handling edge cases when a cycle could potentially be introduced.
Key Learnings:
Prepare well on tree traversal problems (DFS/BFS).
Think about edge cases such as cycles even when working on tree structures.
Always clarify the problem scope with the interviewer.
Round 3 : Phone Screen
Duration: 20 minutes
Difficulty Level: Easy
Experience:
Two days after the coding interview, the recruiter called me to share feedback. They also asked for my input on the process. I was given two more weeks to prepare for the next stage, which would be the final set of five interviews.
Key Learnings:
Recruiters at Google are highly communicative and open to feedback.
This call was not evaluative but important for logistics and preparation.
Round 4 : Technical Interview #1
Duration: 45 minutes
Difficulty Level: Medium
Experience:
The task was:
Given an array of integers
arr(could be empty), and a positive integerk, return a subarray that meets the following condition:
answer = [a, a+1, ..., a+k-1, b, b+1, ..., b+k-1] length(answer) == 2*k
If no such subarray exists, return an empty array.
Examples:
arr = [3 2 3 4 1 2 3 -1], k = 3 → answer = [2 3 4 1 2 3]arr = [2 3 4 1 2], k = 2 → answer = [3 4 1 2]
The problem required a good understanding of array manipulation and subarray properties.
Key Learnings:
Focus on edge cases like empty arrays or when no subarray matches the condition.
Write helper functions to check subarray validity efficiently.
Round 5 : Technical Interview #2
Duration: 45 minutes
Difficulty Level: Medium
Experience:
The problem revolved around computing file sizes in a file system represented by an array of entities.
Sample structure:
[ {'name': 'abc', 'id': 123, 'isDirectory': True, 'children': [456]}, {'name': 'def', 'id': 456, 'isDir': False, 'size': 200} ]
Tasks:
Compute the total size of an entity given its id.
Optimize for multiple queries.
Validate if the given array represents a correct file system.
Key Learnings:
Efficient traversal and caching techniques (like memoization) are useful.
Always confirm assumptions about data correctness before implementing.
Round 6 : Technical Interview #3
Duration: 45 minutes
Difficulty Level: Medium
Experience:
The system problem involved "painting objects" in a given range. Once an object was painted, it could not be repainted.
Example:
Input:
[[2, 5], [8, 10], [3, 9]]Output:
[4, 3, 2]
This was similar to the Merge Intervals problem on LeetCode.
Key Learnings:
Knowledge of interval merging and set operations is essential.
Keep track of previously covered ranges to avoid overcounting.
Round 7 : Technical Interview #4
Duration: 45 minutes
Difficulty Level: Hard
Experience:
The task was to implement a fake timing system for scheduling callbacks.
Required functions:
void schedule(Function callback, int delay) void tick(int timeDelta)
Follow-ups included:
Handling multiple schedule calls.
Justifying the data structure chosen for callback storage.
Dealing with very large delays (e.g., 10^7).
This round was the most challenging, requiring strong design skills and careful reasoning about time simulation.
Key Learnings:
System design questions can come even in coding interviews.
Explain trade-offs in data structures rather than just writing code.
Round 8 : Behavioral Interview (Googliness)
Duration: 20–30 minutes
Difficulty Level: Medium
Experience:
The interviewer asked situational questions about teamwork, problem-solving, and conflict resolution. Some examples:
A time when the team wasn’t organized well and what I did about it.
A situation where I realized mid-way that my solution would not work.
Disagreeing with a team decision and how I handled it.
Handling a situation where teammates threatened to leave due to a chosen solution.
Key Learnings:
Focus on structured responses (Situation, Task, Action, Result).
Be genuine while explaining failures or conflicts, but highlight how you resolved them.
Final Thoughts
Although I did not receive an offer, this interview process was one of the most valuable learning experiences in my career. Google’s interview process is rigorous and requires not just technical expertise but also clarity of thought, adaptability, and effective communication.
For future candidates:
Focus on data structures, algorithms, and problem-solving fundamentals.
Practice system-like problems that test simulation, range operations, and optimizations.
Don’t underestimate the behavioral interview—Google looks for cultural fit as much as technical ability.
Take note of how you explain trade-offs, optimizations, and edge cases.