Disgusting Google L4 Screening Round
Summary
I had a frustrating Google L4 screening interview marked by poor communication, an ambiguous problem, and conflicting explanations regarding parallel execution. This led to confusion and inefficient solutions, ultimately resulting in a 'No Hire' verdict citing poor problem-solving.
Full Experience
TL;DR: Had a Google screening interview with a non-native English-speaking interviewer, which was marked by poor communication, ambiguous code snippets, and conflicting explanations—especially around blocking behavior in parallel execution. The unclear problem statement led to confusion and inefficient solutions. Ultimately received a 'No Hire' with feedback citing poor problem-solving. Frustrated by the 1-year cool-off and the lack of clarity in early-stage interviews
Date: 9th May 2025
The interviewer was a German guy. Started with an intro. He began reading some code snippet. It was difficult to understand orally. I could not see the code in the Google Meet video or on the interview doc. I waited for 2 minutes to see if he would stop or say something—still, he was just reading. Then I said I was unable to see the code. He said it was present in the interview doc. I said that it was not visible to me. Then he checked again and tried a few more times. Finally, it was visible on the doc.
He gave the following code snippet:
public CWFuture CountWords (int machine_id, int doc_id);
class CWFuture {
int Join();
boolean IsDone();
}
I was confused after looking at the snippet itself. First of all, it was syntactically incorrect. Also, the method names started with capital letters, which was weird. The first two lines were especially confusing for me.
He told me we have a list of documents, each document has multiple words. We have an infinite set of machines. The CountWords method runs on a particular machine_id and tells us how many words are present in a document with a particular doc_id. We have to find the sum of all the words in all the documents.
Then he explained the other two methods:
Join => Blocks until the operation has completed and a result is available, and returns the result.
IsDone => Returns whether or not the operation has completed.
He then created another method:
int CountWords() {}
He created it inside the CWFuture class and asked me to code it. (I think this itself was wrong—it should have been created in a new class.)
He was not fluent in English and was speaking at a very slow pace. Even to understand up to this point, I had to ask multiple clarifying questions. Then finally, he added these comments for the methods at the end of the document. And once I said "got it", he removed them—which seemed weird to me.
First of all, the code at this point was very ambiguous. I was not even sure how to call the CountWords method itself. I tried asking some questions, but I still didn't understand. So I asked him again. He gave the following code:
CWFuture* cw_future = CountWords(machine_id, doc_id);
It was beyond my understanding how a method which is not present in a class was being called directly. I was feeling awkward and dumb at the same time. But I didn’t object and proceeded.
Then I asked him, blocking basically means that the machine will be blocked, right? He said yes. I said, the machine_id on which this method is running, right? He again said yes. Just to confirm, I asked whether our system (which calls the API) will also get blocked? He said yes.
I was shocked. So I asked another question: It means that we cannot do anything on our system at that time? He again said yes.
Then I said that since our machine is blocked, we cannot run multiple CountWords on multiple machines—as once the method is called on a system, our machine will also get blocked. He said yes. So, I said I will run it serially on each machine. He said to code it. At this point, I was expecting there would be a follow-up where our machine is not blocked.
I coded it in around 5 minutes. After coding, he said "why don't you try this" and gave a code snippet. He was basically trying to run it in parallel. I said, as you already mentioned our machine is blocked, it will run serially only. He said, what will be the total time? I said: number of machines * average time for each machine. He said: should it not be max of time taken on any machine? I again said, that is possible if our system is not blocked.
I assume he didn't understand my explanation. It was only after I wrote the code that he realized I was calling countwords serially.
He then asked me to code the logic suggested by him. I made the changes—it took 5 minutes. I was confused how to check if all APIs have completed. I thought a bit and then used a while loop with a queue. All the APIs which are not done are put into the queue, and then checked again. If not done, they're put back into the queue. Not sure if this was a good way.
At this time, I was already just waiting for the interview to be over.
He asked me to explain the code. I did. He said, please look at your code and see if there is any mistake. I observed for some time—everything looked fine. I said, yes, looks good. He pointed out a mistake, which was valid. I corrected it.
Finally, he ended the interview—maybe 2–3 minutes were remaining. He asked if I had any questions. At that point, he was smirking while looking at me, which I found extremely unprofessional.
Verdict: No Hire Comments: Lacks problem solving. Was not able to understand the problem properly.
I am not sure why such people are allowed to take interviews. Even if they do, they should not ask such ambiguous problems when they can’t even explain them. He spoke bare minimum, was unsupportive and allowed me to code a wrong (inefficient) logic only to correct it once I had completed coding it. I was further dejected when I learnt that the cool-off period is 1 year even if you get rejected in the screening round.
Interview Questions (1)
Given an API signature: public CWFuture CountWords (int machine_id, int doc_id); and a CWFuture class with int Join(); and boolean IsDone(); methods. The CountWords method runs on a specified machine_id and returns the word count for a doc_id. Join() blocks until the operation completes and returns the result. IsDone() returns true if the operation has completed.
The task is to find the sum of all words in all documents from a given list of documents, utilizing an infinite set of machines.
Initially, I was given misleading information that calling CountWords would block the caller's system, which implied a serial execution approach. The core challenge then shifted to implementing a parallel solution where the calling system is not blocked, aiming for an overall time complexity proportional to the maximum time taken by any single machine rather than the sum of times across all machines.