Easy Data Science Interview Questions

A table of true positives, false positives, true negatives and false negatives from which accuracy, precision, recall and F1 are calculated.

A symmetric bell-shaped distribution defined by mean and standard deviation, where about 68%, 95% and 99.7% of values lie within 1, 2 and 3 standard deviations.

Information from outside the training window, such as future data or test statistics, enters training and inflates performance. Split first, then fit scalers and encoders on training data only.

Split the data into k folds, train on k−1 folds and validate on the remaining one, rotate and average the scores. It gives a more reliable estimate than one split and helps tune hyperparameters without touching the test set.

Covariance shows the direction of a relationship but depends on units. Correlation is covariance scaled to −1…+1, so it shows direction and strength and is unit-free.

Type I = false positive (rejecting a true null), probability α. Type II = false negative (missing a real effect), probability β. Power = 1 − β.

First understand why data is missing. Then drop rows or columns with too many nulls, impute with mean/median/mode or a model (KNN), add a 'was_missing' flag, and fit imputers on training data only.

Train fits the model, validation tunes hyperparameters and model choice, and the untouched test set gives a final unbiased estimate of performance.

List: ordered and mutable. Tuple: ordered and immutable (hashable, slightly faster). Set: unordered, unique items, fast membership checks. Dict: key–value pairs with fast lookup by key.

== compares values for equality, while is checks whether two names point to the same object in memory. Use is mainly for None checks.

loc selects by label (row and column names, inclusive of the end label); iloc selects by integer position (end-exclusive).

Regression predicts continuous values such as price; classification predicts discrete categories such as spam or not spam.

Splitting text into units such as words, subwords or characters that are mapped to ids; subword methods like BPE handle rare words well.

Precision = TP / (TP + FP). Recall = TP / (TP + FN). Prefer recall when missing a positive is costly — for example disease screening or fraud detection.

int, float, complex, bool, str, list, tuple, set, dict and NoneType. Mutable ones are list, set and dict; the others are immutable.

Bagging trains models in parallel on bootstrap samples and averages them (reduces variance, e.g. Random Forest). Boosting trains models one after another, each fixing the previous errors (reduces bias, e.g. XGBoost).

df.drop_duplicates(subset=[...], keep='first') removes repeated rows; use duplicated() first to inspect what will be dropped.

Mean is the average, median is the middle value after sorting and mode is the most frequent value. Median is more robust to outliers.

A method is a function that belongs to an object or class and receives the instance (self) as its first argument.

*args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dict. They make function signatures flexible and are common in wrappers and decorators.

The rule that lets arrays of different shapes operate together by virtually stretching the smaller one, for example adding a scalar or a (3,) vector to a (4,3) matrix.

Supervised learning trains on labelled data to predict a target; unsupervised learning finds structure such as clusters or components in unlabelled data.

A set stores unique values with no keys; a dictionary stores key-value pairs with unique keys. Both use hashing, so lookups are O(1) on average.

Pearson measures linear relationships on continuous data; Spearman uses ranks, so it captures monotonic relationships and is less sensitive to outliers.

A measure of asymmetry. Right-skewed data has a long tail on the right (mean greater than median); left-skewed is the opposite. Log transforms often reduce right skew.

They build a list in one readable expression, for example [x*x for x in data if x > 0]. They are usually faster than an equivalent for-loop with append.

Modelling the count of events in a fixed interval when events occur independently at a constant average rate, such as calls per hour or defects per batch.

The square root of the variance; it measures how far values typically sit from the mean, in the same units as the data.

The model memorises noise and fails on new data. Prevent it with more data, simpler models, regularisation, cross-validation, early stopping and dropout.

The probability of seeing a result at least this extreme if the null hypothesis were true. A small p-value (for example < 0.05) is evidence against the null hypothesis.

Layers of connected neurons that apply weights, biases and activation functions to learn complex patterns, trained by backpropagation.

A Series is a one-dimensional labelled array: one column of values with an index. A DataFrame is a two-dimensional table made of several Series that share the same index, and each column can have its own dtype. Selecting one column, like df['price'], gives you a Series. Selecting with a list, like df[['price']], gives you a DataFrame. Many methods work on both, but the output shape is different.

axis tells an operation which direction to work along. axis=0 works down the rows, so df.sum(axis=0) gives one total per column. axis=1 works across columns, so df.sum(axis=1) gives one total per row. In df.drop, axis=1 means drop columns and axis=0 means drop rows. A simple way to remember it: the axis you name is the one that gets collapsed or removed.

Method chaining writes a sequence of transformations as one expression, for example df.query(...).assign(...).groupby(...).agg(...). It avoids many temporary variables, reads top to bottom like a recipe, and reduces the risk of changing the wrong intermediate DataFrame. assign and pipe make chaining easy. The trade-off is that long chains are harder to debug, so split them into named steps when a chain grows past eight or ten operations.

A context manager sets something up and guarantees cleanup when a block ends, even if an error is raised. You use it with the with statement, for example with open('data.csv') as f, which always closes the file. It works through __enter__ and __exit__ methods, or the contextlib.contextmanager decorator. In data work it is used for files, database connections, locks and timers, so resources are never left open.

Situation: in my final-year project, a teammate's cleaning script was one 600-line notebook that took 20 minutes to run. Task: I needed to reuse it for new data. Action: I split it into small functions, added docstrings, replaced row loops with vectorised Pandas code and wrote a few checks for row counts. Result: run time fell to 2 minutes and the team could reuse the functions. I learned to refactor in small, tested steps.

Type hints annotate expected types, for example def clean(df: pd.DataFrame, cols: list[str]) -> pd.DataFrame. Python does not enforce them at runtime, but tools like mypy and IDEs use them to catch mistakes early and give better autocomplete. In data teams they make shared pipeline code easier to read and review. They matter most in production code and libraries, less in quick exploratory notebooks.

A population is the full group you want to learn about, such as all customers of an app. A sample is the subset you actually observe, such as 5,000 surveyed customers. Numbers from the population are parameters, and numbers from a sample are statistics that estimate them. Good sampling, ideally random, lets you generalise from the sample to the population and measure the uncertainty using standard errors and confidence intervals.

Standard deviation measures how spread out individual data points are. Standard error measures how much a sample statistic, usually the mean, would vary if you repeated the sampling. For the mean, SE = SD divided by the square root of n. So with more data the standard deviation stays roughly the same, but the standard error shrinks. Confidence intervals and t-tests are built on the standard error.

A two-tailed test checks for a difference in either direction, for example whether a new page changes conversion up or down. A one-tailed test checks only one direction, such as whether it increases conversion. One-tailed tests have more power for that direction but ignore harm in the other direction. In most product experiments a two-tailed test is the safer default unless the direction was fixed before seeing data.

A t-test compares means when the population variance is unknown. A two-sample t-test compares two independent groups, such as users in control and treatment. A paired t-test is used when the same units are measured twice, such as the same students before and after training. Pairing removes variation between individuals, so it is more powerful. Welch's t-test is preferred when the two groups have unequal variances.

I start with the decision they care about, not the formula. Once a sales manager asked why a 3 percent lift was not significant. I explained that with only 200 customers, the result could easily happen by chance, like getting 6 heads in 10 coin tosses. I showed a simple range chart of the confidence interval and suggested running the test longer. He agreed, and the extended test gave a clear answer.

Conditional probability is the chance of an event given that another event has happened, written P(A given B) = P(A and B) / P(B). Example: 10 percent of users buy, and 40 percent of users who add to cart buy. So P(buy given cart) is 0.4, much higher than the overall 0.1. It is the base of Bayes' theorem, Naive Bayes and many funnel analyses.

Start visually with a histogram and a Q-Q plot; points close to the straight line suggest normality. Check skewness and kurtosis values. Then use a formal test such as Shapiro-Wilk for small samples or Anderson-Darling. Remember that with very large samples, tests flag tiny harmless deviations, so judge by the plots too. If data is skewed, consider a log transform or a non-parametric method.

F1 is the harmonic mean of precision and recall, so it is high only when both are high. It is useful for imbalanced classes where accuracy hides poor performance. It can mislead because it ignores true negatives and treats precision and recall as equally important. If missing a fraud case costs far more than a false alarm, use an F-beta score with beta above 1, or choose metrics based on real costs.

Early stopping monitors a validation metric during training and stops when it has not improved for a set number of rounds, called patience. It is used in gradient boosting and neural networks to prevent overfitting and save time. The model from the best round is kept. The validation set must not be the final test set, otherwise the reported test score becomes optimistic.

If only 1 percent of transactions are fraud, a model that predicts not fraud for everything is 99 percent accurate and useless. Accuracy hides the minority class. I would check the confusion matrix, recall on fraud cases and precision-recall AUC. Then fix it with class weights, resampling or a lower decision threshold, and choose the threshold based on the cost of missed fraud versus false alerts.

R-squared shows the share of variance in the target explained by the model. It never decreases when you add a feature, even a useless one. Adjusted R-squared penalises extra features based on the number of predictors and sample size, so it rises only if a new feature improves the model more than chance would. Use adjusted R-squared to compare linear models with different numbers of features.

Stratified splitting keeps the class proportions the same in the training and test sets. If 5 percent of customers churn, both sets will have about 5 percent churners. Without it, a small or imbalanced dataset can give a test set with very few positives and unstable metrics. In scikit-learn you pass stratify=y to train_test_split or use StratifiedKFold for cross-validation.

MAE is the average absolute error; it is easy to explain and less sensitive to outliers. MSE squares errors, so large errors are punished heavily, and it is smooth for optimisation. RMSE is the square root of MSE, so it is in the same units as the target while still punishing big misses. Use RMSE when large errors are very costly, like stock-out forecasts, and MAE when outliers should not dominate.

A baseline is the simplest reasonable prediction, such as predicting the most common class, last week's value or a basic logistic regression. It sets the minimum score any real model must beat. Without it, a 75 percent accuracy can look good when predicting the majority class already gives 80 percent. Baselines also catch pipeline bugs early and show whether extra complexity is worth it.

Word embeddings represent words as dense vectors, usually 100 to 300 numbers, so that words used in similar contexts get similar vectors. Word2Vec learns them by predicting a word from its neighbours or the neighbours from the word. Unlike one-hot or TF-IDF, embeddings capture meaning, so king and queen are close. Their limit is one vector per word, so bank has the same vector in river bank and bank loan.

Both reduce words to a base form. Stemming chops suffixes using rules, so studies becomes studi; it is fast but can produce non-words. Lemmatisation uses vocabulary and grammar to return the real dictionary form, so studies becomes study and better becomes good. Lemmatisation is more accurate but slower. With modern transformer models, neither is usually needed because subword tokenisers handle word forms.

Named entity recognition finds and labels spans of text such as person names, organisations, locations, dates and amounts. For example, in an invoice email it can pull out the vendor, invoice number and total. It is usually framed as token classification with BIO tags. spaCy and fine-tuned transformer models are common tools. Domain-specific entities, like medicine names, usually need custom labelled training data.

Data augmentation creates new training examples by applying realistic changes to existing ones. For images this means flips, rotations, crops and brightness changes. For text it can mean synonym replacement, back-translation or random word dropping. For audio, adding noise or shifting pitch. It improves generalisation when data is limited. Changes must keep the label correct; flipping a digit 6 can turn it into a 9.

Step 1: collect and label a sample of reviews, checking class balance. Step 2: build a baseline with TF-IDF and logistic regression to get a quick benchmark. Step 3: fine-tune a small pretrained transformer such as DistilBERT for better accuracy, or use a multilingual model if reviews mix languages. Step 4: evaluate with F1 per class and read wrong predictions. Step 5: handle sarcasm and neutral reviews explicitly.

One-hot encoding creates a binary column per category and suits nominal data like city for linear models. Label encoding maps categories to integers arbitrarily; it is fine for tree models but implies a false order for linear models. Ordinal encoding also uses integers but in a meaningful order, like low, medium, high mapped to 0, 1, 2. Choose based on whether categories have a natural order and which model you use.

Binning groups a continuous variable into ranges, like age into 18-25, 26-35 and so on. It can capture non-linear effects in linear models, reduce the impact of outliers and make results easier to explain to business teams. Bins can be equal width, equal frequency using quantiles, or chosen by domain knowledge. The downside is losing information inside each bin, and tree models usually do not need it.

A log transform compresses large values and spreads small ones, which reduces right skew in features like income, price or page views. This helps linear models and distance-based models that are sensitive to scale and outliers. Use log1p, which is log of 1 plus x, when the feature has zeros. For negative values, a Yeo-Johnson transform works. Tree models generally do not need it.

Categories that appear only a few times give unreliable signals and create many sparse columns. A common fix is to group all categories below a frequency threshold, like 1 percent, into an Other bucket. You can also use frequency encoding or smoothed target encoding. Make sure the encoder handles unseen categories at prediction time, for example with handle_unknown set to ignore.

WHERE filters individual rows before grouping, so it cannot use aggregate functions. HAVING filters groups after GROUP BY and can use aggregates. Example: WHERE order_date >= '2026-01-01' keeps only this year's orders, then GROUP BY customer_id HAVING SUM(amount) > 10000 keeps customers who spent more than 10,000. Filtering early with WHERE is also faster because fewer rows are grouped.

An INNER JOIN returns only rows with matching keys in both tables. A LEFT JOIN returns all rows from the left table, with NULLs where the right has no match. A RIGHT JOIN is the mirror of that. A FULL OUTER JOIN returns all rows from both sides, matched where possible. In analytics, LEFT JOIN from a customers table is common so customers with no orders are still counted.

Window functions compute a value for each row using a set of related rows, without collapsing them like GROUP BY does. They use OVER with optional PARTITION BY and ORDER BY. Examples are ROW_NUMBER for ranking, SUM OVER for running totals, LAG and LEAD for previous and next values, and AVG over a frame for moving averages. They are central to data science SQL interviews.

All three number rows within a window ordered by some column. ROW_NUMBER gives unique numbers even for ties: 1, 2, 3. RANK gives tied rows the same rank and skips the next numbers: 1, 1, 3. DENSE_RANK gives ties the same rank without gaps: 1, 1, 2. Use ROW_NUMBER to pick exactly one row per group, and DENSE_RANK for questions like the second highest distinct salary.

Although you write SELECT first, the database logically processes FROM and JOIN first, then WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY and finally LIMIT. This explains common errors: you cannot use a SELECT alias in WHERE because WHERE runs before SELECT, but you can use it in ORDER BY. Window functions are computed after WHERE and GROUP BY, so filter on them in an outer query.

COUNT(*) counts all rows, including rows with NULLs. COUNT(column) counts only rows where that column is not NULL. COUNT(DISTINCT column) counts unique non-NULL values. For example, in an orders table, COUNT(*) is the number of orders, COUNT(coupon_code) is orders that used a coupon, and COUNT(DISTINCT customer_id) is the number of unique buyers. Mixing them up is a common reporting bug.

Both stack the results of two queries with the same number and type of columns. UNION removes duplicate rows, which needs an extra sort or hash step and is slower. UNION ALL keeps every row, including duplicates, and is faster. Use UNION ALL by default when you know the sets do not overlap or when duplicates matter, such as combining transaction logs from two systems.

Situation: during my internship I was building a monthly sales report. Task: make sure numbers were correct before sharing. Action: I compared order counts per day and noticed one day had double the usual orders. A GROUP BY on order_id showed every order that day appeared twice because a load job had run twice. Result: I reported it, the data team removed duplicates and added a uniqueness check. Now I always validate row counts.

A large language model is a neural network, usually a decoder-only transformer, trained on huge amounts of text to predict the next token. With billions of parameters and further instruction tuning, it can answer questions, summarise, write code and follow instructions. It does not look up facts; it generates likely text based on patterns learned in training, so it can be fluent but wrong. Data scientists use LLMs through APIs or open-weight models.

Tokens are the pieces of text an LLM reads and writes, often word parts; in English, one token is roughly three quarters of a word. The context window is the maximum number of tokens the model can consider at once, including your prompt, any documents and its answer. Costs and speed depend on token counts. Long documents beyond the window must be chunked, summarised or retrieved selectively.

In zero-shot prompting you give only instructions, like classify this review as positive or negative. In few-shot prompting you also include a few worked examples of input and correct output, which shows the model the format and decision boundary. Few-shot usually improves consistency on custom labels, at the cost of more tokens. Pick examples that cover tricky cases and keep their format identical to what you want back.

Both control randomness when the model picks the next token. Temperature scales the probabilities: low values like 0 to 0.3 make output focused and repeatable, high values make it more varied and creative. Top-p, nucleus sampling, keeps only the smallest set of tokens whose probabilities add up to p, such as 0.9, and samples from them. For extraction and classification use low temperature; for brainstorming use higher values.

A base model is trained only to predict the next token on large text, so it continues text rather than following requests. An instruction-tuned model is further trained on instruction and answer pairs, and often preference data, so it follows prompts, answers questions and behaves like an assistant. For apps you usually use instruction-tuned or chat models. Base models are mainly starting points for custom fine-tuning.

MLOps is the set of practices that take machine learning models from experiments to reliable production and keep them working. It covers versioning data and code, tracking experiments, automated training pipelines, testing, deployment, monitoring and retraining. It borrows ideas from DevOps but adds data and model concerns, because a model can fail even when the code has not changed, simply because the data has.

Batch inference scores many records on a schedule, for example nightly churn scores for all customers written to a table. It is cheap and simple. Real-time inference serves predictions on request through an API within milliseconds, for example fraud checks during payment. It needs low-latency feature access, scaling and high availability. Choose real-time only when the decision truly must use fresh data at the moment of the request.

A DAG, directed acyclic graph, in Apache Airflow defines a workflow as tasks with dependencies, such as extract data, build features, train model and publish scores, in that order. Airflow schedules runs, retries failed tasks, passes run dates and shows status in a web UI. Acyclic means no task can loop back to an earlier one. Data scientists use it for scheduled training and batch scoring pipelines.

A time series is a sequence of observations recorded at ordered time steps, such as daily sales or hourly website traffic. Unlike ordinary tabular data, rows are not independent: today's value depends on yesterday's, and the order cannot be shuffled. This changes everything downstream. You must split train and test by time, build features only from the past, and check for trend and seasonality before choosing a model.

Trend is the long-term direction of the series, such as steady growth in monthly users. Seasonality is a pattern that repeats at a fixed period, like higher sales every weekend or every festive season. Noise is the random variation left after removing trend and seasonality. Separating these parts, through decomposition, helps you understand the data and pick a model that can capture each component properly.

A stationary series has a constant mean, constant variance and an autocorrelation structure that does not change over time. Classical models like ARMA assume stationarity because they learn fixed relationships between past and present values; if the mean keeps drifting, those relationships break. You usually make a series stationary by differencing to remove trend, seasonal differencing to remove seasonality, and a log transform to stabilise growing variance.

Differencing replaces each value with the change from the previous value: y_t minus y_(t-1). It removes a linear trend and often makes a series stationary. Seasonal differencing subtracts the value one season back, such as y_t minus y_(t-7) for daily data with a weekly cycle. Avoid over-differencing, because it adds noise and negative autocorrelation. In ARIMA, the d parameter is the number of times you difference.

A naive forecast predicts that the next value equals the last observed value. A seasonal naive forecast predicts the value from the same period last season, such as last Monday for next Monday. They take seconds to build and are surprisingly hard to beat on many business series. Always report your model's error relative to these baselines; if a complex model cannot beat seasonal naive, it is not adding value.

With additive seasonality the seasonal swing is a fixed amount, for example weekends always add about 500 orders regardless of the overall level. With multiplicative seasonality the swing is a percentage of the level, so as the business grows the weekend spike grows too. A quick check is to plot the series: if the peaks widen as the trend rises, use multiplicative, or take a log and model it additively.

A prediction interval gives a range in which a future value is expected to fall with a stated probability, such as 80 or 95 percent. A point forecast of 1,000 units means little without knowing whether the realistic range is 950 to 1,050 or 400 to 1,600. Planners use the interval to set safety stock and staffing. Intervals widen with the horizon because uncertainty accumulates over time.

First make the gaps explicit by reindexing to a full daily calendar so missing days appear as NaN instead of silently disappearing. For short gaps, linear or time-based interpolation is usually fine. If there is strong weekly seasonality, fill using the same weekday from neighbouring weeks or a seasonal decomposition. Add a flag column marking imputed days, and never treat missing as zero unless zero really happened.

A dataclass, created with the @dataclass decorator, automatically generates __init__, __repr__ and __eq__ from annotated fields. It is a clean way to hold structured records such as a training config with learning rate, batch size and paths. Options like frozen=True make instances immutable, and default values reduce boilerplate. Compared with plain dictionaries, dataclasses give attribute access, type hints and clearer errors when a field is misspelled.

The binomial distribution gives the probability of getting k successes in n independent trials, each with the same success probability p. Its mean is n times p and its variance is n times p times (1 minus p). You use it for counts of yes-or-no outcomes, such as how many of 1,000 visitors convert or how many of 50 parts are defective. For large n it is well approximated by a normal distribution.

An average hides the shape of the distribution. Delivery times are usually right-skewed, so a 30-minute mean can include many orders taking 60 minutes or more. Look at the median, the 90th and 95th percentiles and a histogram, then break them down by city, time of day and restaurant. Report the share of orders beyond the promised time, because that is what customers actually experience.

An image is a numeric array of height by width by channels, where a colour image has three channels, usually RGB, with pixel values from 0 to 255. Libraries differ: OpenCV loads BGR in HWC order, while PyTorch expects tensors in CHW order with a batch dimension in front. Before training you convert to float, scale to 0-1 and normalise with the mean and standard deviation used by the pretrained model.

The kernel is a small learnable filter, such as 3x3, that slides over the image and computes a weighted sum at each position. Stride is how many pixels it moves each step; stride 2 halves the output size. Padding adds border pixels so the output can keep the same size and edge pixels get processed. Output size equals (input minus kernel plus 2 times padding) divided by stride, plus one.

Pooling downsamples a feature map by summarising small regions. Max pooling keeps the largest value in each window, such as 2x2, and average pooling keeps the mean. It reduces computation, enlarges the receptive field of later layers and gives a little tolerance to small shifts. Many modern networks replace pooling with strided convolutions, but global average pooling before the classifier head is still very common.

Classification assigns one label to the whole image, such as cat. Object detection finds each object and returns a bounding box plus a class label and confidence for each one. Segmentation labels every pixel, giving exact object shapes. The tasks need increasingly detailed annotations and compute. Choose based on the business need: counting products on a shelf needs detection, while measuring a crack's area needs segmentation.

IoU measures how well a predicted box or mask overlaps the ground truth. It is the area of their intersection divided by the area of their union, giving a value from 0 for no overlap to 1 for a perfect match. In detection, a prediction usually counts as correct if IoU is at least 0.5 with a ground truth box of the same class. IoU is also used inside non-maximum suppression.

A detector usually predicts many overlapping boxes for the same object. Non-maximum suppression keeps the box with the highest confidence, removes other boxes of the same class whose IoU with it exceeds a threshold such as 0.5, and repeats with the remaining boxes. A threshold that is too low can delete genuinely nearby objects in crowded scenes, so variants like soft-NMS lower scores instead of removing boxes.

First measure agreement, for example with Cohen's kappa or IoU between annotators' boxes, to find which classes are confusing. Usually the guidelines are unclear, so write precise rules with example images for edge cases and retrain annotators. Have multiple people label a subset and resolve conflicts by majority vote or an expert reviewer. Track ambiguous images separately, since even a perfect model cannot beat human label noise.

The control group sees the current experience, and the treatment group sees the change being tested, such as a new checkout button. Users are randomly assigned, so the only systematic difference between groups is the change itself. Any difference in metrics beyond random noise can then be attributed to the treatment. Without a proper control, you cannot separate the effect of your change from seasonality, marketing or other launches.

In an A/A test both groups get the identical experience. Since there is no real difference, results should be significant only about 5 percent of the time at alpha 0.05. Running A/A tests validates your experimentation platform: it catches broken randomisation, logging bugs, sample ratio problems and metrics whose variance is wrongly estimated. Teams often run them when launching a new platform or a new metric.

The primary metric is the one the change is meant to improve and that decides success, such as checkout conversion. Guardrail metrics are ones that must not get worse, such as page load time, refund rate, unsubscribes or revenue per user. Defining both before the test prevents cherry-picking afterwards. A change that lifts the primary metric but breaks a guardrail is usually not shipped without further discussion.

Not significant does not mean no effect. Report the observed effect with its confidence interval, for example minus 0.3 to plus 1.2 percent, and compare it with the MDE the test was powered for. If the interval rules out effects that matter, conclude the change has little impact and decide based on cost or design preference. If the interval is wide, the test was underpowered, and a longer test or variance reduction may help.

Run an A/B/n test with control plus five variants and equal random allocation. Calculate sample size for the smallest effect worth detecting, remembering that each variant gets only a sixth of traffic, so the test takes longer. Plan the analysis upfront: compare each variant to control and adjust for multiple comparisons. If the team has strong priors, test fewer designs first to save time.

Situation: new analysts kept misusing two similar revenue columns. Task: reduce repeated questions and errors. Action: I wrote a short data dictionary for our main tables, with definitions, known pitfalls and sample queries, and linked it in the team wiki and onboarding checklist. I updated it whenever schemas changed. Result: onboarding time dropped, and the number of revenue mismatches in reports fell noticeably within a quarter.

A system prompt is the instruction message placed before user messages that sets the model's role, tone, rules and output format, for example 'You are a support assistant; answer only from the provided policy and reply in JSON'. It shapes every response in the conversation. Keep it clear and specific, version it like code, and do not rely on it alone for security, since users can try to override it through prompt injection.

Depending on the encoder, the pipeline may crash or silently map the value to all zeros. Plan for it: use OneHotEncoder with handle_unknown='ignore' or map unseen values to an explicit 'other' bucket that also exists in training for rare values. Log and monitor the rate of unknown categories, since a rising rate signals data drift, and retrain when new categories become common.

A model registry is a central store for trained model versions along with their metadata: training data version, code commit, parameters, metrics and owner. Models move through stages such as staging, production and archived, with approvals. It gives one source of truth for which model is live, makes rollback to a previous version easy and supports audits. Tools like MLflow Model Registry are commonly used.