Data Analyst

The WHERE clause is used to filter records before any groupings are made (it acts on individual rows). The HAVING clause is used to filter values after the GROUP BY clause has been applied, typically to filter based on aggregate functions (like SUM, AVG, COUNT). Example: WHERE Sales > 100 filters rows; HAVING SUM(Sales) > 1000 filters groups.

INNER JOIN returns records with matching values in both tables. LEFT JOIN returns all records from the left table and matched records from the right (NULLs if no match). RIGHT JOIN is the opposite of LEFT. FULL OUTER JOIN returns all records when there is a match in either left or right table records.

Window functions perform calculations across a set of table rows that are related to the current row. Unlike aggregate functions, they do not cause rows to become grouped into a single output row. Common uses include calculating running totals, moving averages, or ranking items (RANK, ROW_NUMBER) within specific partitions using the OVER() clause.

You can find duplicates by using the GROUP BY clause on the columns you suspect are duplicated and then using the HAVING clause to find counts greater than 1. Example: SELECT email, COUNT(*) FROM users GROUP BY email HAVING COUNT(*) > 1;

DELETE is a DML command used to remove specific rows (can be rolled back). TRUNCATE is a DDL command that removes all rows from a table but keeps the structure (faster, cannot be rolled back easily). DROP removes the entire table structure and data from the database permanently.

A Primary Key uniquely identifies each record in a table and cannot contain NULL values. A Foreign Key is a field in one table that refers to the Primary Key in another table, establishing a link between the two and ensuring referential integrity.

Indexes are special lookup tables that the database search engine can use to speed up data retrieval. They are important because they significantly reduce the amount of data the server needs to scan to find a specific result, though they can slow down data insertion (INSERT/UPDATE) operations.

Optimization techniques include: 1) Using EXPLAIN to see the execution plan, 2) Adding indexes on frequently searched columns, 3) Avoiding SELECT *, 4) Reducing subqueries by using JOINs, 5) Filtering data as early as possible using WHERE, and 6) Avoiding wildcards at the beginning of strings (e.g., LIKE '%abc').

A subquery is a query nested inside another query (SELECT, INSERT, UPDATE, or DELETE). You use them when you need to perform a calculation or filter based on a result that isn't known until runtime, such as finding all employees whose salary is above the average salary.

GROUP BY is used to arrange identical data into groups. It is most often used with aggregate functions like COUNT, MAX, MIN, SUM, and AVG. Use cases include finding total sales per region, counting students per class, or finding the average temperature per month.

Both combine the results of two SELECT statements. UNION removes duplicate rows from the combined result set, while UNION ALL includes all duplicates. UNION ALL is generally faster because it doesn't have the overhead of checking for duplicates.

NULL values are handled using operators like IS NULL or IS NOT NULL. Functions like COALESCE(val, replacement) can be used to return a default value if a column is NULL, and IFNULL() or NVL() perform similar tasks depending on the SQL dialect.

A CTE is a temporary result set defined within the execution scope of a single SELECT, INSERT, UPDATE, or DELETE. Defined using the 'WITH' keyword, they make complex queries more readable and maintainable compared to nested subqueries.

ROW_NUMBER assigns a unique sequential integer to rows. RANK assigns the same rank to tied values, but skips the next rank (1, 2, 2, 4). DENSE_RANK assigns the same rank to ties but does not skip the next number (1, 2, 2, 3).

Method 1: Using subquery: SELECT MAX(salary) FROM employees WHERE salary < (SELECT MAX(salary) FROM employees). Method 2: Using OFFSET (Postgres/MySQL): SELECT salary FROM employees ORDER BY salary DESC LIMIT 1 OFFSET 1.

Normalization is the process of organizing data to reduce redundancy and improve data integrity (splitting tables). Denormalization is the process of combining tables to improve read performance at the cost of some redundancy, common in data warehousing (OLAP systems).

Candidate Key: A column or set of columns that can uniquely identify a row. Composite Key: A primary key composed of two or more columns. Surrogate Key: An artificial key (like an auto-incrementing ID) used as a primary key when no natural primary key is available.

A self-join is a regular join where a table is joined with itself. It is useful for querying hierarchical data, such as an Employee table where a column 'ManagerID' refers back to the 'EmployeeID' in the same table.

Running totals are calculated using window functions with the SUM aggregate. Format: SUM(amount) OVER (ORDER BY date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW).

A non-correlated subquery can be executed independently of the outer query. A correlated subquery uses values from the outer query for its results and must be executed repeatedly for every row processed by the outer query, which can be slower.

CASE acts like an if-else statement. SELECT name, CASE WHEN score >= 90 THEN 'A' WHEN score >= 80 THEN 'B' ELSE 'C' END as Grade FROM students; It is powerful for creating categories or buckets in your analysis.

Aggregate functions perform a calculation on a set of values and return a single value. Common ones include COUNT() (number of rows), SUM() (total), AVG() (average), MIN() (smallest), and MAX() (largest).

PARTITION BY divides the result set into partitions to which the window function is applied. For example, to find the highest-paid employee per department: RANK() OVER (PARTITION BY department_id ORDER BY salary DESC).

A clustered index determines the physical order of data in the table (one per table, usually the PK). A non-clustered index is a separate structure that points to the data (multiple per table), like an index in the back of a book.

General formula: SELECT salary FROM employees e1 WHERE N-1 = (SELECT COUNT(DISTINCT salary) FROM employees e2 WHERE e2.salary > e1.salary). Or using OFFSET N-1 LIMIT 1 in supported databases.

Stored procedures are prepared SQL code that you can save so the code can be reused over and over. Use them for repetitive tasks, complex transactions, or to improve security by limiting direct table access.

COALESCE returns the first non-null value in a list. It is vital for data analysis to replace NULLs with 0 or 'Unknown' to ensure calculations (like sums) don't break or return unexpected NULLs.

Using functions like DATEDIFF (difference between dates), DATE_ADD/DATEADD (adding intervals), or EXTRACT/DATE_PART to get the year, month, or day from a timestamp.

CHAR is a fixed-length character type (padded with spaces if the string is shorter than the limit). VARCHAR is a variable-length character type. Use CHAR for data with consistent length (like Country Codes) and VARCHAR for names or addresses.

Pivoting turns row data into columns (using CASE statements or the PIVOT function). Unpivoting turns columns into rows. This is common when transforming wide data from Excel into long format for database storage.

Common libraries include Pandas (data manipulation), NumPy (numerical computing), Matplotlib and Seaborn (visualization), Scikit-learn (machine learning), and SciPy (statistical tests).

Lists are mutable (can be changed) and defined with []. Tuples are immutable (cannot be changed after creation) and defined with (). Tuples are generally faster and safer for data that shouldn't change, like coordinates.

Pandas is a Python library providing high-performance, easy-to-use data structures like DataFrames. It is essential for cleaning, transforming, and analyzing tabular data, offering built-in methods for handling missing data and merging datasets.

Techniques include: 1) df.isnull() to detect, 2) df.dropna() to remove rows/columns, 3) df.fillna(value) to impute with mean/median, and 4) Interpolation for time-series data.

loc is label-based (you use the names of columns/rows). iloc is integer-index based (you use the numerical position 0, 1, 2...).

List comprehension is a concise way to create lists. Example: [x**2 for x in range(10) if x%2==0] creates a list of squares for even numbers. It's more readable and often faster than traditional for-loops.

Lambda functions are small, anonymous, one-line functions defined with the 'lambda' keyword. They are often used with functions like map(), filter(), and apply() in pandas for quick transformations.

Using pd.merge(df1, df2, on='key', how='inner/left/right/outer'). It works similarly to SQL joins. You can also use df1.join(df2) for index-on-index joining.

NumPy is for numerical operations on large, multi-dimensional arrays and matrices. Use it for complex mathematical operations, linear algebra, and when you need performance that standard Python lists can't provide.

Using pd.read_csv('file.csv') and pd.read_excel('file.xlsx'). These functions convert the external files directly into pandas DataFrames.

map() works on a Series element-wise. apply() works on a Series or DataFrame (row/column-wise). applymap() is used for element-wise operations on an entire DataFrame.

Using df.groupby('column').aggregate_function(). For example: df.groupby('Category')['Sales'].sum() gives the total sales for each unique category.

Dictionaries are unordered collections of key-value pairs. Use them when you need to store data that you can look up quickly by a unique key, such as mapping IDs to names.

Broadcasting allows NumPy to perform arithmetic operations on arrays of different shapes, effectively 'stretching' the smaller array to match the shape of the larger one without making extra copies of data.

Convert strings to datetime using pd.to_datetime(). Once converted, you can extract properties like .dt.year, .dt.month, or calculate time deltas (differences between dates).

A shallow copy creates a new object but fills it with references to the original nested objects. A deep copy creates a new object and recursively adds copies of the nested objects, so changes in one don't affect the other.

Using df.sort_values(by='column_name', ascending=True/False) to sort by data, or df.sort_index() to sort by the index labels.

Generators are functions that return an iterator using the 'yield' keyword. They generate values on the fly and are highly memory-efficient when dealing with large datasets as they don't store the entire list in memory.

Using boolean indexing: df[df['age'] > 25]. You can combine multiple conditions using & (and) or | (or), e.g., df[(df['age'] > 25) & (df['city'] == 'NY')].

Matplotlib is the foundational plotting library for Python. Seaborn is built on top of Matplotlib and provides a high-level interface for drawing attractive and informative statistical graphics with less code.

Using the 'def' keyword followed by the function name and parameters. Example: def my_func(x): return x * 2. This is crucial for applying complex logic to pandas columns.

A Series is a one-dimensional labeled array (like a single column). A DataFrame is a two-dimensional labeled data structure (like a table with rows and columns).

Using df['col'].astype('category') to save memory, or performing One-Hot Encoding using pd.get_dummies() to convert categories into numerical columns for machine learning models.

Using df.pivot_table(), which behaves like Excel pivot tables. It allows you to summarize data by grouping by one or more keys and applying an aggregation (mean, sum) to numeric values.

Optimization includes: 1) Vectorized operations instead of loops, 2) Using appropriate data types (int32 vs int64), 3) Chunking large files using the 'chunksize' parameter in read_csv, and 4) using Dask or Polars for extremely large data.

Mean is the average. Median is the middle value in a sorted list (resistant to outliers). Mode is the most frequent value.

Variance is the average of squared differences from the mean. Standard Deviation is the square root of variance, representing how spread out the numbers are in the same units as the data.

A p-value is the probability that the observed results occurred by chance under the null hypothesis. A p-value < 0.05 typically suggests 'statistical significance,' meaning we reject the null hypothesis.

Correlation means two variables move together. Causation means one variable *causes* the other to change. Example: Ice cream sales and drowning rates are correlated (both rise in summer), but ice cream doesn't cause drowning.

Type I (False Positive): Rejecting a true null hypothesis. Type II (False Negative): Failing to reject a false null hypothesis.

A range of values that is likely to contain a population parameter with a certain level of confidence (e.g., 95%). It shows the uncertainty associated with an estimate.

The CLT states that the sampling distribution of the sample mean will be normally distributed, regardless of the population's distribution, provided the sample size is sufficiently large (usually n > 30).

A formal procedure for investigating our ideas about the world using statistics. It involves setting a Null (H0) and Alternative (H1) hypothesis, choosing a significance level (alpha), and using a test statistic to decide whether to reject H0.

The population is the entire group you want to draw conclusions about. A sample is the specific group that you will collect data from; the size of the sample is always less than the total size of the population.

Outliers are data points significantly different from others. Detect them using: 1) Z-scores (> 3), 2) IQR Method (points outside [Q1 - 1.5*IQR, Q3 + 1.5*IQR]), or 3) Box plots.

A bell-shaped curve where most observations cluster around the central peak and probabilities for values further away from the mean taper off equally in both directions. Mean = Median = Mode.

It is a result that is unlikely to have occurred randomly. It suggests that an effect or relationship exists in the population being studied.

Parametric tests assume the data follows a specific distribution (usually normal) and have more power. Non-parametric tests (like Mann-Whitney U) do not assume a distribution and are used for skewed data or small samples.

A set of statistical processes for estimating the relationships between a dependent variable (target) and one or more independent variables (predictors).

Descriptive statistics summarize the characteristics of a dataset (mean, charts). Inferential statistics use a random sample of data taken from a population to describe and make predictions about the population.

Linear regression predicts a continuous numerical value (e.g., house price). Logistic regression predicts the probability of a categorical outcome (e.g., Yes/No, Spam/Not Spam).

R-squared measures the proportion of variance in the dependent variable explained by the model. Adjusted R-squared adjusts for the number of predictors; it penalizes adding variables that don't improve the model.

A one-tailed test looks for an effect in one specific direction (e.g., is A *greater* than B?). A two-tailed test looks for an effect in either direction (is A *different* from B?).

A mathematical function that describes the likelihood of obtaining the possible values that a random variable can take.

A mathematical formula used to determine the conditional probability of an event based on prior knowledge of conditions that might be related to the event. P(A|B) = [P(B|A) * P(A)] / P(B).

Sampling is selecting a subset of individuals from a population. Methods include: 1) Random Sampling, 2) Stratified Sampling (equal rep from groups), 3) Cluster Sampling, and 4) Systematic Sampling.

It states that as a sample size grows, its mean gets closer to the average of the whole population.

Skewness measures the asymmetry of the distribution (left or right tail). Kurtosis measures the 'tailedness' or 'peakedness' (how many outliers exist in the distribution).

Occurs when independent variables in a regression model are highly correlated. It makes the model unstable. Detect it using Variance Inflation Factor (VIF) or a correlation matrix.

Covariance indicates the direction of the linear relationship between variables. Correlation is a standardized version of covariance that indicates both the direction and the strength (ranges from -1 to 1).

A z-score indicates how many standard deviations a data point is from the mean. A z-score of 0 is at the mean; a z-score of 3 is very high.

A t-test is used to compare the means of two groups. Use it when the sample size is small (n < 30) and the population standard deviation is unknown.

A statistical test used to determine if there is a significant association between two categorical variables (e.g., does gender influence product preference?).

Analysis of Variance (ANOVA) is used to compare the means of three or more groups to see if at least one group mean is significantly different from the others.

The analysis of data points collected or recorded at specific time intervals. It involves identifying trends, seasonality, and cyclic patterns to forecast future values.

Common tools include BI platforms (Tableau, Power BI, Looker) and coding libraries (Matplotlib, Seaborn, Plotly). Choice depends on the audience: BI for stakeholders, libraries for technical EDA.

Bar charts are best for comparing categorical groups (e.g., sales by region). Line charts are best for showing trends over a continuous period of time (e.g., stock price over 12 months).

Tableau is a powerful data visualization tool used in the BI industry. It allows users to create interactive dashboards, connect to various data sources, and perform complex calculations without heavy coding.

It translates complex data into a visual context, making it easier for the human brain to identify patterns, trends, and outliers that might go unnoticed in text-based data.

A good dashboard is: 1) Purpose-driven (answers a specific question), 2) Simple (no clutter), 3) Interactive (filters/drill-downs), and 4) Accurate (verified data).

Based on the data relationship: Comparison (Bar), Composition (Pie/Treemap), Distribution (Histogram/Boxplot), or Relationship (Scatter plot).

A business analytics service by Microsoft. It provides interactive visualizations and business intelligence capabilities with an interface simple enough for end users to create their own reports.

1) Start with zero-baselines for bar charts, 2) Use color meaningfully, 3) Label axes clearly, 4) Keep it accessible, and 5) Choose the chart that requires the least mental effort to understand.

Using Matplotlib for basic plots, Seaborn for statistical plots, and Plotly or Bokeh for interactive web-based charts.

A histogram shows the distribution of continuous numerical data (no gaps between bars). A bar chart compares discrete categorical data (gaps between bars).

To show the relationship (correlation) between two numerical variables. It helps identify if one variable affects the other and highlights clusters or outliers.

A graphical representation where individual values are represented as colors. Use it to show correlation matrices or to identify 'hot spots' in large datasets (e.g., website clicks).

1) Group smaller categories into an 'Other' bucket, 2) Use a horizontal bar chart if names are long, 3) Use interactive filters, or 4) Break it into multiple smaller charts (Small Multiples).

A box plot (Whisker plot) shows the distribution of data based on a five-number summary: minimum, first quartile (Q1), median, third quartile (Q3), and maximum. It is excellent for spotting outliers.

1) Use colorblind-friendly palettes, 2) Use large, clear fonts, 3) Provide descriptive titles and tooltips, and 4) Use text annotations to highlight key insights directly on the chart.

VLOOKUP/XLOOKUP, INDEX-MATCH, Pivot Tables, SUMIFS, COUNTIFS, IFERROR, and text functions like LEFT, RIGHT, and CONCATENATE.

VLOOKUP searches for a value in the first column of a range and returns a value in the same row from another column. Limitations: It can only look to the right, is slow on large datasets, and breaks if you insert/delete columns.

INDEX-MATCH is more flexible than VLOOKUP. It can look to the left, is faster for large data, and doesn't break when columns are added. XLOOKUP is the modern alternative to both.

Select the data range, go to Insert > PivotTable. Then drag fields into Rows, Columns, Values, and Filters to summarize the data instantly.

Array formulas (dynamic arrays), INDIRECT (referencing ranges dynamically), OFFSET, and nesting complex IF statements with AND/OR logic.

1) Use Power Query for ETL, 2) Use Power Pivot (Data Model) to handle millions of rows, 3) Disable automatic calculations if it's lagging, and 4) Use binary file format (.xlsb).

A data transformation and preparation engine in Excel that allows you to import data from various sources and perform 'steps' to clean it (e.g., removing columns, splitting text) which can be refreshed.

A feature that allows you to apply specific formatting (colors, icons) to cells that meet certain criteria. Useful for highlighting outliers or visualizing progress (e.g., Heat maps in Excel).

Select the data > Data tab > Remove Duplicates. Or use the =UNIQUE() function in newer versions of Excel.

Relative (A1) changes when copied to other cells. Absolute ($A$1) stays fixed to that specific cell no matter where the formula is copied. Mixed ($A1 or A$1) fixes only the row or column.

Formulas that can perform multiple calculations on one or more items in an array. In modern Excel (O365), these 'spill' across multiple cells automatically.

These are used to sum or count values based on criteria. The 'S' versions (SUMIFS) allow for multiple criteria at once, which is a standard requirement for most reporting.

An Excel add-in used to perform powerful data analysis and create sophisticated data models. It can handle much larger volumes of data than standard Excel and supports DAX (Data Analysis Expressions).

By using Excel Tables (Ctrl+T) as the data source so the chart updates when new rows are added, or by using named ranges with the OFFSET or INDEX functions.

A macro is an automated sequence of actions. VBA (Visual Basic for Applications) is the programming language used to write those macros for complex automation tasks.

Data cleaning is the process of fixing or removing incorrect, corrupted, incorrectly formatted, duplicate, or incomplete data. It's important because 'Garbage In, Garbage Out'—your analysis is only as good as your data.

1) Ignore/Drop rows (if data is missing at random and small), 2) Impute with Mean/Median/Mode, 3) Use predictive models to fill values, 4) Use 'Unknown' for categorical data.

Scaling numeric data to a standard range (like 0 to 1) so that no single variable dominates others due to its scale, which is vital for many machine learning algorithms.

Detect via Boxplots or Z-scores. Handle by: 1) Deleting if they are errors, 2) Transforming (Log transform), 3) Capping (Winsorizing), or 4) Keeping them if they represent true rare events.

ETL stands for Extract, Transform, and Load. It's the process of pulling data from sources, cleaning/transforming it to fit business needs, and loading it into a data warehouse or tool.

By using string manipulation (Lowercasing, stripping whitespace) and data type conversion (pd.to_datetime) to ensure that 'USA', 'usa', and 'United States' are all treated as the same entity.

Checking the accuracy and quality of data before using it. This includes range checks (age can't be negative), format checks (emails must have @), and consistency checks.

Identify them by checking for identical primary keys or identical rows across all columns. In Python, use df.drop_duplicates(); in SQL, use DISTINCT or ROW_NUMBER().

The process of changing the format, structure, or values of data. Examples include pivoting, converting units, or creating aggregations.

It's the common industry observation that data analysts spend 80% of their time cleaning and preparing data and only 20% of their time actually analyzing it.

The process of using domain knowledge to create new features (variables) from raw data that help machine learning models perform better (e.g., extracting 'Day of Week' from a Date).

Techniques include: 1) Resampling (Oversampling the minority/Undersampling the majority), 2) Using different metrics (F1-score instead of Accuracy), or 3) Using algorithms that handle imbalance well (Random Forest).

The process of examining data from an existing source and collecting statistics or informative summaries about that data to understand its structure and quality at the start of a project.

By comparing summary statistics (mean, total) before and after cleaning, checking for unexpected NULLs, and running sample queries to ensure the data aligns with business logic.

Standardization (Z-score scaling) makes data have a mean of 0 and std dev of 1. Normalization (Min-Max scaling) rescales data to a fixed range, usually 0 to 1.

I start by asking 'What is the business goal?' (e.g., increase revenue). Then I identify the metrics needed (e.g., conversion rate) and finally determine the data sources and queries required to measure them.

I've worked with Customer Acquisition Cost (CAC), Lifetime Value (LTV), Churn Rate, Daily Active Users (DAU), and Net Promoter Score (NPS).

I avoid jargon, use clear visualizations, focus on the 'So What?' (the impact on business), and provide actionable recommendations rather than just presenting data.

A randomized experiment with two variants, A and B. It's used to compare two versions of a webpage or product to see which performs better based on a specific metric.

Churn Rate = (Customers lost during period / Total customers at start of period) * 100. It measures the rate at which customers stop doing business with a company.

Dividing a customer base into groups of individuals that are similar in specific ways, such as age, interests, or spending habits, to tailor marketing strategies.

ROI = (Net Profit / Cost of Investment) * 100. It is a key metric used to evaluate the efficiency or profitability of an investment.

It depends on the industry, but generally: Revenue, Profit Margins, Customer Growth, and Retention rates.

I prioritize based on the potential Impact vs. Effort required. Projects that drive high revenue or solve critical pain points with manageable effort come first.

[Actionable Answer]: Explain a situation where you identified a trend (e.g., high churn in a specific segment) and recommended a change that led to measurable improvement.

Funnel analysis tracks the journey of a user through a series of steps toward a goal (e.g., from landing page to checkout). It helps identify where users 'drop off' and which stages need optimization to improve conversion rates.

CLV is calculated by multiplying the average purchase value by the average purchase frequency and then by the average customer lifespan. It helps businesses determine how much they should spend on customer acquisition.

Cohort analysis involves breaking users into groups (cohorts) based on a shared characteristic, usually their signup date. It allows you to see how behavior or retention changes over time for specific groups rather than looking at all users as a single unit.

I start with the problem statement, present the data-driven evidence, estimate the potential ROI or impact (e.g., saved hours or increased revenue), and outline the required resources and risks to give stakeholders a clear path forward.

RFM stands for Recency (how recently did they buy?), Frequency (how often?), and Monetary (how much do they spend?). It is a segmentation technique used to identify a company's best customers and those at risk of churning.

I track metrics like Return on Ad Spend (ROAS), Conversion Rate, Click-Through Rate (CTR), and Cost Per Acquisition (CPA). I also compare these metrics against a control group or historical baseline.

Lagging indicators measure past performance (e.g., last month's revenue). Leading indicators are predictive and change before the business trend follows (e.g., number of new trial signups predicting future revenue).

I remain objective, walk them through the methodology and data sources, acknowledge their domain expertise, and if needed, suggest further deep-dive analysis or A/B testing to resolve the ambiguity with more data.

It is the process of estimating future sales using historical data, market trends, and seasonal patterns. Common methods include time-series analysis (ARIMA, Prophet) or simple linear regression.

Using product-specific metrics like Adoption Rate, Feature Usage, Time to Value, and the North Star Metric (the single key figure that best captures the core value your product delivers).

1. Ask (Define the problem), 2. Prepare (Data collection), 3. Process (Data cleaning), 4. Analyze (Exploratory analysis), 5. Share (Visualization/Reporting), and 6. Act (Implementation).

Structured data is highly organized (SQL tables, CSVs). Unstructured data has no predefined format (Text, Audio, Video). Semi-structured data (JSON, XML) falls in between.

A central repository of integrated data from multiple sources. It is designed for analytical reporting (OLAP) rather than transactional processing (OLTP).

OLTP (Online Transactional Processing) handles large numbers of simple transactions (e.g., ATM withdrawals). OLAP (Online Analytical Processing) handles complex queries on historical data for insights (e.g., yearly sales trends).

Big data refers to datasets so large or complex that traditional data processing software can't manage them. It is defined by the 3 Vs: Volume (size), Velocity (speed of generation), and Variety (types of data).

The process of creating a visual representation of either a whole information system or parts of it to communicate connections between data points and structures.

Quantitative data is numerical and can be measured (How many? How much?). Qualitative data is descriptive and conceptual (Why? How do people feel?).

A series of processes that move data from a source (like a CRM) to a destination (like a data warehouse), transforming it along the way to make it ready for analysis.

A collection of processes, roles, policies, and standards that ensure the effective and efficient use of information, focusing on data security, privacy, and integrity.

A data design technique used in data warehouses to optimize for fast data retrieval. It uses Fact tables (measurements) and Dimension tables (context).

In a Star Schema, a central fact table connects to denormalized dimension tables. In a Snowflake Schema, dimension tables are normalized into multiple related tables, making it look like a snowflake.

Data quality measures how well a dataset serves its purpose. Metrics include Accuracy, Completeness, Consistency, Timeliness, and Validity.

Batch processing collects data over a period and processes it all at once (e.g., payroll). Real-time processing handles data immediately as it is generated (e.g., fraud detection).

Fact tables contain quantitative metrics (e.g., Sale_Amount, Quantity). Dimension tables contain descriptive attributes related to the facts (e.g., Product_Name, Store_Location, Date).

The 'life cycle' of data that shows the data's origins, where it moves over time, and what happens to it as it travels through different systems.

A data warehouse stores structured, processed data for specific analysis. A data lake stores vast amounts of raw data (structured and unstructured) for future, often undetermined, purposes.

A method used to define and manage the critical data of an organization to provide a single, trusted 'source of truth' for business entities like customers or products.

Simply put, metadata is 'data about data.' It provides context, such as the table name, column types, creation date, and data owner.

Scalability, data storage costs, processing speed (latency), data security/privacy, and the difficulty of cleaning messy, unstructured data at scale.

The process of selecting, preparing, extracting, and transforming data and permanently transferring it from one computer storage system to another.

Supervised learning trains on labeled data (mapping input to a known output). Unsupervised learning finds hidden patterns or structures in unlabeled data (grouping things without being told what they are).

Overfitting is when a model 'memorizes' the training data but fails on new data. Underfitting is when the model is too simple to capture the underlying trend.

A resampling technique used to evaluate models by partitioning the data into subsets, training on some and validating on others (e.g., K-fold) to ensure the model isn't biased toward one specific split.

Bias is error from overly simple assumptions (leads to underfitting). Variance is error from high sensitivity to small fluctuations in training data (leads to overfitting). The goal is to minimize both for optimal model performance.

The process of choosing the most relevant variables for your model. It's important because it reduces noise, prevents overfitting, and speeds up training time.

Clustering is an unsupervised learning task of grouping similar data points together. Common algorithms include K-Means, Hierarchical Clustering, and DBSCAN.

Classification predicts a discrete label or category (Spam vs. Not Spam). Regression predicts a continuous numerical value (Predicting the price of a house).

A table used to evaluate the performance of a classification model by showing True Positives, True Negatives, False Positives, and False Negatives.

Precision measures 'How many predicted positives were actually positive?' Recall measures 'How many actual positives did we capture?' There is usually a tradeoff between the two.

An algorithm that groups data into 'k' clusters by minimizing the distance between data points and the center (centroid) of their assigned cluster.

Commonly used tools include Tableau (powerful visuals), Power BI (Microsoft integration), and Looker (SQL-based modeling). My choice depends on the existing company stack.

Yes, GA4 tracks events. Key metrics include Users, Sessions, Bounce Rate (now Engagement Rate), Average Session Duration, and Conversion Rate.

Git tracks changes in code. It is essential for data analysts to manage SQL scripts and Python notebooks, allowing for collaboration and the ability to revert to previous versions.

I use cloud platforms for data storage (S3/GCS) and compute (Redshift/BigQuery). BigQuery (GCP) is particularly popular for data analysts due to its serverless nature.

An open-source web application that allows you to create documents containing live code, equations, visualizations, and narrative text. It's the standard for exploratory data analysis (EDA).

Yes, I use the 'requests' library in Python to fetch data from APIs (like weather or financial data) and convert the JSON response into a pandas DataFrame.

A multi-language engine for executing data engineering, data science, and machine learning on single-node machines or clusters. It is known for its speed in processing massive datasets.

A framework that allows for the distributed processing of large data sets across clusters of computers using simple programming models (MapReduce).

I am proficient in relational databases (PostgreSQL, MySQL, SQL Server) and have experience querying data warehouses like Snowflake and BigQuery.

SQL (Relational) is structured with tables and schemas (e.g., MySQL). NoSQL (Non-relational) is flexible and can store documents or key-value pairs (e.g., MongoDB).

1. Check data integrity (is the tracking broken?), 2. Segment the drop (is it one region or device?), 3. Correlate with external factors (holidays, outages), 4. Review recent product changes.

I thank them for the feedback, walk through my data sources and cleaning steps, show them the raw data if needed, and offer to run a quick validation or cross-reference.

I investigate *why* data is missing. If it's a critical column, I look for a better source. If not, I may drop the column entirely rather than imputing, as 80% imputation introduces too much bias.

I focus on high-level KPIs (Revenue, Growth) with minimal clutter. I provide 'drill-down' options for details but ensure the main view answers the business status in 10 seconds.

I use EXPLAIN to find bottlenecks, check for missing indexes, avoid 'SELECT *', reduce JOINs on non-indexed columns, and consider using temp tables or CTEs to break down logic.

I look for the 'source of truth' (e.g., the billing DB vs. the analytics tool). I compare timezones, filter settings, and definitions of a 'user' to find the discrepancy.

I start with the final conclusion (The 'Headline'), show 1-2 supporting charts, and end with the recommended action. I leave the technical details for the appendix.

I compare the actual metrics (Adoption, Retention) against the pre-launch targets and against the performance of previous similar product launches.

I immediately notify the stakeholders, explain the error, provide the corrected report, and outline the steps I've taken to ensure this specific error doesn't happen again.

I would use a combination of cohort analysis to see *when* they leave and a correlation/regression analysis to see *which* features or behaviors distinguish churners from active users.

I identify the data owner, explain the business value of the request to get approval, and meanwhile, check if a proxy dataset exists that can provide a preliminary answer.

By comparing the sales volume and revenue before and after the change, accounting for seasonality, and ideally using a control region where the price did not change.

I double-check my work for errors. If it holds up, I present the data transparently. Data's job is to uncover the truth, even if it challenges our assumptions.

I'd use SQL to pull the data directly into a BI tool (Tableau/Power BI) or use a Python script with 'schedule' or 'airflow' to generate and email the report automatically.

I focus on the 20% of features that handle 80% of the tasks. I use official documentation, a crash course, and immediately start a small hands-on pilot with the project data.

I compare it against our internal internal logs (if available), check for statistical anomalies, and verify if the totals match our expected business volume.

I look at which metric most directly impacts the company's bottom-line or 'North Star' goal. I can also track both as primary and secondary metrics temporarily.

I would use Year-over-Year (YoY) comparisons rather than Month-over-Month, or use seasonal decomposition techniques (moving averages) to isolate the seasonal component.

I optimize the underlying SQL queries, move from manual Excel updates to automated BI dashboards, and pre-aggregate data in the warehouse instead of calculating it on the fly.

I would professionally decline and explain that my role is to provide an accurate, ethical representation of the data to help the company make correct, long-term decisions.

Talk about a project with messy data or a tight deadline. Focus on the steps you took to overcome the obstacle and the final positive outcome for the business.

I use a 'check and double-check' system: SQL verification queries, comparing sums across different tools, and having a peer review my logic for major reports.

Provide a specific example: 'I noticed users on Mobile were dropping off 3x faster, leading to a UI redesign that boosted mobile revenue by 20%.'

I prioritize the 'must-have' insights first, communicate early if there's a blocker, and focus on delivering a functional analysis that can be refined later.

I'm honest about it. I say, 'I don't have that answer right now, but let me research our data sources and get back to you by EOD.' Then I follow through.

I follow industry blogs (Medium/Towards Data Science), participate in Kaggle competitions, and take advanced courses in SQL/Python to keep my skills sharp.

I act as the bridge between technical data and business goals, working closely with Marketing for tracking and Engineering for data collection.

I bring both parties together to clarify the ultimate business objective and help them realize how one unified metric or report can serve both needs.

I am a project-based learner. I find a real data problem I have and try to solve it using the new tool, which helps the knowledge stick much faster than just reading.

I enjoy the process of turning raw, messy information into clear stories that help people make better decisions. I'm naturally curious and love solving puzzles.

Acknowledge the mistake, explain how you caught it (or how it was caught), what you did to fix it, and most importantly, what system you put in place to prevent it from recurring.

I use a task management system (Trello/Jira), set clear expectations on delivery dates, and focus on deep-work blocks for complex SQL/Python tasks.

Focus on your use of analogies. 'I explained a SQL JOIN like merging two different spreadsheets so we could see a customer's name next to their order.'

Describe a dataset with millions of rows, high dimensionality, or severe quality issues, and explain the specific tools you used to navigate it.

I view it as an opportunity to improve the quality of the analysis. I listen to the perspective, validate it against the data, and iterate on the report accordingly.