HackTheRounds Interview Experiences

Google Software Engineer Interview Experience (2026) - Offer

Full breakdown of my Google SWE interview: online assessment, phone screen, and 4 round virtual onsite covering dynamic programming, math, permutations, and str

By Anonymous · 2026-03-15

Background

I had a little over 3 years of experience as a backend engineer at a mid-size company when I decided to interview at Google. A former colleague who had moved there referred me internally, which definitely helped get the ball rolling quickly. From application to offer, the entire process took about 7 weeks.

Timeline

Online Assessment (90 min)

The OA had two coding problems on Google's internal platform. The first was a medium-difficulty string manipulation question that I solved in about 20 minutes. The second was harder and involved interval scheduling — took me the remaining time but I got all test cases passing. Nothing too surprising if you have been grinding LeetCode.

Phone Screen (45 min)

A Google engineer called via Meet. After a few minutes of introductions, we jumped into the problem.

Problem: A frog needs to cross a river by jumping on stones. You are given a list of stone positions and need to determine whether the frog can reach the last stone. The catch is that if the frog's last jump was k units, its next jump can only be k-1, k, or k+1 units.

[[problem/91?company=1|Jump Game]]

I talked through a recursive approach first, then explained why memoization was needed to avoid exponential blowup. The interviewer nodded along and asked a few clarifying questions about the state representation. I ended up using a dictionary mapping each stone position to a set of possible jump sizes, which ran efficiently.

We had about 5 minutes left for my questions. I asked about the team's tech stack and day-to-day work.

Virtual Onsite (4 rounds)

All four rounds were conducted over Google Meet on the same day, with 15-minute breaks between each. Everyone used Google's internal collaborative coding tool.

Round 1: Coding — Verbal Arithmetic

Problem: Given a verbal arithmetic equation like "SEND + MORE = MONEY", determine whether there exists a valid digit assignment (0-9) for each letter such that the equation holds. Each letter maps to a unique digit, and leading characters cannot be zero.

This was a constraint satisfaction / backtracking problem. I started by identifying the unique characters and discussing the brute-force approach (permutations of digit assignments). The interviewer asked me to optimize, so I implemented a column-by-column solver that prunes early when partial assignments violate the arithmetic.

The key insight was processing from the least significant column to the most significant, carrying over remainders, and pruning branches as soon as a contradiction appeared. The interviewer was engaged and asked good follow-up questions about time complexity.

Round 2: Coding — Array Permutations

Problem: Given an array of integers, generate all permutations in lexicographic order. Then, given a specific permutation, find the next permutation in that ordering.

The first part was fairly standard — I used a recursive approach to generate permutations and sorted them. For the "next permutation" follow-up, I implemented the classic algorithm: find the rightmost element that is smaller than its successor, swap it with the smallest larger element to its right, and reverse the suffix.

The interviewer then asked: "What if the array has duplicates?" That required careful handling to skip duplicate permutations. I added a check during the recursive generation to avoid placing the same value at the same position twice, which the interviewer liked.

Round 3: Coding — N-th Element from a Data Stream

Problem: Design a data structure that processes a continuous stream of integers and can efficiently return the N-th smallest element at any point in time.

I discussed several approaches: sorting on every query (too slow), using a max-heap of size N (optimal for this specific case), and balanced BSTs (overkill but worth mentioning). Went with the max-heap approach — maintain a heap of size N, and for each incoming element, if it is smaller than the heap's max, pop the max and push the new element. The N-th smallest is always the heap's root.

The interviewer pushed further: "What if N changes between queries?" That required a different approach — I switched to an order-statistic tree discussion and talked about augmenting a BST with subtree sizes. We ran out of time before I finished coding this variant, but the interviewer said the discussion was exactly what they were looking for.

Round 4: Behavioral + Googleyness

This round felt different from the others. The interviewer asked about:

  • A time I helped a teammate who was struggling with a technical problem
  • How I handle disagreements during code reviews
  • A situation where I had to push back on a product decision
  • What I do when I realize my initial approach to a problem is wrong

Google cares a lot about collaboration and intellectual humility. I made sure to give concrete examples where I showed adaptability and willingness to learn from others. The interviewer seemed to respond well when I described situations where I changed my mind based on new information rather than digging in.

Result

I received the offer about 8 days after the onsite. The recruiter called to walk me through the compensation package, which was competitive with other L4 offers I had seen reported online. The team-matching process started shortly after.

Tips

  1. Think out loud constantly. Google interviewers are evaluating your problem-solving process as much as your final answer. Even when you are stuck, narrate what you are considering and why.
  1. Interviewers are genuinely friendly. Every single person I spoke with was collaborative and encouraging. Do not be intimidated — treat it like a conversation with a colleague.
  1. Demonstrate teamwork in behavioral rounds. Google's "Googleyness" round heavily weights how you work with others. Have 4-5 stories ready about collaboration, mentorship, and handling conflict.
  1. Practice DP and backtracking deeply. Two of my four coding rounds involved these paradigms. Make sure you can identify when to apply memoization and when backtracking with pruning is the right tool.
  1. Ask clarifying questions. In every round, I spent the first 2-3 minutes asking questions about constraints, edge cases, and expected input sizes. This consistently led to better solutions and showed the interviewer I was being thoughtful.

Good luck to anyone preparing for Google. It was a rigorous but fair process, and the interviewers made me feel like they genuinely wanted me to succeed.