Data Science Interview Questions and Answers

Data science interviews have changed. A few years ago most of the questions were definitions of statistics terms. Today employers test whether you can get data with SQL, clean and explore it in pandas, reason about statistics and experiments, build a sensible model, and explain the result to people who do not write code. This guide gives you 50 data science interview questions and answers that follow that structure.

Every answer starts with a short, direct response you can say aloud, followed by detail, a table or working code. The SQL examples were run in SQLite and the Python examples were run before they were added, so the printed output under each sample is the real result. Formulas are written in words, so nothing depends on an image. Where a topic needs more depth, the answer points you to the Statistics, Machine Learning or Python interview pages.

The guide has eight parts: 8 questions on basics and workflow, 9 on SQL, 5 on pandas, 8 on statistics essentials, 4 on machine learning essentials, 7 on A B testing, 4 case studies and 5 project and behavioural questions. Freshers can start at the top. Experienced candidates should go straight to experimentation, case studies and project questions.

Key points

• 50 questions in eight parts, from workflow and SQL to case studies.
• Every answer opens with a short answer you can say in an interview.
• SQL and Python examples were run, and the real output is shown.
• Statistics and machine learning are covered briefly, with links to the full pages.
• Includes A B testing and case study answers with what the interviewer is listening for.

In this guide

Data Science Basics and Workflow (Freshers)

Freshers are usually asked how data science work is organised and how it differs from neighbouring roles. Answer with the full project flow in mind, from the business question to a monitored result.

Q1. What is data science, and how does it differ from data analytics and machine learning engineering?

Data science uses statistics, programming and domain knowledge to answer business questions and build predictive models from data. Data analytics focuses on describing what happened and why, usually with SQL and dashboards. Machine learning engineering focuses on deploying and running models reliably in production. In small teams one person often does all three.

Q2. What are the steps in a data science project?

A typical project moves through problem definition, data collection, cleaning, exploratory analysis, feature engineering, modelling, evaluation, deployment and monitoring. The steps repeat, because results from modelling often send you back to the data. The first step matters most, since a model built for the wrong question has no value.

• Define the business question and how success will be measured.
• Collect and join the data, then clean it and check its quality.
• Explore the data to find patterns, gaps and problems.
• Build features, train models and compare them with a simple baseline.
• Evaluate on unseen data using a metric that matches the business cost.
• Deploy the model, then monitor it for drift and decay.

Q3. What are structured, semi structured and unstructured data?

Structured data fits rows and columns with a fixed schema, such as a sales table. Semi structured data has tags or keys but no rigid schema, such as JSON and XML files. Unstructured data has no predefined format, such as free text, images, audio and video. Each needs different storage and processing tools.

Q4. What is exploratory data analysis, and what do you check first?

Exploratory data analysis is looking at the data before modelling to understand its shape, quality and patterns. Start with the number of rows and columns, the data types, missing values, duplicates, and summary statistics. Then look at distributions, outliers, and relationships between features and the target.

import pandas as pd
import numpy as np

rng = np.random.default_rng(0)
df = pd.DataFrame({
    "age": rng.integers(21, 60, 8).astype(float),
    "city": ["Pune", "Pune", "Bangalore", None, "Pune", "Bangalore", "Bangalore", "Pune"],
    "spend": [1200, 800, 1500, 900, 99999, 1100, 700, 1300],
})
df.loc[2, "age"] = None

print(df.shape)
print(df.dtypes.to_string())
print(df.isna().sum().to_string())
print(df["spend"].describe().round(1).to_string())

(8, 3)
age      float64
city         str
spend      int64
age      1
city     1
spend    0
count        8.0
mean     13437.4
std      34977.2
min        700.0
25%        875.0
50%       1150.0
75%       1350.0
max      99999.0

The maximum spend is far above the rest in the printed summary, which is the kind of outlier to investigate before modelling.

Q5. How do you check the quality of a dataset before trusting it?

Check completeness, uniqueness, validity, consistency and freshness. Look for missing values, duplicate keys, values outside a sensible range, categories spelled in different ways, dates that do not make sense, and totals that do not match the source system. Write these checks as code so they run again each time the data refreshes.

import pandas as pd

orders = pd.DataFrame({
    "order_id": [1, 2, 2, 4],
    "amount": [500, -20, -20, 750],
    "status": ["Paid", "paid", "paid", "Refunded"],
    "order_date": pd.to_datetime(["2026-01-05", "2026-01-06", "2026-01-06", "2027-03-01"]),
})

checks = {
    "duplicate order ids": orders["order_id"].duplicated().sum(),
    "negative amounts": (orders["amount"] < 0).sum(),
    "inconsistent status spellings": orders["status"].nunique() - orders["status"].str.lower().nunique(),
    "dates in the future": (orders["order_date"] > "2026-12-31").sum(),
}

for name, count in checks.items():
    print(f"{name}: {count}")

duplicate order ids: 1
negative amounts: 2
inconsistent status spellings: 1
dates in the future: 1

Q6. What is the difference between ETL and ELT?

ETL extracts data, transforms it on a separate processing server, and then loads the result into the warehouse. ELT loads the raw data into the warehouse first and transforms it there using the warehouse engine. ELT is common with modern cloud warehouses because storage is cheap and the raw data stays available for new questions.

Q7. How do you choose the right metrics for a business problem?

Start from the decision the metric will support. A good metric is tied to the business goal, can be measured reliably, is hard to game and moves when the real outcome moves. Pair a main metric with guardrail metrics that catch harm, for example pairing conversion with refund rate.

Q8. Which tools and technologies does a data scientist use day to day?

Most data scientists use Python or R for analysis and modelling, SQL for getting data, Jupyter notebooks or an editor for development, and Git for version control. Visualisation tools such as Power BI or Tableau help with sharing results, and cloud platforms such as AWS, Azure or Google Cloud host larger workloads.

SQL for Data Science (Freshers and Intermediate)

Almost every data science interview includes a live SQL question. The examples below were run in SQLite, and the same ideas work in MySQL, PostgreSQL and SQL Server with minor changes in syntax.

Q9. What is the difference between WHERE and HAVING?

WHERE filters individual rows before grouping happens, and HAVING filters the groups after aggregation. You cannot use an aggregate such as COUNT or AVG inside WHERE. Use WHERE to reduce the data early, which is faster, and HAVING for conditions on the grouped result.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("""
CREATE TABLE emp (name TEXT, dept TEXT, salary INT);
INSERT INTO emp VALUES ('Asha','Data',90000),('Ravi','Data',120000),
                       ('Kiran','Sales',70000),('Divya','Sales',85000),('Imran','HR',60000);
""")

query = """
SELECT dept, COUNT(*) AS people, AVG(salary) AS avg_salary
FROM emp
WHERE salary > 65000
GROUP BY dept
HAVING COUNT(*) >= 2
ORDER BY dept
"""

for row in con.execute(query):
    print(row)

('Data', 2, 105000.0)
('Sales', 2, 77500.0)

Q10. What are the different types of joins?

An inner join returns only rows that match in both tables. A left join returns all rows from the left table and the matches from the right, with nulls where there is no match. A right join does the reverse, and a full outer join returns all rows from both. A cross join pairs every row with every row.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("""
CREATE TABLE customers (id INT, name TEXT);
CREATE TABLE orders (id INT, customer_id INT, amount INT);
INSERT INTO customers VALUES (1,'Asha'),(2,'Ravi'),(3,'Meena');
INSERT INTO orders VALUES (10,1,500),(11,1,300),(12,2,700);
""")

print("inner join")
for r in con.execute("SELECT c.name, o.amount FROM customers c JOIN orders o ON o.customer_id = c.id"):
    print(r)

print("left join, customers with no orders")
for r in con.execute("""SELECT c.name FROM customers c
                        LEFT JOIN orders o ON o.customer_id = c.id WHERE o.id IS NULL"""):
    print(r)

inner join
('Asha', 300)
('Asha', 500)
('Ravi', 700)
left join, customers with no orders
('Meena',)

The left join with a null check is the standard way to find rows in one table that have no match in another.

Q11. What are window functions, and how do you get the top earner in each department?

A window function calculates a value across a set of related rows without collapsing them into one row, as GROUP BY does. Use ROW_NUMBER, RANK or DENSE_RANK with PARTITION BY and ORDER BY to rank rows inside each group, then keep rank 1 in an outer query.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("""
CREATE TABLE emp (name TEXT, dept TEXT, salary INT);
INSERT INTO emp VALUES ('Asha','Data',90000),('Ravi','Data',120000),('Meena','Data',110000),
                       ('Kiran','Sales',70000),('Divya','Sales',85000),('Imran','HR',60000);
""")

query = """
SELECT dept, name, salary FROM (
    SELECT *, ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn
    FROM emp
) WHERE rn = 1 ORDER BY dept
"""

for row in con.execute(query):
    print(row)

('Data', 'Ravi', 120000)
('HR', 'Imran', 60000)
('Sales', 'Divya', 85000)

Q12. How do you find the second highest salary?

Rank the distinct salaries with DENSE_RANK in descending order and pick rank 2. DENSE_RANK is safer than ROW_NUMBER because tied salaries share a rank and do not hide the next value. A simpler version uses a subquery with MAX of the salaries below the overall maximum.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("""
CREATE TABLE emp (name TEXT, salary INT);
INSERT INTO emp VALUES ('Asha',90000),('Ravi',120000),('Meena',120000),('Kiran',70000);
""")

query = """
SELECT DISTINCT salary FROM (
    SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS r FROM emp
) WHERE r = 2
"""

print(con.execute(query).fetchall())
print(con.execute("SELECT MAX(salary) FROM emp WHERE salary < (SELECT MAX(salary) FROM emp)").fetchall())

[(90000,)]
[(90000,)]

Q13. How do you find and remove duplicate rows?

Group by the columns that define a duplicate and keep only groups with a count above one to find them. To remove them, keep one row per group, for example the row with the smallest row id, and delete the rest. Always run the select version first so you see what will be deleted.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("""
CREATE TABLE leads (email TEXT, city TEXT);
INSERT INTO leads VALUES ('a@x.com','Pune'),('b@x.com','Bangalore'),('a@x.com','Pune'),('a@x.com','Pune');
""")

print(con.execute("SELECT email, COUNT(*) FROM leads GROUP BY email HAVING COUNT(*) > 1").fetchall())

con.execute("DELETE FROM leads WHERE rowid NOT IN (SELECT MIN(rowid) FROM leads GROUP BY email)")
print(con.execute("SELECT * FROM leads").fetchall())

[('a@x.com', 3)]
[('a@x.com', 'Pune'), ('b@x.com', 'Bangalore')]

Q14. What are CTEs and subqueries, and how do you calculate month over month growth?

A subquery is a query inside another query, and a common table expression, or CTE, names a subquery with WITH so it reads top to bottom. Use a CTE to build monthly totals, then use the LAG window function to bring in the previous month and calculate the percentage change.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("""
CREATE TABLE sales (month TEXT, revenue INT);
INSERT INTO sales VALUES ('2026-01',100000),('2026-02',120000),('2026-03',90000);
""")

query = """
WITH monthly AS (
    SELECT month, SUM(revenue) AS revenue FROM sales GROUP BY month
)
SELECT month, revenue,
       ROUND(100.0 * (revenue - LAG(revenue) OVER (ORDER BY month))
             / LAG(revenue) OVER (ORDER BY month), 1) AS growth_pct
FROM monthly
"""

for row in con.execute(query):
    print(row)

('2026-01', 100000, None)
('2026-02', 120000, 20.0)
('2026-03', 90000, -25.0)

Q15. How does SQL handle NULL values?

NULL means unknown, so it is not equal to anything, including another NULL. Use IS NULL and IS NOT NULL to test for it. COUNT of a column ignores NULLs, while COUNT of star counts every row. Use COALESCE to replace NULL with a default value in a result.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("""
CREATE TABLE t (name TEXT, phone TEXT);
INSERT INTO t VALUES ('Asha','98450'),('Ravi',NULL),('Meena',NULL);
""")

print(con.execute("SELECT COUNT(*), COUNT(phone) FROM t").fetchall())
print(con.execute("SELECT name, COALESCE(phone, 'not given') FROM t").fetchall())
print(con.execute("SELECT COUNT(*) FROM t WHERE phone = NULL").fetchall())

[(3, 1)]
[('Asha', '98450'), ('Ravi', 'not given'), ('Meena', 'not given')]
[(0,)]

The last query returns 0 because a comparison with NULL is never true. The correct test is IS NULL.

Q16. What is the difference between UNION and UNION ALL?

UNION combines the results of two queries and removes duplicate rows, which needs extra work to sort or hash the rows. UNION ALL combines them and keeps every row, so it is faster. Use UNION ALL unless you specifically need duplicates removed. Both need the same number of columns with compatible types.

import sqlite3

con = sqlite3.connect(":memory:")

print(con.execute("SELECT 1 UNION SELECT 1 UNION SELECT 2").fetchall())
print(con.execute("SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 2").fetchall())

[(1,), (2,)]
[(1,), (1,), (2,)]

Q17. What is an index, and how does it speed up a query?

An index is a separate sorted structure, usually a B tree, that lets the database find rows without scanning the whole table. It speeds up filters, joins and sorts on the indexed columns, but it takes storage and slows down inserts and updates. Index the columns you filter and join on most often.

import sqlite3

con = sqlite3.connect(":memory:")
con.executescript("CREATE TABLE emp (id INT, dept TEXT, salary INT);")

plan = "EXPLAIN QUERY PLAN SELECT * FROM emp WHERE dept = 'Data'"
print("before:", con.execute(plan).fetchall()[0][3])

con.execute("CREATE INDEX idx_dept ON emp(dept)")
print("after: ", con.execute(plan).fetchall()[0][3])

before: SCAN emp
after:  SEARCH emp USING INDEX idx_dept (dept=?)

Python and pandas for Data Science (Freshers and Intermediate)

These questions focus on the pandas work that fills a data scientist day. For core Python topics such as decorators, generators and the GIL, see the Python interview questions page.

Q18. How do you clean duplicates and wrong data types in pandas?

Use drop_duplicates to remove repeated rows, optionally on a subset of columns, and astype or the to_datetime and to_numeric functions to fix types. Set errors to coerce so that bad values become missing instead of stopping the code, then inspect those missing values on purpose.

import pandas as pd

df = pd.DataFrame({
    "id": [1, 2, 2, 3],
    "amount": ["500", "700", "700", "n/a"],
    "joined": ["2026-01-05", "2026-02-10", "2026-02-10", "2026-03-15"],
})

df = df.drop_duplicates()
df["amount"] = pd.to_numeric(df["amount"], errors="coerce")
df["joined"] = pd.to_datetime(df["joined"])

print(df)
print(df.dtypes.to_string())

   id  amount     joined
0   1   500.0 2026-01-05
1   2   700.0 2026-02-10
3   3     NaN 2026-03-15
id                 int64
amount           float64
joined    datetime64[us]

Q19. What is the difference between groupby and pivot_table?

Both summarise data by categories. The groupby method returns a long format result with one row per group, and pivot_table arranges one category across the rows and another across the columns, like an Excel pivot. Use pivot_table when you want a cross tab for a report, and groupby when you will keep processing the result.

import pandas as pd

df = pd.DataFrame({
    "city": ["Pune", "Pune", "Bangalore", "Bangalore", "Pune"],
    "course": ["Python", "SQL", "Python", "SQL", "Python"],
    "fee": [18000, 12000, 18000, 12000, 18000],
})

print(df.groupby(["city", "course"])["fee"].sum())
print(df.pivot_table(index="city", columns="course", values="fee", aggfunc="sum"))

city       course
Bangalore  Python    18000
           SQL       12000
Pune       Python    36000
           SQL       12000
Name: fee, dtype: int64
course     Python    SQL
city                    
Bangalore   18000  12000
Pune        36000  12000

Q20. How do you calculate rolling averages and resample time series in pandas?

Set the date column as the index, then use rolling with a window size for a moving average, and resample with a frequency such as weekly or monthly to aggregate over time. Rolling averages smooth short term noise so that the trend is easier to see.

import pandas as pd

s = pd.Series([10, 12, 9, 14, 20, 18, 22],
              index=pd.date_range("2026-01-01", periods=7, freq="D"))

print(s.rolling(3).mean().round(2).to_string())
print(s.resample("W").sum().to_string())

2026-01-01      NaN
2026-01-02      NaN
2026-01-03    10.33
2026-01-04    11.67
2026-01-05    14.33
2026-01-06    17.33
2026-01-07    20.00
Freq: D
2026-01-04    45
2026-01-11    60
Freq: W-SUN

Q21. What can go wrong when you merge two tables in pandas?

The most common problem is a many to many join, where the join key repeats in both tables and the number of rows multiplies, which quietly inflates totals. Check key uniqueness before merging, use the validate argument to enforce the expected relationship, and compare row counts and totals after the merge.

import pandas as pd

a = pd.DataFrame({"id": [1, 1], "x": [10, 20]})
b = pd.DataFrame({"id": [1, 1], "y": [100, 200]})

print(len(a.merge(b, on="id")), "rows after merging two 2 row tables")

try:
    a.merge(b, on="id", validate="one_to_one")
except Exception as e:
    print(type(e).__name__)

4 rows after merging two 2 row tables
MergeError

Q22. How do you work with a file that is too large to load into memory?

Read it in chunks with the chunksize argument and aggregate each chunk, load only the columns you need with usecols, use smaller data types such as category and int32, or convert the file to a columnar format such as Parquet. For data far beyond one machine, use a distributed tool such as Spark.

import pandas as pd

pd.DataFrame({"city": ["Pune", "Bangalore"] * 5000, "fee": range(10000)}).to_csv("big.csv", index=False)

total = 0
for chunk in pd.read_csv("big.csv", usecols=["fee"], chunksize=2500):
    total += chunk["fee"].sum()

print(total)

49995000

Statistics Essentials for Data Science (Intermediate)

These are the statistics ideas that data science interviews return to most often. Each answer is short on purpose. A fuller set with worked examples is on the Statistics interview questions page.

Q23. What is the difference between a population and a sample, and what is inferential statistics?

A population is the full group you want to understand, and a sample is the part of it you actually measure. Descriptive statistics summarise the sample. Inferential statistics use the sample to draw conclusions about the population, with a measure of uncertainty, through estimates, confidence intervals and hypothesis tests.

Q24. What is a p value?

A p value is the probability of seeing a result at least as extreme as the one observed, if the null hypothesis is true. A small p value is evidence against the null hypothesis. It is not the probability that the null hypothesis is true, and it does not measure the size of an effect.

import numpy as np
from scipy import stats

rng = np.random.default_rng(42)
old_page = rng.normal(50, 10, 200)
new_page = rng.normal(53, 10, 200)

t, p = stats.ttest_ind(new_page, old_page)
print("t statistic:", round(t, 2))
print("p value:", round(p, 4))

t statistic: 3.68
p value: 0.0003

A common threshold is 0.05, but it is a convention. Decide the threshold before you run the test, and report the effect size along with the p value.

Q25. What are Type I and Type II errors, and what is statistical power?

A Type I error is rejecting a true null hypothesis, a false alarm, and its probability is the significance level alpha. A Type II error is failing to reject a false null hypothesis, a missed effect, with probability beta. Power is 1 minus beta, the chance of detecting a real effect, and a common target is 80 percent.

Q26. What is the central limit theorem, and why does it matter?

The central limit theorem says that the distribution of sample means approaches a normal distribution as the sample size grows, whatever the shape of the original data, provided the variance is finite. It matters because it lets us use normal based confidence intervals and tests on averages, even when the raw data is skewed.

import numpy as np

rng = np.random.default_rng(1)
skewed = rng.exponential(scale=2.0, size=100_000)       # strongly skewed data
means = [rng.choice(skewed, 50).mean() for _ in range(2000)]

print("population mean:     ", round(skewed.mean(), 2))
print("mean of sample means:", round(np.mean(means), 2))
print("spread of the means: ", round(np.std(means), 2), "(about population std divided by square root of 50)")
print("population std / sqrt(50):", round(skewed.std() / 50 ** 0.5, 2))

population mean:      1.99
mean of sample means: 1.99
spread of the means:  0.28 (about population std divided by square root of 50)
population std / sqrt(50): 0.28

Q27. What is a confidence interval, and how do you read one?

A 95 percent confidence interval is a range calculated so that, if you repeated the study many times, about 95 percent of the intervals built this way would contain the true value. It does not mean there is a 95 percent chance the true value lies in this one interval. A narrower interval means a more precise estimate.

import numpy as np
from scipy import stats

rng = np.random.default_rng(7)
data = rng.normal(100, 15, 40)

mean = data.mean()
low, high = stats.t.interval(0.95, df=len(data) - 1, loc=mean, scale=stats.sem(data))

print(round(mean, 1), (round(float(low), 1), round(float(high), 1)))

94.1 (90.1, 98.0)

Q28. What is the normal distribution, and what does a z score tell you?

The normal distribution is a symmetric bell shaped distribution described by its mean and standard deviation. It is common in theory because of the central limit theorem, but many real variables are not normal. A z score is the number of standard deviations a value lies from the mean. It is not limited to a fixed range.

from scipy import stats

mean, std = 70, 10
score = 95
z = (score - mean) / std

print("z score:", z)
print("share of values below this score:", round(stats.norm.cdf(z), 4))
print("within 1, 2, 3 std:", [round(float(stats.norm.cdf(k) - stats.norm.cdf(-k)), 3) for k in (1, 2, 3)])

z score: 2.5
share of values below this score: 0.9938
within 1, 2, 3 std: [0.683, 0.954, 0.997]

The rule of thumb that about 99.7 percent of values lie within three standard deviations applies to normal data only. It is often used to flag outliers, but it is not a limit on the z score.

Q29. What is the difference between correlation and causation?

Correlation means two variables move together. Causation means a change in one produces a change in the other. A correlation can come from a third factor that drives both, from chance, or from reverse causation. A randomised experiment is the strongest way to show causation, because it removes other explanations.

Example to use in an interview: ice cream sales and drowning incidents both rise in summer. Heat drives both, so neither causes the other.

Q30. When do you use the mean and when the median?

Use the mean for roughly symmetric data without extreme values, since it uses every value. Use the median when the data is skewed or has outliers, because it is not pulled by a few extreme values. Income and house prices are typical cases where the median describes a typical value better.

import numpy as np

salaries = np.array([30, 32, 35, 36, 38, 40, 400])   # in thousands

print("mean:  ", salaries.mean().round(1))
print("median:", np.median(salaries))

mean:   87.3
median: 36.0

Machine Learning Essentials for Data Science (Intermediate)

Data science interviews include machine learning, but usually test judgement more than algorithm detail. These answers are brief. The Machine Learning interview questions page covers each topic in depth.

Q31. How do you start a modelling problem, and why use a baseline?

Begin with a simple baseline, such as predicting the most common class, the average, or a basic linear model. The baseline tells you whether a complex model adds real value, and it often catches data problems early. If a sophisticated model only beats the baseline by a hair, the extra complexity is rarely worth it.

from sklearn.datasets import make_classification
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

X, y = make_classification(n_samples=800, n_features=10, n_informative=4, random_state=21)

models = {
    "baseline (most frequent)": DummyClassifier(strategy="most_frequent"),
    "logistic regression": LogisticRegression(max_iter=1000),
    "random forest": RandomForestClassifier(random_state=21),
}

for name, m in models.items():
    print(f"{name}: {cross_val_score(m, X, y, cv=5).mean():.3f}")

baseline (most frequent): 0.503
logistic regression: 0.918
random forest: 0.929

Q32. How do you pick an evaluation metric for a business problem?

Ask what each kind of mistake costs. If missing a positive case is expensive, as in fraud or disease screening, focus on recall. If false alarms are expensive, focus on precision. For ranking quality use ROC AUC or the precision recall curve, and for forecasts use an error measure such as MAE in business units.

Q33. How do you know a model is overfitting, and what do you do about it?

Compare training performance with validation performance. If training is much better, the model is memorising the data. Use cross validation, simplify the model, add regularisation, reduce noisy features or get more data. Also check for data leakage, which can make a model look better than it is.

Q34. How do you explain a model prediction to a business user?

Use plain language and a concrete example. Show the few factors that pushed the prediction up or down, using coefficients for linear models or permutation importance and SHAP values for complex ones. Tell them how reliable the model is and where it should not be trusted, instead of showing technical metrics alone.

A B Testing and Experimentation (Intermediate and Experienced)

Experiment design is one of the most common areas where interviewers separate strong candidates from average ones. Product and e commerce companies in particular spend a lot of time on it.

Q35. What is an A B test, and how do you analyse one?

An A B test randomly splits users into a control group that sees the current version and a treatment group that sees the change, then compares a chosen metric between them. For a conversion rate, use a two proportion z test or a chi square test, and report the difference, its confidence interval and the p value.

import numpy as np
from scipy.stats import norm

control_n, control_conv = 5000, 400       # 8.0 percent
treat_n, treat_conv = 5000, 460           # 9.2 percent

p1, p2 = control_conv / control_n, treat_conv / treat_n
pooled = (control_conv + treat_conv) / (control_n + treat_n)
se = np.sqrt(pooled * (1 - pooled) * (1 / control_n + 1 / treat_n))
z = (p2 - p1) / se
p_value = 2 * (1 - norm.cdf(abs(z)))

print(f"lift: {p2 - p1:.3%}  z: {z:.2f}  p value: {p_value:.4f}")

lift: 1.200%  z: 2.14  p value: 0.0323

Q36. How do you decide the sample size for an A B test?

Fix the baseline rate, the smallest effect worth detecting, the significance level and the power before you start. A common approximation for a conversion rate with 5 percent significance and 80 percent power is about 16 times p times (1 minus p), divided by the squared difference, users per group. Smaller effects need far more users.

from scipy.stats import norm

def users_per_group(baseline, lift, alpha=0.05, power=0.80):
    p1, p2 = baseline, baseline + lift
    z_alpha, z_beta = norm.ppf(1 - alpha / 2), norm.ppf(power)
    variance = p1 * (1 - p1) + p2 * (1 - p2)
    return (z_alpha + z_beta) ** 2 * variance / lift ** 2

print(round(users_per_group(0.08, 0.01)))
print(round(users_per_group(0.08, 0.005)))

12205
47525

The quick rule gives a slightly lower number than this exact formula. Halving the effect you want to detect roughly quadruples the number of users you need. That is why tiny improvements can take weeks to confirm.

Q37. What is sample ratio mismatch?

Sample ratio mismatch means the number of users in each group differs from the split you planned, for example 50 to 50, by more than chance allows. It signals a bug in assignment or logging, and the results are not trustworthy until it is fixed. Check it with a chi square test on the group counts.

from scipy.stats import chisquare

observed = [5200, 4800]                  # planned split was 50 to 50
expected = [5000, 5000]

stat, p = chisquare(observed, expected)
print("p value:", p)

p value: 6.334248366623988e-05

Q38. What is the peeking problem in A B testing?

Peeking means checking the results repeatedly and stopping as soon as the p value drops below 0.05. Each look is another chance for a false positive, so the real error rate becomes much higher than 5 percent. Decide the sample size in advance and wait for it, or use sequential testing methods designed for repeated looks.

Q39. How do you handle multiple comparisons?

Testing many metrics or segments at once raises the chance that at least one looks significant by luck. Control it by naming one primary metric in advance, and by adjusting the threshold for the others, for example with the Bonferroni correction, which divides alpha by the number of tests, or the Benjamini Hochberg method.

alpha, tests = 0.05, 20

print("chance of at least one false positive with no correction:", round(1 - (1 - alpha) ** tests, 2))
print("Bonferroni threshold per test:", alpha / tests)

chance of at least one false positive with no correction: 0.64
Bonferroni threshold per test: 0.0025

Q40. What are primary and guardrail metrics?

The primary metric is the single measure that decides whether the experiment succeeded, such as conversion rate. Guardrail metrics are measures that must not get worse, such as page load time, refund rate or unsubscribe rate. A change that lifts the primary metric but breaks a guardrail should not ship.

Q41. What can you do when you cannot run a randomised A B test?

Use a quasi experimental method. A difference in differences design compares the change over time in a treated group with the change in a similar untreated group. Matching, synthetic control and regression with careful controls are other options. All of them rely on assumptions, so state the assumptions and the limits of the conclusion.

Case Study Questions (Experienced)

Case questions are open on purpose. The interviewer wants to see how you structure a vague problem, what you ask first and how you reach a recommendation. Say your steps aloud, and state assumptions as you go.

Q42. Daily orders on a food delivery app dropped 15 percent last week. How do you investigate?

First confirm that the drop is real by checking data pipelines and tracking, then compare it with the same week in earlier periods. Break the drop down by city, platform, customer type, restaurant and time, find which segment explains most of it, and test the likely causes for that segment, such as an outage, a price change, a competitor offer or supply shortage.

• Check data first: late loads, broken events and app releases that changed tracking.
• Compare against last week, the same week last year and any holiday effect.
• Split by city, app version, new versus returning users, restaurant and hour of day.
• Look at the funnel: app opens, searches, cart, payment and delivery, to see where users drop.
• Rank the explanations by how much of the drop they explain, then propose a fix and a way to confirm it.

import pandas as pd

data = pd.DataFrame({
    "segment": ["Pune Android", "Pune iOS", "Bangalore Android", "Bangalore iOS"],
    "last_week": [4000, 2500, 5000, 3000],
    "this_week": [3950, 2480, 2880, 2970],
})

data["change"] = data["this_week"] - data["last_week"]
data["share_of_drop"] = (data["change"] / data["change"].sum()).round(2)

print(data.to_string(index=False))
print("total change:", data["change"].sum())

          segment  last_week  this_week  change  share_of_drop
     Pune Android       4000       3950     -50           0.02
         Pune iOS       2500       2480     -20           0.01
Bangalore Android       5000       2880   -2120           0.95
    Bangalore iOS       3000       2970     -30           0.01
total change: -2220

In this made up table, one segment explains most of the total decline, so that is where the investigation should go next.

What the interviewer is listening for: You check the data before the business, you segment to find where the problem is, and you finish with a testable explanation.

Q43. How would you build a churn prediction model for a subscription business?

Start by defining churn, the prediction window and the action the business will take. Build features from past behaviour such as usage, payments and support contacts, using only data available at the prediction date. Split by time, compare against a simple baseline, choose a metric that matches the cost of a retention offer, and plan how the scores will be used and monitored.

• Define churn precisely, for example no activity for 30 days, and the horizon to predict, for example the next 30 days.
• Build features as of the prediction date only, to avoid leakage.
• Split the data by time so the test period comes after the training period.
• Pick a metric and threshold from the cost of an offer and the value of a retained customer.
• Deliver a ranked list or score to the retention team, and measure whether the offers actually reduce churn.

What the interviewer is listening for: You start from the decision and the data timeline, not from the algorithm.

Q44. How would you measure the success of a new feature?

Link the feature to a business goal, choose one primary metric, add guardrail metrics, and run a randomised experiment if you can. Define the target group, the minimum change worth detecting and the test duration in advance. After the test, look at segments to see who benefits, and decide whether the gain justifies the cost of running the feature.

What the interviewer is listening for: You use an experiment, one clear primary metric and guardrails against harm.

Q45. You need to forecast demand for 500 products. How do you start?

Start with simple baselines, such as the last value, the same period last year and a moving average, and measure them on a time based holdout. Group products by pattern, since stable, seasonal and intermittent items need different methods. Add a more advanced model only if it beats the baseline by enough to matter, and report forecast error in business units.

import numpy as np

rng = np.random.default_rng(5)
weeks = np.arange(104)
demand = 200 + 30 * np.sin(2 * np.pi * weeks / 52) + rng.normal(0, 8, 104)

train, test = demand[:78], demand[78:]
naive = np.full(len(test), train[-1])                    # repeat the last value
seasonal = demand[78 - 52: 104 - 52]                     # same week last year
moving_avg = np.full(len(test), train[-4:].mean())       # average of last 4 weeks

def mae(pred): return round(float(np.abs(pred - test).mean()), 1)

print("naive:", mae(naive), "| seasonal naive:", mae(seasonal), "| moving average:", mae(moving_avg))

naive: 16.6 | seasonal naive: 7.1 | moving average: 25.5

On data with a yearly pattern, the seasonal baseline wins easily. Any complex model has to beat it to earn its place.

What the interviewer is listening for: You build and respect baselines, validate on later data, and judge a model by business error.

Project and Behavioural Questions (All Levels)

Interviewers use these questions to find out how you work with people, handle imperfect data and take ownership. Use real examples from your own projects, and prepare them in advance.

Q46. Walk me through a data science project you worked on.

Tell it in five parts: the business problem, the data you had, what you did and why, the result with a number, and what you would change. Keep your own contribution clear, and be ready for questions on any choice you made. Choose a project you can explain in about three minutes.

• Problem: who needed what decision, and why it mattered.
• Data: sources, size, quality issues and how you handled them.
• Approach: baseline, the model you chose and why, and how you validated it.
• Result: the measured outcome and how the business used it.
• Reflection: one thing you would do differently.

What the interviewer is listening for: Clear ownership, honest numbers and the ability to defend each decision.

Q47. Tell me about a time you worked with messy or incomplete data.

Pick a real case and describe the specific problems, such as missing values, inconsistent categories or duplicate records. Explain how you found them, what you decided and why, and what effect your choices had on the result. Mention that you documented your assumptions so others could review them.

What the interviewer is listening for: You check data before trusting it, and you can explain trade offs.

Q48. How do you present findings to a non technical audience?

Start with the decision or answer, then give the two or three facts that support it, using simple charts and plain words. Leave out method detail unless asked, state the uncertainty honestly, and end with a clear recommendation and next step. Check afterwards that the audience understood what to do.

What the interviewer is listening for: You lead with the answer and adapt the message to the listener.

Q49. What would you do if stakeholders disagree with your analysis?

Listen first to understand what they disagree with, then check whether they know something you missed. Show your data and method openly, test their point where possible, and agree on how to resolve it, for example with an additional cut of the data or an experiment. Be willing to change your view if the evidence supports it.

What the interviewer is listening for: You stay open to being wrong and settle disagreements with evidence.

Q50. Describe a mistake you made in an analysis and what you changed afterwards.

Choose a real, modest mistake, state it plainly, say how you found it and how you told the people affected. Then explain the specific process change you made, such as a review step, a data check or a test, so it would not happen again. Interviewers value honesty and learning over a perfect record.

What the interviewer is listening for: You take responsibility without excuses and you improved a process.

Common questions about data science interviews

What do data science interviews usually include?

Most data science interviews have a screening call, a SQL or Python test, a statistics and machine learning round, a case study or take home task, and a conversation about your past projects. Product companies add experimentation questions, and larger teams add a system design or deployment round.

How should a fresher prepare for a data science interview?

Learn SQL and pandas well, because they decide most first rounds. Then revise statistics basics, one end to end machine learning project and how to explain it. Practise answering aloud. Having two projects you can defend in detail counts for more than a long list of tools.

Is SQL really necessary for data science?

Yes. Almost every data science role needs you to pull and join your own data, and many first round tests are SQL only. You should be comfortable with joins, grouping, window functions and common table expressions, and able to explain what each query does and why.

How is a data science interview different from a data analyst interview?

Analyst interviews lean toward SQL, dashboards and business metrics. Data science interviews add statistics, experiment design and machine learning, and expect you to build and validate models. The two overlap heavily at junior level, so read the job description for the exact weight.

How many projects should I have ready for an interview?

Prepare two or three projects that you can explain from the business problem to the result. Choose ones where you made real decisions about data, modelling and evaluation. Be honest about what you did yourself, and be ready to discuss what went wrong and what you would change.

A four week plan to prepare

Use this plan if you have about a month before your interview.

Practise with a trainer

If you want to practise these questions with a trainer and build projects you can talk about in interviews, you can book a free demo class for the Prwatech Data Science course. It covers Python, SQL, statistics and machine learning with hands on work.

Contact the learning team for current batch dates and fees.

Written by Mithun Ray, data engineering trainer at Prwatech. Reviewed by Avishekh Verma. Last updated October,2026.