The A to Z of a Capstone Data Project: 15 Steps from Goal to Reflection

A Capstone Data Project is a comprehensive, culminating project that integrates the knowledge and skills you've acquired throughout your education or training in data science or a related field. The goal is to showcase your ability to tackle real-world problems using data analysis, machine learning, and other relevant techniques.

This is a working guide, not a summary. Each of the 15 steps lists its purpose, activities, methods, standards and deliverables, so you can use it as a checklist while you build. Skim the lifecycle first, then jump to the step you are on from the contents.

Project Lifecycle at a Glance

Phase Steps Main output
Frame1-2Problem statement, dataset
Understand and prepare3-5EDA findings, clean data, features
Model6-8Trained models, evaluation, interpretation
Communicate9-10, 14Report, repository, presentation
Improve and learn11-13, 15Iterations, feedback, reflection

Workflow diagram

How to read it: solid arrows are the normal forward path; dotted arrows are the feedback loops you should expect to take. Steps 3-8 are the iterative core of the project.

1. Define Your Goal

Purpose: Everything downstream (data, metrics, models) is judged against the goal. A vague goal produces a vague project.

Activities

  • Write a one-sentence problem statement ("Predict whether a passenger survived the Titanic disaster using passenger attributes").
  • Identify stakeholders and who will use the result.
  • Decide the task type:
    1. Classification
    2. Regression
    3. Clustering
    4. Forecasting
    5. Pure exploration
  • Define success criteria and constraints.
  • List assumptions and risks.

Methods

  • SMART framework:
    • Specific: the goal is clear and unambiguous.
    • Measurable: progress and success can be quantified.
    • Achievable: realistic given your skills, data and time.
    • Relevant: it matters to the stakeholders and the wider problem.
    • Time-bound: it has a deadline or timeframe.
  • Hypothesis writing: state at least 3 testable hypotheses (e.g., "Women had higher survival rates than men").

Standards

  • The goal is stated in one or two sentences a non-specialist can understand.
  • Success is a number with a threshold (e.g., "accuracy of at least 80% on held-out data, beating the 62% majority-class baseline").
  • Scope is realistic for the available time.
  • Ethical and privacy considerations are noted up front.

Deliverables: Problem statement, success metric, hypotheses list, project timeline (a short README section is enough).

2. Choose a Dataset

Purpose: Data quality and relevance set the ceiling on what any model can achieve.

Activities

  • Search for candidate datasets.
  • Check licence, provenance and permitted use.
  • Read the data dictionary and any accompanying documentation.
  • Confirm the dataset can actually answer your question.
  • Download the data and record where it came from and when.

Methods

  • Dataset selection checklist:
    • Relevance: it can answer your question and contains the target variable.
    • Size: enough rows and features to draw meaningful conclusions.
    • Completeness: missing values are limited and manageable.
    • Recency: the data is current enough for your problem.
    • Licence: you are permitted to use and share it.
    • Documentation: a data dictionary or description is available.
    • Bias: known gaps or skews in who or what is represented are understood.
  • Rule of thumb for sample size: more rows than features by a healthy margin.
  • Record checksums or versions for reproducibility.

Standards

  • Source and licence are cited.
  • A data dictionary exists describing every column, type, unit and meaning.
  • No personally identifiable information is exposed unless properly authorised.
  • Train/test files are clearly identified.

Deliverables: Raw data, data dictionary, data source and license note.

3. Exploratory Data Analysis (EDA)

Exploratory Data Analysis (EDA) is the step where you explore, summarise and visualise the data before applying any machine learning or statistical model. It shows what the data looks like and whether it can be trusted.

EDA helps you to:

  • Understand the structure: how many rows and columns there are, what each column means and which data types it holds.
  • Detect patterns: trends, groupings and shapes of distributions that hint at what drives the target.
  • Identify anomalies: missing values, outliers and impossible or inconsistent entries.
  • Test assumptions: check whether the data meets the conditions a method needs, such as normality, balance between classes or independence.
  • Check relationships: see how variables relate to each other and to the target, for example through correlations, group comparisons and cross-tabulations.

Purpose: Build an accurate mental model of the data before you change or model it.

Activities

  • Inspect shape, column types, memory use, and a sample of rows.
  • Summarise missing values, duplicates, and impossible values.
  • Univariate analysis studies one variable at a time to understand its distribution, centre, spread and outliers, or the frequency of each category.
  • Bivariate analysis examines the relationship between two variables, typically a feature and the target, to see whether and how strongly they are associated.
  • Multivariate analysis studies three or more variables together to uncover interactions, correlations and redundancy between features, and how combinations of features relate to the target.
  • Record every finding and question in the notebook as markdown, not just plots.

Methods

  • Structure and quality:
    • Shape and types: count the rows and columns and check that each column has the expected data type.
    • Missing values: count the gaps in each column.
    • Duplicates: count repeated rows.
    • Summary statistics: review the count, mean, spread and range of each column.
  • Numeric features:
    • Histograms: show the distribution shape.
    • KDE plots: show a smoothed distribution curve.
    • Box plots: show the median, spread and outliers.
    • Skewness: measures how asymmetric the distribution is.
    • Kurtosis: measures how heavy the tails are.
  • Categorical features:
    • Count plots: show how many observations fall in each category.
    • Frequency tables: list the counts and percentages for each category.
    • Cardinality checks: count the number of unique categories, to flag high-cardinality columns that need special encoding.
  • Target relationships:
    • Grouped means/rates: compare the average or rate of the target across groups.
    • Stacked bar charts: show how the target classes split within each category.
    • Violin plots: compare the distribution of a numeric feature across target classes.
  • Correlation:
    • Pearson: measures linear association between two numeric variables.
    • Spearman: measures monotonic association, and works for ordinal data or non-linear trends.
    • Cramér's V: measures association between two categorical variables.
    • Heatmaps: display a correlation matrix as colours so strong relationships stand out.
  • Outlier detection:
    • IQR rule: flags values below Q1 − 1.5×IQR or above Q3 + 1.5×IQR.
    • Z-scores: flags values more than a set number of standard deviations (commonly 3) from the mean.
    • Visual inspection: spot extreme points using box plots, scatter plots and histograms.
  • Statistical tests for hypotheses:
    • t-test: compares the means of a numeric variable between two groups (assumes roughly normal data).
    • Mann-Whitney U: compares a numeric variable between two groups without assuming normality.
    • Chi-square: tests whether two categorical variables are associated.

Standards

  • Every chart has a title, labelled axes with units, a legend where needed, and a one-line takeaway.
  • Colours are accessible (colour-blind-safe palette) and used consistently.
  • Findings are written down and tied back to the hypotheses.
  • Chart choice fits the data type.
  • EDA is done on the training data only so that test data does not influence decisions.
  • The notebook runs top to bottom without errors.

Deliverables: EDA notebook with visualisations and written insights, a list of data quality issues to fix in Step 4.

4. Data Cleaning and Preprocessing

Data cleaning is the process of finding and fixing problems in raw data so that it is accurate, consistent and ready for analysis and modelling. It comes after EDA, which shows what is wrong, and before feature engineering and modelling. This follows the principle of garbage in, garbage out (GIGO): errors, gaps and inconsistencies in the data carry through into the model and its results, however good the algorithm is.

Data preprocessing is the wider step that includes cleaning and then transforms the cleaned data into the form a model can learn from, for example by encoding categories as numbers and scaling numeric values to comparable ranges. Cleaning fixes what is wrong with the data, while preprocessing reshapes it for the chosen model. Both are learned from the training data only and applied unchanged to the test data, so that no information leaks from the test set.

Purpose: Turn raw data into a consistent, model-ready dataset without distorting the information it contains.

Activities

  • Fix data types.
  • Handle missing values and decide, per column, whether to drop, impute, or flag.
  • Remove or reconcile duplicates.
  • Treat outliers, with justification for each choice:
    • Keep: retain genuine extreme values that carry real information.
    • Cap (winsorise): limit extreme values to a chosen percentile or boundary.
    • Transform: reduce the effect of extremes, for example with a log transform.
    • Remove: drop values that are clearly errors or impossible.
  • Standardise text and categories.
  • Encode categoricals and scale numerics where the model needs it.
  • Split the data before fitting any imputer, encoder or scaler.

Methods

  • Missing data mechanisms:
    • MCAR (Missing Completely At Random): missingness is unrelated to any variable, so the remaining data is still unbiased.
    • MAR (Missing At Random): missingness depends on other observed variables, so it can be modelled from them.
    • MNAR (Missing Not At Random): missingness depends on the missing value itself, so it needs careful handling such as a missing indicator or domain knowledge.
  • Imputation:
    • Mean/median/mode: fill with the column's average (numeric), middle value (numeric, robust to outliers) or most frequent value (categorical).
    • Group-wise median: fill with the median of a related group, such as the median age per passenger class.
    • KNN imputer: fill using the values of the most similar rows.
    • Iterative imputer: predict each missing value from the other features using a model.
    • Explicit "missing" indicator: add a flag column (or a "Missing" category) so the model can learn from the missingness itself.
  • Dropping: drop columns with extreme missingness unless they are informative when missing.
  • Outliers:
    • IQR or z-score flags: mark values that fall outside the expected range.
    • Log transform: compress large values in right-skewed positive data.
    • Box-Cox transform: reduce skewness for strictly positive data.
    • Yeo-Johnson transform: reduce skewness for data that includes zero or negative values.
    • Capping: limit extreme values to a chosen percentile or boundary.
  • Encoding:
    • One-hot (nominal): create a 0/1 column per category, for categories with no natural order.
    • Ordinal (ordered): map categories to integers that preserve their order, such as low < medium < high.
    • Target encoding (high cardinality): replace each category with the mean of the target for that category, computed inside cross-validation to avoid leakage.
    • Frequency encoding (high cardinality): replace each category with how often it appears.
  • Scaling:
    • Standardisation: rescale to mean 0 and standard deviation 1.
    • Min-max scaling: rescale values to a fixed range, usually 0 to 1.
    • Robust scaling (outlier-heavy data): rescale using the median and IQR, so extreme values have less influence.
  • Implementation: chain all cleaning and preprocessing steps into a single, ordered, reusable workflow, and apply the right steps to the right columns (for example, scaling for numeric columns and encoding for categorical ones). Fit the workflow on the training data only, then apply the same learned steps unchanged to the test data and to any new data, so results are consistent and no information leaks from the test set.

Standards

  • No data leakage: statistics (means, encodings, scalers) are learned from training data only.
  • Every cleaning decision is documented with its reason.
  • Raw data is never overwritten.
  • Row counts before and after each step are logged so that data loss is visible.
  • The cleaning process is a repeatable script or pipeline, not manual edits.

Deliverables: Cleaning pipeline or script, processed dataset, cleaning log (what changed and why).

5. Feature Engineering

Feature engineering is the process of creating, transforming and selecting features (the input variables a model learns from) so that the signal in the raw data is easier for a model to find. It builds on the findings from EDA and cleaning. For example, a passenger's title can be pulled out of their name, and two family columns can be combined into one family size. New features should be checked, because a feature that looks useful does not always improve the model.

Feature engineering helps you to:

  • Improve accuracy: choosing the right features can help the model learn better, leading to more accurate predictions.
  • Reduce overfitting: using fewer, more informative features helps the model avoid memorising the data and perform better on new data.
  • Boost interpretability: well-chosen features make it easier to understand how the model makes its predictions.
  • Enhance efficiency: focusing on key features speeds up the model's training and prediction, saving time and resources.

Purpose: Give the model signals it cannot easily discover on its own, and remove noise.

Activities

  • Brainstorm features using domain knowledge and EDA findings.
  • Create new features from existing ones.
  • Transform skewed or non-linear features.
  • Select the most useful features and drop redundant ones.
  • Validate that each new feature actually helps.

Methods

  • Extraction:
    • Text parts: pull out meaningful pieces, such as a title from a name or a deck from a cabin code.
    • Date parts: split dates into day, month and weekday.
  • Combination:
    • Sums and counts: add related columns together, such as family size = siblings/spouses + parents/children + 1.
    • Flags: create yes/no features, such as travelling alone.
    • Ratios and differences: compare two columns by dividing or subtracting them.
  • Binning:
    • Fixed-width bins: group a numeric value into ranges, such as age groups.
    • Quantile bins: group values so each bin holds a similar number of rows, such as fare bands.
  • Transformations:
    • Log and square root: reduce skewness in positive data.
    • Polynomial terms: add squares or cubes to capture curved relationships.
    • Interaction terms: multiply features together to capture combined effects.
  • Text and categorical:
    • Term-frequency weighting (TF-IDF): turn text into numbers that reflect how distinctive each word is.
    • Frequency encoding: replace each category with how often it appears.
    • Target encoding: replace each category with the mean of the target, computed inside cross-validation to avoid leakage.
  • Selection:
    • Correlation filtering: drop one of each pair of highly correlated features.
    • Variance threshold: drop features that barely change.
    • Mutual information: keep features that share the most information with the target.
    • Permutation importance: measure how much model performance drops when a feature is shuffled.
    • L1 regularisation: let the model shrink unhelpful feature weights to zero.
    • Recursive feature elimination: repeatedly remove the weakest feature and refit.
    • Tree-based importance: rank features by how much a tree model uses them.
  • Dimensionality reduction:
    • Principal component analysis (PCA): combine features into fewer new ones that keep most of the variation. This transforms the features rather than selecting them.

Standards

  • Features are available at prediction time.
  • Each engineered feature has a stated rationale and is tested against the baseline.
  • Feature logic lives in code that is applied identically to train and test.
  • Feature names are descriptive and documented.
  • Complexity is justified: do not keep a feature that adds no measurable value.

Deliverables: Feature engineering code, feature list with descriptions, evidence (metric changes or importance) that features help.

6. Choose a Modeling Approach

Choosing a modelling approach is the step where you decide which type of model suits the problem and how you will test it fairly, before you train anything. The task type from Step 1 (classification, regression, clustering or time series) narrows the candidate algorithms. You then set a simple baseline and a validation plan, so that every later result has something honest to be compared against.

Choosing an approach helps you to:

  • Match the model to the task: use algorithms built for your type of target, instead of trying them at random.
  • Set a baseline: know what a model that does almost nothing scores, so you can tell whether a complex model actually adds value.
  • Estimate performance honestly: split the data and pick a validation method so that scores reflect how the model will do on new data.
  • Keep results reproducible: fix random seeds so that you and others get the same numbers.

Purpose: Match the technique to the problem, and set up an evaluation that gives honest estimates.

Activities

  • Map the task type to candidate algorithms.
  • Build a simple baseline first.
  • Choose a validation strategy.
  • Split the data into training, validation and test sets.
  • Fix random seeds for reproducibility.

Methods

  • Candidate algorithms by task:
    • Classification:
      • Logistic regression: estimates the probability of each class from a weighted sum of features; simple and easy to interpret.
      • k-nearest neighbours: predicts the class most common among the most similar training rows.
      • Decision tree: splits the data with a series of yes/no questions; easy to read but prone to overfitting.
      • Random forest: averages many decision trees trained on random samples, which is more stable than one tree.
      • Gradient boosting: builds trees one after another, each correcting the errors of the last; often very accurate.
      • Support vector machine: finds the boundary that separates the classes with the widest margin.
    • Regression:
      • Linear regression: fits a straight-line relationship between the features and a numeric target.
      • Ridge regression: linear regression with a penalty that shrinks large weights, which helps when features are correlated.
      • Lasso regression: linear regression with a penalty that can shrink some weights to zero, which also selects features.
      • Random forest: averages many decision trees to capture non-linear patterns.
      • Gradient boosting: builds trees in sequence, each correcting the errors of the last.
    • Clustering:
      • k-means: groups rows into a chosen number of clusters around central points.
      • Density-based clustering (DBSCAN): groups points that are densely packed and marks isolated points as noise, without needing the number of clusters in advance.
      • Hierarchical clustering: builds a tree of nested clusters by repeatedly merging the closest groups.
    • Time series:
      • ARIMA/SARIMA: forecasts from past values and past errors, with SARIMA adding seasonal patterns.
      • Trend-and-seasonality models: split a series into trend, seasonal and holiday effects, then forecast each part.
      • Gradient boosting with lagged features: uses earlier values of the series as input features for a tree model.
  • Baselines:
    • Majority class: always predict the most common class.
    • Mean prediction: always predict the average value.
    • Simple rule: use a basic rule of thumb.
  • Splitting:
    • Hold-out split: set aside a fixed share of the data for testing, such as 80/20.
    • Stratified split: keep the class proportions the same in each part, for imbalanced classes.
    • Time-ordered split: train on earlier data and test on later data, for temporal data.
    • Group split: keep related rows together in the same part.
  • Cross-validation:
    • Stratified k-fold (k = 5 or 10): rotate which fold is held out, keeping class proportions in each fold.
    • Repeated cross-validation: repeat the process with different splits, for small datasets.
  • Model selection trade-offs:
    • Interpretability vs accuracy: simpler models are easier to explain, complex ones may score higher.
    • Training cost: time and computing power needed.
    • Data size: some models need a lot of data, others work with little.
    • Fit with data type: match the model to numeric, categorical, text or time-based data.

Standards

  • The test set is touched exactly once, at the very end.
  • Splits are stratified or grouped wherever the data requires it.
  • A baseline model is reported so improvements are meaningful.
  • Random seeds are set and recorded.
  • Choice of approach is justified in writing (why these models and not others).

Deliverables: Modeling plan, baseline result, reproducible train/validation/test split.

7. Model Training and Evaluation

Model training and evaluation is the step where you fit the candidate models to the training data, tune them, and measure how well they will perform on data they have not seen. Every candidate goes through the same preprocessing and the same validation, so the scores can be compared fairly with the baseline from Step 6. The held-out test set is used once, at the end, for the final chosen model.

Training and evaluation helps you to:

  • Compare models fairly: use cross-validation so that each candidate is scored in the same way.
  • Tune hyperparameters: adjust the model's settings within cross-validation, so tuning does not leak information from the test set.
  • Diagnose overfitting and underfitting: compare training and validation scores to see whether the model memorises the data or is too simple.
  • Estimate real-world performance: evaluate the final model once on the test set for an honest estimate.
  • Understand mistakes: analyse the errors to see where and why the model fails.

Purpose: Train candidates, tune them fairly, and measure how well they will generalise.

Activities

  • Train each candidate model through the same preprocessing pipeline.
  • Evaluate with cross-validation and compare against the baseline.
  • Tune hyperparameters.
  • Diagnose overfitting and underfitting.
  • Evaluate the final chosen model once on the held-out test set.
  • Analyse errors.

Methods

  • Metrics, aligned with the goal:
    • Accuracy: share of predictions that are correct.
    • Precision: of the cases predicted positive, how many really are.
    • Recall: of the real positive cases, how many were found.
    • F1 score: balance of precision and recall (prefer it for imbalanced data).
    • ROC-AUC: how well the model ranks positives above negatives across all thresholds.
    • PR-AUC: the same idea focused on the positive class (prefer it for imbalanced data).
    • Confusion matrix: counts of true and false positives and negatives.
    • Log loss: penalises confident wrong probabilities.
    • MAE / RMSE (regression): average size of the prediction error, with RMSE penalising large errors more.
    • R² (regression): share of the variation the model explains.
    • MAPE (regression): average error as a percentage.
    • Silhouette score / Davies-Bouldin index (clustering): how well separated and compact the clusters are.
  • Hyperparameter tuning
    • Grid search: try every combination in a defined set of values.
    • Randomised search: try random combinations, which is faster over large ranges.
    • Bayesian optimisation: use earlier results to choose the next values to try.
  • Diagnostics:
    • Learning curves: performance as the training set grows.
    • Validation curves: performance as a hyperparameter changes.
    • Train-vs-validation gap: a large gap signals overfitting.
  • Imbalance handling:
    • Class weights: make mistakes on the rare class cost more.
    • Resampling (inside cross-validation folds only): oversample the rare class or undersample the common one.
    • Threshold tuning: move the cut-off that turns a probability into a class.
  • Calibration (if probabilities matter):
    • Reliability curves: compare predicted probabilities with observed rates.
    • Platt or isotonic calibration: adjust predicted probabilities to match reality.
  • Ensembling:
    • Voting: combine the predictions of several models.
    • Stacking: train a model on the outputs of other models.
    • Bagging: average many models trained on random resamples.
    • Boosting: train models in sequence, each correcting the last.
  • Error analysis:
    • Misclassified rows: read through the mistakes to find patterns.
    • Group-level performance: compare results across subgroups.
  • Experiment tracking:
    • Tracking tool or results table: record each run's settings and scores so they can be compared.

Standards

  • Metrics are chosen before looking at results and justified by the goal.
  • Reported scores include variability (mean ± standard deviation across folds).
  • Tuning uses validation data only; the test score is reported once.
  • All models are compared on identical splits and preprocessing.
  • Results are reproducible from code and a fixed seed.
  • Negative results are reported too.

Deliverables: Comparison table of models, tuned final model, test-set results, saved model file, error analysis notes.

8. Interpret Results

Purpose: Turn numbers into understanding and decide what the findings mean for the original problem.

Activities

  • Explain which features drive predictions and in which direction.
  • Compare the findings with your hypotheses from Step 1.
  • Identify where the model works well and where it fails.
  • Check for fairness issues across groups.
  • State limitations and what you would not trust the model to do.
  • Translate results into plain-language conclusions and recommendations.

Methods

  • Global importance (which features matter overall):
    • Coefficients (linear models): the size and sign show each feature's influence.
    • Impurity importance (tree models): how much each feature improves the model's splits.
    • Permutation importance: how much performance drops when a feature is shuffled.
  • Local and model-agnostic explanation:
    • SHAP values: how much each feature pushed a single prediction up or down.
    • LIME: a simple local model that approximates one prediction.
    • Partial dependence plots: the average effect of one feature on the prediction.
    • ICE plots: the same effect shown for individual rows.
  • Error slicing:
    • Subgroup performance: compare results across groups such as sex, class or age band.
  • Confidence:
    • Bootstrap confidence intervals: the range a metric would plausibly take on other samples.
    • Significance tests: check whether the difference between two models is real or noise.
  • Fairness checks:
    • Error rates by group: compare mistakes across groups.
    • Selection rates by group: compare how often each group receives a positive prediction.
  • Correlation vs causation:
    • Explicit statement: say that an association does not prove a cause.

Standards

  • Claims are supported by evidence in the notebook or report.
  • Language does not overstate: "associated with", not "causes", unless the design supports causality.
  • Uncertainty is shown (intervals, variability).
  • Limitations, biases and data caveats are stated honestly.
  • Conclusions answer the question set in Step 1, including whether the success criterion was met.

Deliverables: Interpretation section with explainability plots, a limitations list, and a short list of conclusions and recommendations.

9. Build a Presentation or Report

Purpose: Communicate the work so that an audience can understand, trust and act on it.

Activities

  • Identify the audience and tailor depth accordingly (technical, mixed or executive).
  • Outline the story: problem, data, approach, results, implications.
  • Select the few visualisations that carry the argument.
  • Write, review and edit; remove everything that does not support the story.

Methods

  • Report structure:
    • Abstract / executive summary: the whole project in a few sentences.
    • Introduction and goal: the problem and why it matters.
    • Data description: source, size and key columns.
    • Methodology: EDA, cleaning, features and models.
    • Results: what was found, with figures and tables.
    • Discussion and limitations: what the results mean and where they fall short.
    • Conclusion and next steps: the answer and what to do next.
    • References: sources and tools cited.
    • Appendix: extra detail for readers who want it.
  • Storytelling:
    • Lead with the answer: state the main finding first.
    • Support with evidence: back each claim with a figure or number.
    • End with recommendations: say what the reader should do.
  • Visual design:
    • One message per chart: each figure makes a single point.
    • Direct labels: label lines and bars directly where possible instead of using a legend.
    • Consistency: use the same colours and fonts throughout.
    • Minimal clutter: remove anything that does not help the reader.
  • Formats:
    • Notebook export: share the notebook as an HTML or PDF document.
    • Slide deck: present the story visually.
    • Publishing tools: use a document-publishing tool for polished output.
  • Plain-language summaries:
    • Define technical terms: explain them in everyday words.

Standards

  • The executive summary stands alone (readable in under a minute).
  • Every figure and table is numbered, captioned and referenced in the text.
  • Methods are described precisely enough for someone else to reproduce them.
  • Sources, data licences and tools are cited.
  • Writing is proofread; numbers in the text match the numbers in the code output.

Deliverables: Final report (PDF/HTML) and/or slide deck.

10. Documentation and Code

Purpose: Make the project reproducible, reviewable and a credible portfolio piece.

Activities

  • Organise the repository into a clear structure.
  • Write a README that lets a stranger run the project.
  • Pin dependencies and record how to set up the environment.
  • Comment and document code, and clean the notebooks.
  • Use version control with meaningful commits.
  • Add tests for critical logic.
  • Publish to GitHub (or similar).

Methods

  • Suggested layout:
project/
├── data/raw/  data/processed/
├── notebooks/
├── src/
├── tests/
├── reports/figures/
├── docs/
├── README.md
├── requirements.txt 
└── .gitignore
  • Environment:
    • Isolated environment: keep the project's packages separate from other projects.
    • Pinned versions: record exact package versions so others get the same setup.
  • Code style:
    • Style guide: follow the language's standard style conventions.
    • Formatter: reformat code automatically for consistency.
    • Linter: flag errors and bad practices automatically.
    • Type hints and docstrings: describe what functions expect and return.
  • Notebook hygiene:
    • Restart and run all: confirm the notebook runs top to bottom before committing.
    • Clear stray outputs: remove leftover or sensitive output.
    • Reusable logic: move repeated code into the src/ folder.
  • Version control:
    • Conventional commit messages: use prefixes such as feat:, fix: and docs:.
    • Feature branches: develop each change on its own branch.
    • Pull requests: review changes before merging.
  • Testing:
    • Data and pipeline tests: check shapes, confirm no nulls remain after cleaning, and confirm no train/test overlap.
  • Data validation:
    • Schema checks: confirm columns, types and value ranges match what you expect.
  • Configuration:
    • Environment variables: keep paths and secrets outside the code.
    • No credentials in the repository: never commit passwords or keys.

Standards

  • README states the goal, data source, setup steps, how to reproduce results, and the key findings.
  • A fresh clone plus the documented steps reproduces the results.
  • No secrets, large raw files or personal data are committed.
  • Code is readable: meaningful names, small functions, comments on non-obvious decisions.
  • Licence file included.

Deliverables: Public (or shared) repository, README, environment file, tests, licence.

11. Iterate and Improve

Purpose: Use remaining time on the changes most likely to move the metric or deepen the insight.

Activities

  • Review error analysis and pick the highest-impact improvements.
  • Change one thing at a time and measure the effect.
  • Try additional data, features, models or tuning.
  • Stop when gains are marginal or time is up.

Methods

  • Prioritisation:
    • Impact vs effort matrix: rank ideas by expected gain and cost, and do high-gain, low-effort ones first.
  • Data-centric improvement:
    • Fix label errors: correct wrong target values.
    • Gather more or better data: add rows or improve quality.
    • Add features: try new features before changing algorithms.
  • Model-centric improvement:
    • Better tuning: search hyperparameters more thoroughly.
    • Ensembling: combine several models.
    • Alternative algorithms: try a different model family.
  • Ablation studies:
    • Remove one component at a time: see how much each part contributed.
  • Experiment log:
    • Record every run: note its settings and result.

Standards

  • Each iteration has a hypothesis and a measured outcome.
  • Comparisons use the same validation scheme as before.
  • Improvements are kept only if they exceed noise (check fold variability).
  • The final version is tagged in version control (for example v1.0).

Deliverables: Experiment log, updated results, tagged release.

12. Seek Feedback

Purpose: Catch blind spots you cannot see yourself and strengthen the work before the final presentation.

Activities

  • Choose reviewers: peers, mentors, instructors, domain experts.
  • Share the report and repository with specific questions.
  • Collect, triage and act on feedback.
  • Record what changed as a result.

Methods

  • Review channels:
    • Pull request review: ask a peer to review your code changes.
    • Community groups: share the work with groups such as WiMLDS Nairobi or a study group.
    • Mentor sessions: get one-to-one guidance.
    • Mock presentations: practise in front of friendly critics.
  • Targeted questions:
    • Leakage: "Is there any leakage?"
    • Metric: "Is the metric appropriate?"
    • Story: "Is the story clear?"
  • Feedback triage:
    • Must fix: errors and serious problems.
    • Should fix: clear improvements.
    • Consider later: nice-to-have ideas.
  • Reproducibility test:
    • Run from the README: ask someone to run your project using only the instructions you wrote.

Standards

  • Request feedback early enough to act on it.
  • Respond to every comment, even if only to explain why you did not change something.
  • Credit reviewers in the acknowledgements.

Deliverables: Feedback log and the revisions made.

13. Prepare for Questions

Purpose: Show that you understand your decisions deeply, not just the final numbers.

Activities

  • List likely questions and write short answers.
  • Rehearse explaining each design choice and its alternatives.
  • Prepare to discuss weaknesses openly.
  • Practise out loud, including with someone who will challenge you.

Methods

  • Question bank by theme:
    • Problem: Why this question? Who benefits?
    • Data: Where is it from? What biases exist? How did you handle missing values?
    • Method: Why this model? Why this metric? How did you avoid leakage and overfitting?
    • Results: How reliable is the score? What are the model's failure modes?
    • Ethics: Who could be harmed by errors? What are the fairness concerns?
    • Next steps: What would you do with more time or data?
  • Backup appendix:
    • One slide of technical detail: keep the confusion matrix, hyperparameters and extra plots ready.
  • Structure of answers:
    • Direct answer: respond to the question first.
    • Brief evidence: support it with a number or figure.
    • Honest caveat: state what you are unsure of.

Standards

  • Answers are honest; say "I don't know, but here is how I would find out" when needed.
  • Every number you quote can be traced to code.
  • You can explain every method in plain language.

Deliverables: Q&A cheat-sheet and a backup appendix.

14. Presentation

Purpose: Deliver the story clearly and persuasively to a live audience.

Activities

  • Fit the talk to the time allowed, leaving room for questions.
  • Rehearse with a timer and refine.
  • Prepare the demo or notebook walk-through, and a fallback if it fails.
  • Present and handle Q&A.

Methods

  • Structure (10-15 minute talk):
    1. Hook and problem (1-2 min): why the question matters.
    2. Data and approach (3 min): what you used and how you worked.
    3. Results (3-4 min): the main findings.
    4. Insights and recommendations (2 min): what the findings mean and what to do.
    5. Next steps and close (1 min): what comes next.
  • Slide design:
    • One idea per slide: keep each slide focused.
    • Large readable fonts: make text legible from the back of the room.
    • Minimal text: use short phrases.
    • Visuals over bullet lists: let charts carry the message.
  • Delivery:
    • Speak to the audience: keep eye contact rather than reading the slides.
    • Explain charts out loud: say "the key thing to notice is...".
    • Pace yourself: slow down on key points.
  • Logistics:
    • Test equipment: check the screen, sound and connection beforehand.
    • Backup copy: export the slides to PDF.
    • Repository link: have it ready to share.

Standards

  • Finishes on time.
  • The audience can state the problem, the result and the takeaway afterwards.
  • Visuals are legible from the back of the room.
  • Technical jargon is defined or avoided.
  • A link to the code and report is shared.

Deliverables: Delivered presentation, slide deck, recording if applicable.

15. Reflect

Purpose: Convert the experience into durable learning and a better next project.

Activities

  • Review what went well and what did not.
  • Compare the plan from Step 1 against what actually happened.
  • Identify skills gained and gaps remaining.
  • Write down lessons and set goals for the next project.

Methods

  • Structured retrospective:
    • What went well?
    • What was hard?
    • What would I do differently?
    • What did I learn?
  • Time review:
    • Where the time went: compare planned and actual time per step (data cleaning usually dominates).
  • Skills inventory:
    • Technical skills: tools and methods you practised.
    • Communication skills: writing, presenting and explaining.
    • Project-management skills: planning, prioritising and meeting deadlines.
  • Learning plan:
    • Two or three concrete next steps: for example a course, a harder dataset, or deploying a model.
  • Optional:
    • Share the project: write a blog post or portfolio entry.

Standards

  • Reflection is specific and honest, with examples rather than generalities.
  • Lessons lead to concrete actions.
  • Reflection is written down and kept with the project.

Deliverables: Reflection write-up (a page is enough), next-steps plan.

Master Checklist

  • ☐ Goal stated with a measurable success criterion (1)
  • ☐ Dataset sourced, licensed and documented (2)
  • ☐ EDA complete with written insights, using training data only (3)
  • ☐ Cleaning done in a reproducible pipeline, no leakage (4)
  • ☐ Features engineered and validated (5)
  • ☐ Baseline and modeling plan defined, splits fixed (6)
  • ☐ Models tuned with cross-validation; test set used once (7)
  • ☐ Results interpreted with limitations stated (8)
  • ☐ Report or slides complete (9)
  • ☐ Repository, README, environment and tests in place (10)
  • ☐ Iterations logged (11)
  • ☐ Feedback gathered and acted on (12)
  • ☐ Q&A prepared (13)
  • ☐ Presentation delivered (14)
  • ☐ Reflection written (15)

Common Pitfalls

Pitfall How to avoid it
Data leakage (scaling or imputing before splitting, using the target in features)Use pipelines; fit transformers on training data only
Tuning on the test setKeep a locked test set; tune with cross-validation
Wrong metric (accuracy on imbalanced data)Pick the metric from the goal; report baselines
Skipping the baselineAlways report a trivial baseline first
Overly complex model with no gainPrefer the simplest model that meets the goal
Unreproducible notebookFix seeds, pin versions, run top to bottom
Overclaiming causationUse cautious language; state limitations
Leaving documentation until the endWrite notes and README as you go