The Interview Question

"Walk me through a data science project you've worked on, from understanding the business problem to deploying the solution and measuring its impact."

This is arguably the most common technical screening question at top-tier tech companies. Google and Meta use it to assess your end-to-end thinking, communication skills, and depth of technical understanding.

Why Companies Ask This Question

At Google and Meta, the interviewer is listening for:

1. Structured Problem Solving — Can you decompose a complex problem?
2. Technical Rigor — Do you understand the tools, methods, and trade-offs?
3. Business Orientation — Do you connect technical work to outcomes?
4. Communication Clarity — Can you explain complex topics simply?
5. Self-Awareness — Do you acknowledge limitations and trade-offs?

The STAR-D Framework for Project Walkthroughs

Use this adapted framework specifically designed for data science project narratives:

S — Situation & Business Context

• What was the company/team/product?
• What business problem were you solving?
• What was the impact if left unsolved?

T — Task & Problem Definition

• How was the problem framed as a data science problem?
• What were the key metrics and success criteria?
• What were the constraints (time, data, compute)?

A — Approach & Technical Design

• What data did you use and how did you obtain it?
• What features/engineering decisions did you make?
• What model/approach did you choose and why?
• What were the alternatives considered?

R — Results & Impact

• How did you evaluate the model?
• What were the quantitative results?
• What was the business impact ($, %, users)?

D — Discussion & Reflection

• What would you do differently?
• What were the limitations?
• What follow-up work did this enable?

Example Walkthrough: Churn Prediction at a SaaS Company

Here's a comprehensive example you can adapt:

Situation

"At my previous company, a B2B SaaS platform, we were experiencing 15% annual churn, costing approximately $12M in ARR. The account management team had no systematic way to identify at-risk accounts before they churned."

Task

"I was tasked with building an early-warning churn prediction system. The goal was to identify accounts likely to churn within the next 90 days with at least 70% precision, so the CS team could intervene proactively. Success meant reducing churn by at least 2 percentage points."

Approach

"I structured this as a supervised binary classification problem — predicting whether an account would churn within 90 days."

Data Collection & Engineering:

import pandas as pd
import numpy as np

# Feature engineering from raw event logs
def build_churn_features(events_df, accounts_df, prediction_window=90):
    """
    Build feature matrix for churn prediction.
    
    Args:
        events_df: Raw product interaction events
        accounts_df: Account metadata
        prediction_window: Days ahead to predict churn
    
    Returns:
        Feature matrix with one row per account
    """
    features = {}
    
    for account_id in accounts_df['account_id']:
        account_events = events_df[events_df['account_id'] == account_id]
        
        # Recency features
        features[account_id] = {
            'days_since_last_login': (
                pd.Timestamp.now() - account_events['timestamp'].max()
            ).days,
            'days_since_last_billing': (
                pd.Timestamp.now() - account_events[
                    account_events['event_type'] == 'payment'
                ]['timestamp'].max()
            ).days,
        }
        
        # Engagement frequency features (last 30 days)
        recent = account_events[
            account_events['timestamp'] >= pd.Timestamp.now() - pd.Timedelta(days=30)
        ]
        features[account_id].update({
            'logins_last_30d': len(recent[recent['event_type'] == 'login']),
            'actions_last_30d': len(recent),
            'unique_features_used': recent['feature_name'].nunique(),
        })
        
        # Trend features (comparing last 30d vs prior 30d)
        prior = account_events[
            (account_events['timestamp'] >= pd.Timestamp.now() - pd.Timedelta(days=60)) &
            (account_events['timestamp'] < pd.Timestamp.now() - pd.Timedelta(days=30))
        ]
        features[account_id]['engagement_trend'] = (
            len(recent) / max(len(prior), 1)
        )
        
        # Account-level features
        account_info = accounts_df[
            accounts_df['account_id'] == account_id
        ].iloc[0]
        features[account_id].update({
            'account_age_days': (
                pd.Timestamp.now() - account_info['signup_date']
            ).days,
            'mrr': account_info['monthly_recurring_revenue'],
            'num_users': account_info['num_licensed_users'],
            'plan_tier': account_info['plan_tier'],
        })
    
    return pd.DataFrame(features).T

# Build feature matrix
X = build_churn_features(events_df, accounts_df)

# Define target variable (churn within 90 days)
y = accounts_df.set_index('account_id')['churned_within_90d']

Model Selection & Training:

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import TimeSeriesSplit
from sklearn.metrics import precision_score, recall_score, f1_score
import shap

# Time-aware cross-validation (critical for time-dependent data)
tscv = TimeSeriesSplit(n_splits=5)

model = GradientBoostingClassifier(
    n_estimators=200,
    max_depth=5,
    learning_rate=0.1,
    subsample=0.8,
    random_state=42
)

# Train with temporal splits to avoid data leakage
for train_idx, val_idx in tscv.split(X):
    X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
    y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]
    
    model.fit(X_train, y_train)
    y_pred = model.predict(X_val)
    
    print(f"Precision: {precision_score(y_val, y_pred):.3f}")
    print(f"Recall: {recall_score(y_val, y_pred):.3f}")
    print(f"F1: {f1_score(y_val, y_pred):.3f}")

# SHAP for interpretability (critical for stakeholder trust)
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_val)

Results

"The final model achieved 78% precision and 72% recall on our held-out test set. We deployed it as a weekly batch pipeline that flagged ~50 accounts per week. The CS team used these flags to trigger outreach workflows. Over 6 months, we reduced churn by 3.2 percentage points, recovering approximately $2.4M in ARR."

Company-Specific Tips

Google Interview Tips

• Emphasize your approach to avoiding data leakage
• Discuss statistical significance of your results
• Mention how you'd design an experiment to validate the model's impact
• Talk about scalability and how your solution would work at Google's scale

Meta Interview Tips

• Lead with user impact — how many users were affected?
• Discuss A/B testing as part of your deployment strategy
• Mention how you handled edge cases and fairness
• Show awareness of privacy considerations in data usage

Follow-Up Questions to Prepare For

"What would you do differently?"

"Looking back, I'd invest more time in feature engineering around usage patterns rather than raw counts. I'd also implement a more sophisticated temporal feature approach using rolling windows rather than fixed lookback periods."

"How would you handle this at 10x scale?"

"I'd move the feature computation to Spark, implement incremental feature computation rather than full recomputation, and use a model serving layer like Vertex AI or SageMaker for real-time predictions."

"How did you handle class imbalance?"

"We had a 12% churn rate. I used SMOTE for initial training but ultimately found that adjusting the classification threshold with precision-recall optimization worked better for our use case, where false positives had a real cost."

"What was the hardest part?"

"The hardest part was defining 'churn' operationally — was it no login for 30 days? Cancellation? Non-renewal? We had to align with CS, Sales, and Finance on a definition that was both measurable and actionable."

Common Mistakes to Avoid

1. Jumping to modeling without problem framing — Always start with the business problem
2. Not mentioning data quality work — 80% of real DS work is data preparation
3. Forgetting to discuss evaluation metrics — Don't just say "accuracy"
4. Ignoring deployment and monitoring — Production ML requires ongoing maintenance
5. Not quantifying impact — Always include numbers ($, %, users)
6. Oversimplifying trade-offs — Show you understand the complexity
7. Being vague about your specific contribution — Clarify what YOU did vs. the team

Quiz: Test Your Understanding

Related Topics

• Metrics Design for Data Scientists
• A/B Testing Deep Dive
• SQL Live Coding
• Machine Learning Application
• Data Quality & Messy Data