SQL vs Python for Data Science Interviews: What to Prioritize

Most candidates preparing for data science interviews ask the same question: Should I focus more on SQL or Python?

You have limited time, and both show up in job descriptions. But the expectations for SQL interviews vs Python interviews are not symmetric, and they vary by role (data analyst vs data scientist vs analytics engineer).

This post breaks down, in practical detail, how to prioritize SQL and Python for data science skills, what interviewers actually test, and how to structure your preparation so you don’t over-optimize for the wrong thing.

---

SQL vs Python in Data Science Interviews: The Short Answer

If you just want the prioritization:

• For Data Analyst roles (and many Analytics/Data Science roles in product companies):

  • SQL: Top priority
  • Python: Nice-to-have or secondary

• For Data Scientist (ML-heavy) roles:

  • SQL: Important baseline
  • Python: Top priority

• For Analytics Engineer / Data Engineer-leaning roles:

  • SQL: Critical
  • Python: Important but often more for scripting and tooling

Across most data-focused roles, weak SQL is a red flag. Weak Python can sometimes be worked around (depending on role); weak SQL usually cannot.

Let’s unpack why, and how that should shape your preparation.

---

How SQL and Python Show Up in Real Data Work

SQL: The Language of Data Access

In most organizations:

• Data is stored in relational databases or data warehouses (e.g., PostgreSQL, Snowflake, BigQuery, Redshift).
• 80–90% of analysis tasks start with: “Write a query to get X from table Y.”

SQL is how you:

• Pull data from large tables efficiently
• Join multiple sources (e.g., users, events, transactions)
• Aggregate and slice data by dimensions (date, region, product)
• Build the base datasets that feed dashboards, models, and experiments

This is why SQL interviews are so common for data analyst interviews, analytics data scientists, and analytics engineers.

Python: The Language of Analysis and Modeling

Python dominates for:

• Exploratory data analysis (EDA) in notebooks
• Machine learning (scikit-learn, XGBoost, PyTorch, TensorFlow)
• Data cleaning and feature engineering (pandas, NumPy)
• Scripting and automation (batch jobs, ETL helpers)
• Experimentation and prototyping

Python interviews are more common when the role includes:

• Building and evaluating ML models
• Owning end-to-end modeling projects
• Working with unstructured data (text, images)
• Writing production-ish code or pipelines

---

What Interviewers Actually Test in SQL Interviews

Core SQL Skills You Must Demonstrate

For most data science and data analyst interviews, SQL expectations cluster around a few core patterns:

1. Filtering and projections

   • SELECT, WHERE, ORDER BY, LIMIT
   • Conditional logic: CASE WHEN

2. Aggregations

   • GROUP BY, HAVING
   • Aggregate functions: COUNT, SUM, AVG, MIN, MAX

3. Joins

   • INNER JOIN, LEFT JOIN
   • Understanding of join keys and row multiplication
   • Occasionally RIGHT JOIN, FULL OUTER JOIN

4. Window functions

   • ROW_NUMBER, RANK, DENSE_RANK
   • Running totals, moving averages
   • Partitioning and ordering: OVER (PARTITION BY ... ORDER BY ...)

5. Working with dates and text

   • Date truncation, extraction, and arithmetic
   • String operations: LIKE, SUBSTRING, CONCAT

6. Subqueries and CTEs

   • WITH clauses for readability
   • Correlated vs uncorrelated subqueries

These map to common analytics problems: “Find the top N users by revenue,” “Compute 7-day retention,” “Identify first purchase date per user,” etc.

Example: A Typical SQL Interview Question

Given tables:

• users(user_id, signup_date, country)
• events(user_id, event_name, event_time)

Write a query to find, for each country, the percentage of users who performed an event named 'purchase' within 7 days of signup.

A clean solution might look like:

SQL
Copy
WITH first_purchase AS (
    SELECT
        u.user_id,
        u.country,
        u.signup_date,
        MIN(e.event_time) AS first_purchase_time
    FROM users u
    LEFT JOIN events e
        ON u.user_id = e.user_id
       AND e.event_name = 'purchase'
    GROUP BY
        u.user_id,
        u.country,
        u.signup_date
),
purchases_within_7_days AS (
    SELECT
        country,
        COUNT(*) AS total_users,
        COUNT(
            CASE
                WHEN first_purchase_time IS NOT NULL
                 AND first_purchase_time <= signup_date + INTERVAL '7 day'
                THEN 1
            END
        ) AS purchasers_within_7_days
    FROM first_purchase
    GROUP BY country
)
SELECT
    country,
    purchasers_within_7_days * 1.0 / total_users AS pct_purchased_within_7_days
FROM purchases_within_7_days;

What’s being evaluated:

• Correctness of logic (7-day window, per user, per country)
• Understanding of joins and aggregations
• Ability to structure multi-step logic with CTEs
• Readability and maintainability

---

What Interviewers Actually Test in Python Interviews

Python interviews vary more by role. For data science roles, you’ll usually see some mix of:

1. Python for Data Manipulation (pandas, NumPy)

Common expectations:

• Loading data from CSV/SQL into pandas
• Filtering rows, selecting columns
• Grouping and aggregating (groupby, agg)
• Merging/joining DataFrames
• Handling missing values
• Basic reshaping (pivot, melt)

Example:

PYTHON
Copy
import pandas as pd

# users: user_id, signup_date, country
# events: user_id, event_name, event_time

# Filter to purchases and compute first purchase per user
purchases = events[events["event_name"] == "purchase"].copy()
first_purchase = (
    purchases
    .groupby("user_id", as_index=False)["event_time"]
    .min()
    .rename(columns={"event_time": "first_purchase_time"})
)

users_with_purchase = users.merge(first_purchase, on="user_id", how="left")

# Compute purchase within 7 days flag
users_with_purchase["signup_date"] = pd.to_datetime(users_with_purchase["signup_date"])
users_with_purchase["first_purchase_time"] = pd.to_datetime(
    users_with_purchase["first_purchase_time"]
)

within_7_days = (
    (users_with_purchase["first_purchase_time"].notna()) &
    (users_with_purchase["first_purchase_time"] <=
     users_with_purchase["signup_date"] + pd.Timedelta(days=7))
)

users_with_purchase["purchased_within_7_days"] = within_7_days

# Aggregate by country
result = (
    users_with_purchase
    .groupby("country", as_index=False)
    .agg(
        total_users=("user_id", "count"),
        purchasers_within_7_days=("purchased_within_7_days", "sum"),
    )
)

result["pct_purchased_within_7_days"] = (
    result["purchasers_within_7_days"] / result["total_users"]
)

Interviewers look for:

• Fluent use of pandas idioms
• Avoiding unnecessary loops
• Clear, readable code

2. Python for ML and Modeling

For ML-focused data scientist roles:

• Train/test split, cross-validation
• Basic models: logistic regression, random forest, gradient boosting
• Feature preprocessing (scaling, encoding)
• Model evaluation metrics (AUC, precision/recall, RMSE)

Example snippet:

PYTHON
Copy
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score

# X: features, y: binary target
numeric_features = ["age", "tenure_days"]
categorical_features = ["country", "device"]

numeric_transformer = "passthrough"
categorical_transformer = OneHotEncoder(handle_unknown="ignore")

preprocessor = ColumnTransformer(
    transformers=[
        ("num", numeric_transformer, numeric_features),
        ("cat", categorical_transformer, categorical_features),
    ]
)

clf = Pipeline(
    steps=[
        ("preprocessor", preprocessor),
        ("model", LogisticRegression(max_iter=1000)),
    ]
)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

clf.fit(X_train, y_train)
y_pred_proba = clf.predict_proba(X_test)[:, 1]
auc = roc_auc_score(y_test, y_pred_proba)

The bar here varies widely; some interviews stay at “can you explain how you’d approach this,” others require full implementation.

3. Core Python and Algorithmic Thinking

Some companies (especially tech/product companies) also test:

• Basic data structures: lists, dicts, sets, tuples
• Control flow, functions, list comprehensions
• Simple algorithms: parsing, counting, grouping
• Time/space complexity awareness

Example question:

Given a list of events with user_id and timestamp, find the number of unique active users per day.

You might write:

PYTHON
Copy
from collections import defaultdict
from datetime import datetime

def active_users_per_day(events):
    # events: list of dicts with keys "user_id", "timestamp" (ISO string)
    users_by_day = defaultdict(set)
    
    for e in events:
        dt = datetime.fromisoformat(e["timestamp"])
        day = dt.date()
        users_by_day[day].add(e["user_id"])
    
    return {day: len(users) for day, users in users_by_day.items()}

Time complexity: O(n), where n is number of events.

---

Role-by-Role: How to Prioritize SQL vs Python

Data Analyst Interview

Typical expectations:

• SQL: Strong to expert
• Python: Sometimes optional, sometimes light (mostly pandas)

Prioritization:

1. Master SQL first.
   • You should be comfortable solving multi-CTE problems with joins and window functions under time pressure.
2. Then add enough Python to be productive.
   • Basic pandas for cleaning and aggregations
   • Simple visualizations (matplotlib/seaborn) if relevant

If you’re short on time and the JD doesn’t explicitly require Python, you will get more ROI from SQL.

Product / Analytics Data Scientist Interview

Typical expectations:

• SQL: Strong
• Python: Moderate to strong (EDA, stats, light ML)

Prioritization:

1. SQL and Python are both important, but SQL is non-negotiable.
2. Focus Python on:
   • pandas, NumPy
   • Basic modeling and evaluation
   • Writing clear, modular code

For many such roles, interviews include at least one SQL round and one Python/analysis round. Weak performance in SQL will usually block you.

ML / Research Data Scientist Interview

Typical expectations:

• Python: Strong to expert
• SQL: Solid baseline

Prioritization:

1. Python first, but don’t neglect SQL.
2. You should:
   • Comfortably write non-trivial SQL queries
   • Be very strong in Python, including ML libraries and possibly deep learning

Even in ML-heavy roles, you often need to pull your own training data, debug data issues, and validate experiments — all of which use SQL.

Analytics Engineer / Data Engineer-Leaning Roles

Typical expectations:

• SQL: Expert (including complex transformations)
• Python: Moderate (ETL, scripting)

Prioritization:

1. SQL is your primary language.
2. Python is used to:
   • Orchestrate pipelines
   • Integrate with APIs
   • Write tests and validation scripts

---

How to Decide Your Personal Priority

Ask yourself:

1. What roles are you targeting?

   • Analyst / Analytics DS → SQL-heavy
   • ML DS / Research → Python-heavy but SQL still required

2. What do current job descriptions say?

   • If “SQL” appears multiple times and “Python” appears once or not at all, bias towards SQL.
   • If “Python” appears with libraries like scikit-learn, PyTorch, etc., you need deeper Python.

3. What is your current strength?

   • Strong Python, weak SQL → Fix SQL now; it’s a fast, high-ROI investment.
   • Strong SQL, weak Python → Decide if you’re okay targeting more analytics/BI roles; otherwise, invest in Python.

---

SQL vs Python: Comparison Table for Interview Prep

---

Common Mistakes in SQL Interviews (and How to Avoid Them)

1. Ignoring Edge Cases with Joins

Mistake: Using INNER JOIN when you really want all users, including those without events.

Fix: Default to LEFT JOIN when the primary table is “all entities” (e.g., all users) and the secondary table is “events/attributes” that may be missing.

2. Writing One Giant Query Without Structure

Mistake: Cramming all logic into a single SELECT with nested subqueries.

Fix: Use CTEs (WITH clauses) to break logic into steps:

SQL
Copy
WITH base AS ( ... ),
aggregated AS ( ... )
SELECT ... FROM aggregated;

This improves readability and reduces logical errors.

3. Misusing Window Functions

Mistake: Forgetting PARTITION BY or ORDER BY, leading to incorrect rankings or running totals.

Fix: Always articulate the intent verbally first:

• “I need to rank events per user, ordered by time” → PARTITION BY user_id ORDER BY event_time
• “I need a running total of purchases per day” → PARTITION BY date ORDER BY date (or global, depending on requirement)

4. Not Checking for Duplicates

Mistake: Assuming join keys are unique and accidentally multiplying rows.

Fix:

• Ask clarifying questions: “Is user_id unique in this table?”
• Use COUNT(DISTINCT ...) if uniqueness is not guaranteed.
• Consider pre-aggregating before joins if needed.

---

Common Mistakes in Python Interviews (and How to Avoid Them)

1. Overusing Loops Instead of Vectorization

Mistake: Iterating row-by-row over a pandas DataFrame.

Fix: Use vectorized operations:

PYTHON
Copy
# Bad
for i, row in df.iterrows():
    df.loc[i, "is_active"] = row["last_seen"] > cutoff

# Good
df["is_active"] = df["last_seen"] > cutoff

This is both faster and more idiomatic.

2. Writing Code Without Considering Complexity

Mistake: Using nested loops on large lists or DataFrames.

Fix:

• Use dictionaries/sets for O(1) lookups.
• Use groupby and merge instead of manual grouping logic.
• Be prepared to discuss time complexity at a high level.

3. Ignoring Code Readability

Mistake: Writing dense, cryptic one-liners under time pressure.

Fix:

• Use descriptive variable names.
• Break logic into small functions.
• Prefer clarity over cleverness, especially in interviews.

4. Treating Python as “Just Scripting”

Mistake: Not using functions, not handling errors, not organizing code.

Fix:

• Wrap logic into functions with clear inputs/outputs.
• Use docstrings or comments to explain non-trivial logic.
• Show that you can write code that could be maintained.

---

How to Practice Effectively for SQL Interviews

1. Practice Realistic Query Problems

Focus on problems that mimic real analytics work:

• Retention and cohort analysis
• Funnel conversion rates
• Top-N by metric (e.g., revenue, sessions)
• Sessionization and user activity streaks

You can simulate the pressure and feedback loop with tools like AI-driven mock interviews (for example, Thita’s /ai-interview tooling can generate SQL-style questions with real-time hints).

2. Develop a Reusable Querying Framework

For any problem, think in steps:

1. Clarify the question and expected output columns.
2. Identify base tables and join keys.
3. Define filtering conditions (time ranges, event types).
4. Aggregate or window as needed.
5. Format final output (sorting, limiting, rounding).

This mental checklist reduces errors and speeds you up.

3. Learn the Dialect You’ll Use Most

Most interview platforms use:

• PostgreSQL-like syntax
• Or BigQuery/Snowflake for analytics roles

Know the date/time functions and quirks of at least one major dialect.

---

How to Practice Effectively for Python Interviews

1. Anchor on pandas + NumPy for Data Roles

Build fluency in:

• df.groupby([...]).agg(...)
• df.merge(...)
• df.pivot_table(...)
• Handling missing data: isna(), fillna(), dropna()

Practice by re-implementing SQL queries in pandas and vice versa.

2. Add ML Fundamentals if Relevant

If you’re targeting ML/DS roles:

• Implement a full pipeline:

  1. Load data
  2. Clean and preprocess
  3. Train a model
  4. Evaluate metrics
  5. Interpret results

• Be prepared to explain:

  • Why you chose a certain model
  • How you handle overfitting
  • What metrics you use and why

For a comprehensive overview of machine learning interview expectations, see Machine Learning Interviews: Theory vs Practical Expectations.

3. Brush Up on Core Python

Even if the role is data-focused, knowing:

• List/dict/set operations
• Comprehensions
• Basic OOP (classes) if needed
• Error handling (try/except)

will make you more comfortable in any Python-based interview.

---

Combining SQL and Python in a Realistic Workflow

In actual data science work, you often:

1. Use SQL to pull a reasonably sized dataset from a warehouse.
2. Use Python (pandas) to:
   • Clean and transform
   • Explore distributions and correlations
   • Build and evaluate models

Interviewers increasingly like to see that you understand this end-to-end flow, not just isolated skills. For a structured approach to preparing for data science roles, check out the Data Science Interview Preparation: Complete Roadmap.

---

Best Practices and Actionable Tips

1. Align Your Prep with Target Roles

• Make a short list of 5–10 companies you’d like to work at.
• Read 10–20 job descriptions.
• Tally mentions of “SQL”, “Python”, “pandas”, “machine learning”.
• Let that data drive your priority.

2. Build a Small Portfolio That Uses Both

For example:

• A short project where you:
  • Use SQL to query public data (e.g., BigQuery public datasets).
  • Export a sample into Python.
  • Perform EDA and build a simple model.
• This gives you concrete examples to discuss in interviews.

See End-to-End Data Science Projects That Impress Interviewers for ideas on portfolio projects that can boost your interview chances.

3. Practice Under Constraints

For both SQL and Python:

• Time-box practice sessions (e.g., 30–45 minutes per problem).
• Simulate “whiteboard-style” solving:
  • Talk through your thought process.
  • Explain trade-offs and assumptions.

4. Learn Patterns, Not Just Individual Problems

Many SQL and Python interview questions reuse the same core patterns:

• SQL:
  • “Top N per group”
  • “First/last event per user”
  • “Rolling metrics over time”
• Python:
  • “Group and aggregate by key”
  • “Map and transform columns”
  • “Count unique entities per bucket”

Recognizing patterns helps you generalize quickly. If you’re already using a pattern-based system for DSA, you can bring that mindset to your data prep too; resources like Thita’s /dsa-patterns-sheet can help you think in patterns even outside pure algorithms.

---

Key Takeaways: What to Prioritize, Concretely

1. SQL is non-negotiable for almost all data roles.

   • For data analyst interviews and analytics-focused data science roles, prioritize SQL first.
   • Aim to be able to solve multi-step queries with joins and window functions confidently.

2. Python importance depends heavily on the role.

   • For ML-heavy data scientist roles, Python is as important (or more) than SQL.
   • For analyst roles, you can often get by with strong SQL and moderate Python.

3. Don’t treat SQL and Python as competing; they’re complementary.

   • SQL: Get the right data efficiently.
   • Python: Analyze, model, and automate.

4. Align your preparation with real job descriptions, not generic advice.

   • Count mentions of SQL vs Python and specific libraries.
   • Adjust your prep time allocation accordingly.

5. Practice in realistic, end-to-end scenarios.

   • Query with SQL → analyze/model with Python → explain insights.
   • This is how you’ll work on the job and how the strongest candidates differentiate themselves.

If you structure your preparation around the actual expectations for SQL interviews and Python interviews by role, you’ll avoid over-investing in the wrong area and walk into your data science or data analyst interview with the right skills at the right depth.