Comprehensive Interview Preparation Guide: Google Data Scientist (Junior Level)
Google's data scientist interview process for junior-level candidates is structured across multiple rounds spanning 4-8 weeks. The process includes an initial recruiter screening, two technical phone screens covering SQL/Python and statistics/experimentation, and four onsite rounds (machine learning, product sense, advanced SQL, and behavioral). The interviews assess technical depth, statistical reasoning, product intuition, and cultural fit. Each round uses live coding environments, case studies, and behavioral assessments to evaluate problem-solving ability, communication skills, and alignment with Google's data-driven culture.
Interview Rounds
Recruiter Screening
What to Expect
This initial screening call lasts 30-45 minutes and serves as a mutual fit assessment. The recruiter will verify your background, assess your interest in Google and the specific role/team, and ensure your experience aligns with the position. You may receive follow-up communications from the recruiting team regarding next steps. This round determines whether you advance to technical phone screens. The recruiter will ask about your motivation, technical background, and any scheduling constraints. They also provide information about the role, team, and Google's culture.
Tips & Advice
Research the specific team and product area you're interviewing for. Prepare 2-3 reasons why you're interested in Google beyond salary and brand. Review your resume carefully and be prepared to discuss each position and specific projects with metrics/outcomes. Ask thoughtful questions about the role, team dynamics, and what success looks like in the first 6 months. Be concise but thorough in your answers—recruiters appreciate candidates who are organized and show genuine interest. Ask about the interview timeline and what to expect in upcoming rounds.
Focus Topics
Career Goals and Learning Mindset
Discuss where you see your data science career in 3-5 years and what skills you want to develop. Emphasize your eagerness to learn, examples of how you've picked up new skills, and your interest in emerging areas like causal inference or recommendation systems. Show curiosity about staying current with data science trends.
Practice Interview
Study Questions
Technical Skills Overview
Briefly describe your proficiency in Python, SQL, and statistics. Mention any machine learning frameworks you've used (scikit-learn, TensorFlow, etc.), data visualization tools, and relevant coursework or certifications. Be honest about your level—recruiters respect candidates who know their strengths and gaps.
Practice Interview
Study Questions
Professional Background and Experience Summary
Succinctly walk through your career trajectory, focusing on data science, analytics, or engineering experiences. Highlight 2-3 key projects where you used data to drive decisions or build models. Emphasize quantifiable impact (e.g., improved accuracy by 15%, reduced processing time by 40%).
Practice Interview
Study Questions
Motivation for Google and the Role
Articulate why you're specifically interested in this data scientist role at Google (not just any tech company). Reference specific products, teams, or problems that excite you. Show understanding of Google's data-driven approach and how it aligns with your career goals.
Practice Interview
Study Questions
Technical Phone Screen 1: SQL & Python Data Analysis
What to Expect
This 45-60 minute virtual interview takes place via Google Meet with a shared code editor. You'll work through 1-2 coding problems involving SQL queries and Python data manipulation. The focus is on your ability to write correct, efficient code, think through edge cases, and explain your problem-solving approach. You may be asked to optimize a query, parse data structures, calculate metrics from raw data, or manipulate datasets to answer specific business questions. The interviewer will look for clean code, logical thinking, and communication throughout the process.
Tips & Advice
Start by clarifying the problem requirements and edge cases before coding. Think out loud about your approach—interviewers want to understand your thought process, not just see the final code. For SQL problems, consider query optimization and indexing strategies. For Python, write readable code with meaningful variable names. Test your solution with sample inputs and discuss time/space complexity. If you get stuck, ask for hints rather than sitting in silence. Remember that the interviewer is assessing both your technical ability and communication skills. Practice on LeetCode (Medium difficulty) and HackerRank with SQL and Python problems. Focus on problems involving data aggregation, joins, and transformations.
Focus Topics
Problem-Solving and Communication
Articulate your thinking process as you solve problems. Ask clarifying questions about requirements and constraints. Discuss your approach before coding. Walk through examples. Explain design decisions and trade-offs. Acknowledge assumptions. Revise your solution if you identify issues. Communicate the time and space complexity of your solution.
Practice Interview
Study Questions
Algorithm and Data Structure Fundamentals
Understand basic algorithms (sorting, searching, string manipulation) and data structures (arrays, linked lists, dictionaries, sets). Know Big-O complexity analysis. Apply these concepts to data manipulation problems. For example, using hash maps for fast lookups, efficient sorting for ranking problems, or binary search for optimization.
Practice Interview
Study Questions
SQL Query Writing and Optimization
Write efficient SQL queries to extract, filter, aggregate, and join data from multiple tables. Understand SQL fundamentals: SELECT, WHERE, GROUP BY, HAVING, JOIN (INNER, LEFT, RIGHT), UNION, subqueries, window functions. Optimize queries for performance by considering indexing, query plans, and avoiding expensive operations. Know how to calculate common metrics: counts, sums, averages, medians, percentiles.
Practice Interview
Study Questions
Python Data Manipulation with Pandas and NumPy
Use Pandas DataFrames and NumPy arrays to manipulate, clean, and transform data. Master operations like filtering, sorting, grouping, merging, reshaping, and aggregating data. Understand vectorized operations for efficiency. Implement data cleaning techniques: handling missing values, dealing with duplicates, type conversions. Write Pythonic code with proper error handling.
Practice Interview
Study Questions
Technical Phone Screen 2: Statistics & Experimentation
What to Expect
This 45-60 minute virtual interview focuses on your understanding of statistics, hypothesis testing, experimental design, and causal inference. You'll answer conceptual and applied questions about designing A/B tests, interpreting statistical results, understanding probability distributions, and analyzing experimental outcomes. The interviewer may present business scenarios (e.g., testing a new feature, analyzing campaign performance) and ask how you'd approach them statistically. This round assesses your ability to connect data analysis to business decision-making and your understanding of statistical rigor.
Tips & Advice
Focus on the business context, not just formulas. When discussing A/B testing, walk through the full workflow: defining metrics, calculating sample size, running the test, interpreting results, and accounting for multiple comparisons. Be ready to discuss confounding variables, selection bias, and when correlation doesn't imply causation. Understand p-values, confidence intervals, and statistical power. For junior candidates, emphasize the practical application and business impact rather than advanced theory. Use real examples from your past projects. Practice explaining statistical concepts in plain language—this is what you'd do when communicating results to non-technical stakeholders. Draw diagrams if it helps clarify your thinking.
Focus Topics
Causal Inference and Confounding Variables
Understand the difference between correlation and causation. Identify potential confounding variables in analyses. Discuss strategies to isolate causal effects: randomized experiments, matching, stratification, regression adjustment. Understand concepts like Simpson's Paradox. For observational data, discuss limitations in causal inference. Understand instrumental variables and difference-in-differences conceptually.
Practice Interview
Study Questions
Probability Distributions and Sampling
Understand common distributions: normal, binomial, Poisson, exponential. Know their properties, when to use them, and how to work with them. Understand sampling distributions, central limit theorem, and why sample size matters. Discuss concepts like standard error and how to estimate population parameters from samples. Know the relationship between population and sample, and why random sampling matters.
Practice Interview
Study Questions
A/B Testing and Experimental Design
Design end-to-end A/B tests for product changes. Define clear hypotheses and success metrics. Calculate required sample size based on effect size, significance level, and power. Understand randomization and ensuring valid control groups. Discuss minimum detection effect (MDE) and trade-offs between test duration and sensitivity. Know how to interpret results: p-values, confidence intervals, statistical significance vs. practical significance. Discuss common pitfalls: peeking, multiple comparisons, network effects, interfering treatments.
Practice Interview
Study Questions
Statistical Hypothesis Testing and Inference
Understand null and alternative hypotheses, p-values, significance levels (alpha), Type I and Type II errors, power, and confidence intervals. Know when to use t-tests, chi-square tests, z-tests, and other statistical tests. Interpret results: what does a p-value actually mean? How do you report confidence intervals? Understand limitations of statistical inference. Discuss Bayesian vs. frequentist approaches conceptually.
Practice Interview
Study Questions
Onsite Round 1: Machine Learning & Applied Modeling
What to Expect
This 45-60 minute onsite interview assesses your understanding of machine learning fundamentals, model selection, feature engineering, and model evaluation. You may be asked to describe an end-to-end machine learning project you've built, explain how different algorithms work, or solve an applied modeling problem. The interviewer wants to understand your thought process for model selection, how you handle overfitting, how you choose features, and how you evaluate model performance. For a junior candidate, the focus is on demonstrating solid understanding of fundamentals and the ability to think through practical trade-offs rather than deep theoretical knowledge.
Tips & Advice
Prepare 2-3 machine learning projects from your past work or education that you can discuss in detail. Walk through the full pipeline: problem definition, data collection and preprocessing, feature engineering, model selection, training, evaluation, and deployment. Be specific about decisions you made and why. Discuss trade-offs (accuracy vs. interpretability, training time vs. performance, complexity vs. generalization). When discussing algorithms, explain the intuition before getting into mathematical details. Show awareness of when different models are appropriate. Discuss how you'd validate your model (cross-validation, hold-out test set). Be prepared to discuss overfitting, underfitting, and regularization. For junior candidates, show curiosity and explain what you learned from projects. If asked about unfamiliar algorithms (e.g., Transformer architectures), admit gaps honestly and explain how you'd approach learning them.
Focus Topics
Overfitting, Underfitting, and Regularization
Understand the bias-variance tradeoff. Recognize signs of overfitting (high training accuracy, low validation accuracy) and underfitting (poor performance on both). Use regularization techniques: L1 (Lasso), L2 (Ridge), dropout, early stopping. Discuss trade-offs in regularization strength. Understand how model complexity, data size, and feature count affect overfitting risk. Know when to add/remove features or adjust model complexity.
Practice Interview
Study Questions
End-to-End Machine Learning Project Experience
Discuss a complete project you've built: problem statement, data sources and size, exploratory analysis, preprocessing steps, features created, models tried, evaluation approach, results, and business impact. Explain challenges encountered and how you addressed them. Discuss what you'd do differently with more time/resources. Be specific about technical choices and their justifications.
Practice Interview
Study Questions
Machine Learning Fundamentals and Model Selection
Understand supervised vs. unsupervised learning, regression vs. classification, and when to use each. Know fundamental algorithms: linear/logistic regression, decision trees, random forests, k-nearest neighbors, k-means clustering, naive Bayes. Understand trade-offs: bias-variance tradeoff, model complexity vs. interpretability, training time vs. accuracy. Know when to choose simple models (interpretability, data efficiency) vs. complex models (high dimensional problems, complex patterns). Discuss how to evaluate different models systematically.
Practice Interview
Study Questions
Model Evaluation and Validation
Choose appropriate metrics for different problems: accuracy, precision, recall, F1, ROC-AUC for classification; MSE, RMSE, MAE, R² for regression. Understand when each metric is appropriate (e.g., when classes are imbalanced). Use cross-validation to estimate generalization performance. Understand train/validation/test splits and why they matter. Discuss overfitting detection. Know how to interpret evaluation results and communicate them to stakeholders.
Practice Interview
Study Questions
Feature Engineering and Data Preprocessing
Extract and create features from raw data. Understand feature types (numerical, categorical, temporal) and appropriate transformations. Handle missing values, outliers, and imbalanced classes. Normalize and scale features appropriately. Create polynomial features, interaction terms, or domain-specific features. Understand feature selection techniques: correlation analysis, mutual information, model-based importance. Discuss the impact of preprocessing on model performance. Know when standardization or one-hot encoding is appropriate.
Practice Interview
Study Questions
Onsite Round 2: Product Sense & Business Case Analysis
What to Expect
This 45-60 minute interview evaluates your ability to think strategically about products and use data to drive business decisions. You'll be presented with open-ended questions about Google products (or products in general) and asked how you'd approach them from a data science perspective. Questions might involve designing metrics, evaluating feature impact, identifying opportunities for improvement, or analyzing user behavior. The goal is to see if you can connect technical data science skills with business strategy, define the right success metrics, and think through how to measure and improve product outcomes. For junior candidates, the focus is on structured thinking and showing curiosity rather than having all the answers.
Tips & Advice
Use a structured framework to approach case studies: (1) clarify the problem and business context, (2) define success metrics, (3) describe how you'd measure/analyze, (4) discuss trade-offs and constraints, (5) recommend next steps. Ask clarifying questions to understand the business goal before proposing solutions. Think about both short-term metrics (e.g., click-through rate) and long-term metrics (e.g., user retention). Consider user experience and potential negative consequences of optimizing one metric. Be specific about how you'd validate your recommendations (experiments, analysis). Show thinking like a product scientist sitting next to a product manager. Discuss confounding variables and how you'd isolate causal effects. For questions about Google products, familiarize yourself with them: Gmail, Search, Maps, YouTube, Docs, etc. Understand their business model and key success metrics.
Focus Topics
Business Strategy and Data-Driven Decision Making
Think strategically about business problems. Understand different types of decisions: should we launch? should we iterate? where should we invest resources? Connect data analysis to business strategy. Understand trade-offs: short-term revenue vs. long-term user satisfaction, revenue per user vs. user growth, feature breadth vs. focus. Discuss how external factors (competition, regulation, seasonality) affect strategy. Think about unintended consequences: could optimizing for one metric harm other important outcomes?
Practice Interview
Study Questions
Case Study Problem-Solving Framework
Apply a structured approach to open-ended questions: (1) clarify business problem and context, (2) identify success metrics and measurement approach, (3) outline data collection and analysis, (4) discuss expected findings and limitations, (5) recommend decisions and next steps. Ask questions before proposing solutions. Make reasonable assumptions and state them explicitly. Structure your thinking verbally so the interviewer can follow. Adjust your approach based on feedback. Be specific rather than vague.
Practice Interview
Study Questions
A/B Testing for Product Evaluation
Design experiments to evaluate product changes. Define hypotheses and success metrics upfront. Discuss trade-offs in test design: statistical power vs. test duration, metric sensitivity vs. business significance. Address practical concerns: when to run tests, how many concurrent tests, sequential testing. Interpret results cautiously: avoid p-hacking, multiple comparisons, and premature conclusions. Discuss how to communicate results to non-technical stakeholders and make launch decisions based on data.
Practice Interview
Study Questions
Google Product Metrics and Analytics
Understand key metrics for various Google products: click-through rate, impressions, engagement, retention, DAU/MAU, time spent, user satisfaction. Know how to measure success across the product funnel: acquisition, activation, retention, revenue, referral. Understand the relationship between different metrics (e.g., how click-through rate affects conversion). Discuss how metrics differ by product type and business model. Think about leading vs. lagging indicators and early signals of success.
Practice Interview
Study Questions
Metric Design and Definition
Design appropriate metrics to measure success for given problems. Understand the difference between vanity metrics (look good but don't drive decisions) and actionable metrics (directly influenced by decisions). Create metrics that align with business goals. Consider multiple dimensions: short-term vs. long-term, user-focused vs. business-focused. Discuss how to detect issues (anomalies, drops) and avoid manipulation. Define clear, unambiguous metric definitions for consistent measurement.
Practice Interview
Study Questions
Onsite Round 3: Advanced SQL & Complex Data Analysis
What to Expect
This 45-60 minute onsite interview focuses on advanced SQL, database optimization, and solving complex analytical problems. You'll work through SQL coding problems in a shared editor, potentially combining multiple queries, using advanced features like window functions or CTEs, and optimizing for performance. Problems may involve complex joins across many tables, aggregating data at different levels, calculating running totals or rankings, or extracting specific insights from complicated data structures. This round goes deeper than the phone screen, testing your ability to write production-quality SQL and think about scalability.
Tips & Advice
Write clear, readable SQL with meaningful aliases and indentation. Use CTEs (WITH clauses) to break complex queries into logical steps. Understand window functions (ROW_NUMBER, RANK, LAG/LEAD, SUM OVER) for sophisticated calculations. Think about query performance: avoid Cartesian products, use proper join types, consider indexing. For each problem, start by understanding the data schema and relationship between tables. Verify your logic with sample data before optimizing. Ask clarifying questions about performance requirements and data volume. Discuss trade-offs between query complexity and readability. Be prepared to optimize queries if the interviewer asks. Practice complex SQL on platforms like LeetCode or Mode Analytics with medium-to-hard problems involving multiple joins, aggregations, and window functions.
Focus Topics
Query Optimization and Database Performance
Optimize queries for performance: understand query execution plans, avoid expensive operations (full table scans, Cartesian products), use appropriate indexes. Discuss indexing strategies: single-column, composite, and covering indexes. Write efficient queries that scale to billions of rows. Understand the impact of WHERE clauses, JOIN order, and GROUP BY on performance. Discuss trade-offs between query speed and readability. Know when to denormalize data for performance.
Practice Interview
Study Questions
Problem-Solving with Complex Data Structures
Decompose complex analytical questions into SQL queries. Understand data schema quickly and identify relevant tables and keys. Plan your query approach before writing code. Verify logic with small examples. Handle ambiguous requirements by clarifying or making reasonable assumptions. Test edge cases and discuss potential issues. Optimize progressively: first get correct results, then optimize if needed. Explain your approach and why you made specific design choices.
Practice Interview
Study Questions
Advanced SQL: Window Functions and CTEs
Master window functions: ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD, SUM/AVG/COUNT OVER, and others. Use these for running totals, rankings, comparisons with previous rows, and complex aggregations. Understand PARTITION BY and ORDER BY within window functions. Use Common Table Expressions (CTEs) with WITH clauses to organize complex queries. Combine multiple CTEs for readability. Understand when to use temporary tables vs. CTEs.
Practice Interview
Study Questions
Complex Joins and Data Aggregation
Write sophisticated queries joining 4+ tables with multiple join conditions. Understand different join types and implications (INNER, LEFT, RIGHT, FULL, CROSS). Aggregate at multiple levels and handle complex grouping logic. Deal with one-to-many relationships correctly. Understand NULL handling in joins and aggregations. Perform calculations across different grain levels (e.g., user-day vs. user-week). Handle edge cases in joins (duplicates, missing keys).
Practice Interview
Study Questions
Onsite Round 4: Behavioral & Culture Fit
What to Expect
This 45-60 minute interview assesses whether you're a good culture fit for Google and the broader team. The interviewer will ask behavioral questions about your past experiences, how you handle challenges, your collaboration style, and your alignment with Google's values. You may be asked about difficult projects, conflicts with colleagues, how you've learned from failures, your communication approach, and what excites you about Google's mission. This round evaluates your professional maturity, teamwork ability, communication skills, and authentic interest in working at Google. For junior candidates, the focus is on demonstrating coachability, collaboration, and growth mindset.
Tips & Advice
Prepare 5-7 specific examples from your past that demonstrate key competencies: problem-solving, collaboration, handling challenges, learning from mistakes, communication. Use the STAR method (Situation, Task, Action, Result) for structure. Be authentic—interviewers can tell when you're reciting a scripted answer. For junior candidates, focus on demonstrating growth: what did you learn? how did you improve? Frame challenges as learning opportunities. Show genuine interest in Google's mission, products, and culture. Ask thoughtful questions that show you've researched the company and understand your potential role. Mention specific Google products or initiatives you find compelling. Be ready to discuss why you want to work on the specific team you're interviewing with. Show that you understand what cross-functional collaboration means in a data science context (working with engineers, product managers, analysts). Remember that this round is mutual assessment—you're also deciding if Google is right for you.
Focus Topics
Motivation for Google and Alignment with Company Values
Articulate genuine reasons for wanting to work at Google beyond salary/brand. Reference specific products, challenges, or values that resonate with you. Show understanding of Google's data-driven culture and mission. Discuss how your work as a data scientist aligns with Google's impact. For the specific team/area, explain what excites you about the problems they're solving. Show that you've thought about what you'd like to contribute.
Practice Interview
Study Questions
Communication and Explaining Technical Concepts
Describe how you explain technical findings to non-technical stakeholders. Give an example where you presented data-driven recommendations to business partners or executives. How did you make complex concepts understandable? Did your recommendations influence decisions? Discuss how you balance technical rigor with business practicality in communication. Show that you can translate data science into business language.
Practice Interview
Study Questions
Collaboration and Teamwork
Describe experiences working with cross-functional teams: engineers, product managers, analysts. What went well? What were tensions or disagreements? How did you navigate them? Show ability to explain technical concepts to non-technical stakeholders. Discuss your communication style and how you adapt it for different audiences. Provide examples of how you've supported teammates or learned from colleagues. For data scientists, emphasize how you bridge technical and business perspectives.
Practice Interview
Study Questions
Project Challenges and Problem-Solving
Discuss a past project where you faced significant challenges (ambiguous requirements, technical obstacles, resource constraints, unexpected results). Walk through how you identified the root cause, what approaches you tried, and how you persisted. Show learning: what would you do differently? How did the experience make you better? Discuss the impact of your solution. For junior candidates, it's okay to mention projects from school or smaller scope—focus on your contribution and learning.
Practice Interview
Study Questions
Learning and Growth Mindset
Discuss a skill you've developed or a topic you've learned recently and how you approach learning new things. Mention challenges you've overcome through learning. Show curiosity about new technologies, methodologies, or domains. Discuss how you stay current with data science trends. For junior candidates, this is important—demonstrate that you're committed to growing your skills and adapting to new challenges. Discuss coursework, personal projects, or areas you're actively learning.
Practice Interview
Study Questions
Frequently Asked Data Scientist Interview Questions
Sample Answer
WITH cohort AS (
SELECT user_id, signup_date::date AS cohort_date
FROM users
),
events_dedup AS (
-- one event per user per day
SELECT DISTINCT user_id, event_date::date AS event_date
FROM events
),
joined AS (
SELECT
c.cohort_date,
e.user_id,
(e.event_date - c.cohort_date) AS days_since_signup
FROM cohort c
JOIN events_dedup e
ON e.user_id = c.user_id
WHERE e.event_date BETWEEN c.cohort_date AND c.cohort_date + INTERVAL '7 day'
)
SELECT
cohort_date,
COUNT(DISTINCT CASE WHEN days_since_signup = 0 THEN user_id END) AS day_0,
COUNT(DISTINCT CASE WHEN days_since_signup = 1 THEN user_id END) AS day_1,
COUNT(DISTINCT CASE WHEN days_since_signup = 2 THEN user_id END) AS day_2,
COUNT(DISTINCT CASE WHEN days_since_signup = 3 THEN user_id END) AS day_3,
COUNT(DISTINCT CASE WHEN days_since_signup = 4 THEN user_id END) AS day_4,
COUNT(DISTINCT CASE WHEN days_since_signup = 5 THEN user_id END) AS day_5,
COUNT(DISTINCT CASE WHEN days_since_signup = 6 THEN user_id END) AS day_6,
COUNT(DISTINCT CASE WHEN days_since_signup = 7 THEN user_id END) AS day_7
FROM joined
GROUP BY cohort_date
ORDER BY cohort_date;Sample Answer
Sample Answer
Sample Answer
Sample Answer
Sample Answer
-- 1) Parameters: define month granularity. Adjust date_trunc / months_between funcs per SQL dialect.
with users_cohort as (
select
u.user_id,
date_trunc('month', u.signup_date) as cohort_month
from users u
),
-- 2) Pre-aggregate orders into month buckets and compute period (months since signup)
orders_preagg as (
select
o.user_id,
date_trunc('month', o.order_date) as order_month,
sum(o.amount) as revenue_month
from orders o
group by 1,2
),
-- 3) Join to cohorts to compute period index (0 = signup month, 1 = next month, ...)
orders_with_period as (
select
o.user_id,
uc.cohort_month,
o.order_month,
date_part('year', o.order_month) * 12 + date_part('month', o.order_month)
- (date_part('year', uc.cohort_month) * 12 + date_part('month', uc.cohort_month)) as period_months,
o.revenue_month
from orders_preagg o
join users_cohort uc using (user_id)
where o.order_month >= uc.cohort_month -- ignore pre-signup orders (if any)
),
-- 4) Cohort-period aggregates: cohort_size, cohort_revenue, active_users
cohort_period as (
select
cohort_month,
period_months,
sum(revenue_month) as cohort_revenue,
count(distinct user_id) as active_users
from orders_with_period
group by 1,2
),
cohort_size as (
select cohort_month, count(*) as cohort_signups
from users_cohort
group by 1
),
-- 5) Compute per-period ARPU and retention (per-signup ARPU = cohort_revenue / cohort_signups)
cohort_metrics as (
select
cp.cohort_month,
cp.period_months,
cp.cohort_revenue,
cp.active_users,
cs.cohort_signups,
cp.cohort_revenue::numeric / cs.cohort_signups as arpu_per_signup,
cp.active_users::numeric / cs.cohort_signups as retention_rate
from cohort_period cp
join cohort_size cs using (cohort_month)
),
-- 6) Cohort LTV = sum over periods of arpu_per_signup (optionally discount future periods)
cohort_ltv as (
select
cohort_month,
sum(arpu_per_signup) as cohort_ltv_no_discount
from cohort_metrics
group by 1
)
-- 7) Assign cohort LTV to each user (per-customer expected LTV)
select
u.user_id,
u.cohort_month,
cl.cohort_ltv_no_discount as expected_ltv
from users_cohort u
left join cohort_ltv cl using (cohort_month);Sample Answer
WITH dedup_addresses AS (
-- Keep one row per customer + physical address (most recent effective_from)
SELECT
a.*,
ROW_NUMBER() OVER (
PARTITION BY a.customer_id,
a.address_line1, a.address_line2, a.city, a.state, a.postal_code
ORDER BY a.effective_from DESC, a.address_id DESC
) AS rn
FROM addresses a
),
current_addresses AS (
-- only the deduplicated rows
SELECT * EXCEPT (rn)
FROM dedup_addresses
WHERE rn = 1
),
orders_with_candidates AS (
-- join orders to candidate addresses valid at or before order_time
SELECT
o.order_id,
o.customer_id,
o.order_time,
ca.address_id,
ca.address_line1,
ca.city,
ca.state,
ca.postal_code,
ca.effective_from,
ROW_NUMBER() OVER (
PARTITION BY o.order_id
ORDER BY ca.effective_from DESC, ca.address_id DESC
) AS addr_rank
FROM orders o
LEFT JOIN current_addresses ca
ON ca.customer_id = o.customer_id
AND ca.effective_from <= o.order_time
)
-- select exactly one address per order (addr_rank = 1). NULLs mean no prior address.
SELECT
o.order_id,
o.customer_id,
o.order_time,
owc.address_id,
owc.address_line1,
owc.city,
owc.state,
owc.postal_code,
owc.effective_from AS address_effective_from
FROM orders o
LEFT JOIN orders_with_candidates owc
USING (order_id)
WHERE owc.addr_rank = 1 OR owc.addr_rank IS NULL;Sample Answer
import numpy as np
def _clean_and_stats(x):
x = np.asarray(x, dtype=float)
x = x[~np.isnan(x)] # drop NaNs
n = x.size
if n == 0:
raise ValueError("Input array is empty or all NaNs.")
mean = x.mean()
# use ddof=1 for sample standard deviation
if n < 2:
std = np.nan
else:
std = x.std(ddof=1)
return n, mean, std
def cohen_d_pooled(x, y):
"""
Cohen's d using pooled standard deviation (assumes equal variances).
Assumptions:
- Two independent samples
- Population variances are equal (homoscedasticity)
- Uses sample std (ddof=1) and pooled estimator
Raises ValueError if a sample is empty or contains only NaNs.
"""
n1, m1, s1 = _clean_and_stats(x)
n2, m2, s2 = _clean_and_stats(y)
if n1 < 2 or n2 < 2:
raise ValueError("Each sample must have at least 2 non-NaN observations for pooled SD.")
pooled_var = (((n1 - 1) * s1**2) + ((n2 - 1) * s2**2)) / (n1 + n2 - 2)
s_pooled = np.sqrt(pooled_var)
if s_pooled == 0:
return 0.0 # no variability -> effect size zero (or undefined)
return (m1 - m2) / s_pooled
def cohen_d_unequal_variance(x, y):
"""
Cohen's d variant for unequal variances (does not pool).
Standardizer: sqrt( (s1^2 + s2^2) / 2 )
Assumptions:
- Two independent samples
- Used when homoscedasticity is questionable
- Uses sample std (ddof=1)
Raises ValueError if a sample is empty or contains only NaNs.
"""
n1, m1, s1 = _clean_and_stats(x)
n2, m2, s2 = _clean_and_stats(y)
if np.isnan(s1) or np.isnan(s2):
raise ValueError("Each sample must have at least 2 non-NaN observations to compute sample std.")
s_unbiased = np.sqrt((s1**2 + s2**2) / 2.0)
if s_unbiased == 0:
return 0.0
return (m1 - m2) / s_unbiasedSample Answer
Sample Answer
Recommended Additional Resources
- LeetCode: Practice SQL (Easy to Hard) and Python coding problems relevant to data science
- HackerRank: Data science and SQL challenges with detailed explanations
- Mode Analytics SQL Tutorial: Interactive learning for advanced SQL concepts
- Google Cloud BigQuery Documentation: Understand Google's data warehouse and query optimization
- Cracking the PM Interview by McDowell & Bavaro: While for PMs, contains valuable frameworks for case studies applicable to data scientists
- Designing Data-Intensive Applications by Martin Kleppmann: Deep understanding of data systems and scalability
- Statistical Rethinking by Richard McElreath: Rigorous approach to statistics and causal inference
- Pandas Documentation and Real Python Pandas Tutorials: Master data manipulation
- Google's 'People + AI Guidebook': Understand Google's approach to responsible AI (valuable for product sense questions)
- Blind.com and Levels.fyi: Community insights on Google interview experiences and expectations
- Kaggle Competitions: Real-world data science problems and community solutions
- Interview.io or Pramp: Practice mock interviews with peers or professionals
- Your favorite Google product deep-dives: Read about metrics, features, and strategy (Google official blogs, case studies)
Search Results
Google Data Scientist Interview (questions, process, prep)
Why Google? How do you sort your priorities when engaged in multitasking? Describe a past project you worked on. In what ...
Google Data Scientist Interview Guide (2025) – Process, Questions ...
Behavioral and communication questions · 1. Describe a data project you worked on. · 2. What are some effective ways to make data more ...
Google Data Scientist Interview Questions
The Google data scientist interview questions on coding include SQL, data analysis, and Python coding questions.
Google Data Scientist Interview Guide | Sample Questions (2025)
1. Recruiter screening · Why do you want to work on [Google team]? · What are the biggest challenges when working in [domain] data? · Talk about your experience ...
Top 10 Data Scientist Interview Questions (With Sample Answers ...
Master the top 10 data scientist interview questions with expert answers. Includes technical, behavioral, and insider tips to land your ...
Top Data Science Interview Questions and Answers (2025)
In this article, we will explore what are the most commonly asked Data Science Technical Interview Questions which will help both aspiring and experienced data ...
This interview preparation guide was generated using AI-powered research from the sources listed above. While we strive for accuracy, we recommend verifying critical information from official company sources.
Want to create your own tailored preparation guide using our deep research?
Get Started for FreeInterview-Ready Courses
Visual-first, interactive, structured learning paths