A Google-shaped process with research inside it
Of the three big labs, Google DeepMind's process looks most like a conventional big-tech loop, and that is because much of it is one. Candidate reports describe a resume screen that filters most applicants, a recruiter call, two coding rounds, ML rounds that you only reach after passing the coding, final conversations with team leads and a people-and-culture partner, and a hiring committee decision. Six or seven weeks end to end is commonly reported.
The recruiter call does more than check your CV. It is reported to place you toward the research-focused or the applied side of the research engineer role, which changes the weight of the later rounds. Tell the recruiter clearly which side you want and why; it is cheaper to steer here than to discover the mismatch in a team-lead interview.
Everything below comes from candidate reports and prep sites rather than an official DeepMind guide, so treat formats as typical rather than guaranteed.
Coding: classic problems, but the code has to run
The coding rounds are reported to use medium-to-hard problems from Google's internal question bank: implementing a trie for prefix matching, a snapshot array, minimising total Manhattan distance to a meeting point on a grid, adding numbers stored as reversed linked lists. Budget around twenty minutes per problem.
The difference from a standard Google interview, as candidates describe it, is that the code should run by the end. That changes how you work. Write in small, testable pieces; run the first piece before writing the second; keep a tiny test at the bottom of the file. Use of AI coding assistants is reported to be restricted, so practise in a plain editor.
The grid problem is a good example of what these rounds reward: a short insight beats a long search. Manhattan distance separates into independent x and y terms, and the sum of absolute deviations is minimised at the median, so the answer is two sorts and two sums.
def min_total_distance(grid: list[list[int]]) -> int:
"""Cells with 1 are people. Meet at one cell; minimise total Manhattan distance."""
rows = [r for r, row in enumerate(grid) for v in row if v]
cols = sorted(c for row in grid for c, v in enumerate(row) if v)
# x and y are independent; |x - m| summed is minimised at the median m
mr, mc = rows[len(rows) // 2], cols[len(cols) // 2]
return sum(abs(r - mr) for r in rows) + sum(abs(c - mc) for c in cols)
assert min_total_distance([[1,0,0,0,1],[0,0,0,0,0],[0,0,1,0,0]]) == 6The quiz: maths and ML fundamentals
The ML fundamentals round is the one candidates call the quiz. It is reported to have loosened from rigid textbook questions into a conversation, but the recruiter usually tells you in advance that maths and statistics will feature, and the emphasis is on intuition and derivation rather than recited definitions. Reported topics include gradients versus weights, convexity, probability puzzles, L1 versus L2 regularisation, regression and SVMs including kernels, Bayesian networks, and deriving the ELBO.
The L1 versus L2 question is a good test of the level expected. 'L1 gives sparse weights' is the definition. The explanation is in the gradient: the L2 penalty's gradient shrinks with the weight, so weights approach zero but rarely land on it, while the L1 penalty pulls with constant force regardless of size, and its proximal step - soft thresholding - sets any weight smaller than the threshold to exactly zero. Being able to show that in five lines of code is the answer that gets a follow-up instead of a nod.
import numpy as np
w = np.array([0.8, -0.05, 0.02, -0.6, 0.009])
lam, lr = 0.1, 0.5
l2_step = w - lr * (2 * lam * w) # shrinks proportionally
l1_prox = np.sign(w) * np.maximum(np.abs(w) - lr * lam, 0.0) # soft threshold
print(l2_step) # [ 0.72 -0.045 0.018 -0.54 0.0081] nothing hits zero
print(l1_prox) # [ 0.75 -0. 0. -0.55 0. ] small weights -> exactly 0ML design: the heart of the loop
ML design rounds are reported as the hardest part of the process. The format resembles system design but follows an ML pipeline: what data you would collect and how you would label it, how you would preprocess it, which model family and loss you would choose and why, how you would evaluate offline and online, and how you would deploy and monitor. Reported prompts include detecting policy-violating multimedia, on-device autocomplete or spell-checking, email auto-replies and video recommendations.
Interviewers push for first-principles justification. Why this loss and not that one? What happens to your metric if the class balance shifts? What would you do if the offline gain does not show up online? A useful habit is to state the evaluation before the model. Once you have said how you would know the system works, the architecture choices have something to be judged against.
For on-device problems, add the constraints that make them interesting: memory and latency budgets, privacy, and the fact that you cannot retrain on the device whenever you like. Naming those early shows you have thought about the product rather than the leaderboard.
Team leads, culture and the committee
Final rounds with team leads cover your background, your experience running ML experiments, and open-ended modelling problems. Anything on your CV is fair game, so be ready to defend past decisions in depth - including the baselines you ran and the experiments that failed.
The behavioural round asks familiar questions - a favourite project, a disagreement, a conflict on a team - plus why DeepMind specifically. Have a real answer that refers to work the lab has published and to the kind of problems you want to spend years on.
The hiring committee can return a hire, a hire pending team match, a request for more interviews, or a no. Because a committee reads written feedback rather than meeting you, clear communication in every round matters: think aloud, state assumptions, and summarise your answer at the end so the interviewer's notes say what you meant.