Module 01
SQL and the shape of real data
First, and assessed hardest. Everything downstream assumes you can get the data out correctly, and most people who think they know SQL know four of its seven useful parts.
The relational model
- Tables, rows, columns, keys — and why a spreadsheet is not a relational model
- Primary and foreign keys; what referential integrity buys you
- Normalisation to third normal form, and when denormalising is the right call
- Data types that matter in practice: integers, decimals vs floats for money, dates, text
Querying, and the order the database actually works in
- SELECT, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT
- Logical order of evaluation: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY
- Why you cannot use a SELECT alias in WHERE, but can in ORDER BY
- DISTINCT, and why it is usually a sign something upstream is wrong
- CASE expressions for conditional logic inside a query
Joins, and what NULL does to each one
- INNER, LEFT, RIGHT, FULL OUTER, CROSS — with the Venn diagrams and then without them
- Self-joins for hierarchies and comparisons within one table
- The LEFT JOIN that quietly became an INNER JOIN because of a WHERE clause on the right table
- NULL semantics: three-valued logic, NULL = NULL, IS NULL, COALESCE, NULLIF
- Anti-joins: NOT IN vs NOT EXISTS vs LEFT JOIN … IS NULL, and why NOT IN breaks on NULLs
- Fan-out: the join that silently multiplies your row count and inflates every SUM after it
Window functions
- OVER, PARTITION BY, ORDER BY inside a window
- ROW_NUMBER, RANK, DENSE_RANK — and which one you actually wanted
- LAG and LEAD for period-on-period comparison
- Running totals and moving averages with frame clauses (ROWS vs RANGE)
- Per-group top-N, the pattern interviewers ask for most often
- FIRST_VALUE, LAST_VALUE, and the frame default that makes LAST_VALUE surprise you
Structuring bigger queries
- Common table expressions, and why a four-level nested subquery is unmaintainable
- Recursive CTEs for hierarchies and date spines
- Correlated vs uncorrelated subqueries, and the performance difference
- Views, and when a view is hiding a problem rather than solving one
Performance, enough to answer "why is this slow"
- Reading a query plan: scans vs seeks, join strategies, estimated vs actual rows
- Indexes: what they cost on write, composite index column order, covering indexes
- Cardinality and selectivity — why an index on a two-value column rarely helps
- Sargable predicates: why wrapping a column in a function defeats its index
The things that quietly produce wrong numbers
- COUNT(*) vs COUNT(column) vs COUNT(DISTINCT column)
- AVG over NULLs, and SUM of an empty set
- GROUP BY on a column you also filtered, and the group that vanished
- Dates, timezones, and month-boundary arithmetic done correctly
- Integer division, and rounding that does not match Finance
Working locally
- DuckDB as a local SQL engine over CSV and Parquet — one binary, no server
- Querying files larger than the laptop's memory
- Excel as a data source, honestly: leading zeros stripped, text coerced to dates, floats truncated on display
Practical work
A messy multi-table dataset with deliberate NULLs, duplicates and a fan-out trap. You produce a set of figures; we compare against the correct answers and work out where the differences came from.
By the end of this module you should be able to
- Write a multi-join aggregate query and defend the row count
- Use window functions without looking them up
- Read a query plan well enough to say why something is slow
- Spot the four aggregation traps above in someone else's query
Module 02
The Python data stack, installed correctly
The version churn in this stack is the reason half the tutorials online now produce different numbers than they did when they were written. Installed correctly, and with the recent breaking changes taught rather than tripped over.
Environments
- Why a global Python install becomes unusable within a term
- Environments with uv or miniforge, and the conda-forge toolchain you meet in restricted enterprise environments
- Lockfiles, pinned versions and reproducible installs
- Jupyter, JupyterLab and the editor question — notebook for exploring, module for keeping
NumPy 2.x
- ndarray, dtypes, shape, axis — thinking in arrays rather than loops
- Broadcasting rules, and the shape errors they cause
- Vectorisation, and measuring the difference against a Python loop
- Indexing, slicing, boolean masks, fancy indexing; views vs copies
- NEP 50 scalar promotion: np.float32(3) + 3 now returns float32, not float64. Old code runs without error and returns different numbers
- Members removed or relocated in NumPy 2.0, and the automated migration path
- Floating point: why 0.1 + 0.2 != 0.3, and where that bites in aggregation
pandas 3.x
- Series and DataFrame; index as a first-class object rather than a row number
- Copy-on-Write, now enforced: df[df.a > 0]['b'] = 1 no longer modifies the frame, and SettingWithCopyWarning no longer exists to warn you. Use .loc
- The dedicated string dtype replacing object, and what breaks if your code tests dtype == object
- datetime64[us] as the default resolution; zoneinfo instead of pytz
- Offset aliases: ME, QE, YE — plain M now raises
- pd.concat, because DataFrame.append has been gone since pandas 2.0
- Selection: loc, iloc, boolean masks, query
- Reshaping: pivot, pivot_table, melt, stack, unstack
- merge and join, and reproducing every SQL join in pandas
- groupby: split-apply-combine, agg, transform, and when apply is the slow trap
- Missing data: NaN vs None vs pd.NA, and how each propagates
Getting data in and out
- CSV and its ambiguities: encodings, delimiters, quoting, dtype inference
- Parquet as the default interchange format — typed, compressed, columnar
- Excel files, JSON, and reading straight from a SQL connection
- APIs: requests, pagination, rate limits, and retrying politely
- Web scraping where it is permitted: HTML parsing, and reading robots.txt first
When to reach past pandas
- Polars for a groupby that has become slow
- DuckDB for data larger than memory, queried in SQL from Python
- Chunked reading, and the memory arithmetic that tells you which you need
Practical work
Take a raw export with mixed types, inconsistent dates and duplicate keys, and produce a clean typed Parquet file plus a written note of every decision you made and why.
By the end of this module you should be able to
- Set up a reproducible environment from scratch
- Reshape and merge real data without silently changing it
- Explain what Copy-on-Write changed and write code that respects it
- Choose between pandas, Polars and DuckDB on the basis of size and shape
Module 03
Statistics you will be asked to defend
The module bootcamps skip and interviewers probe. It is also the one place an AI coding assistant will hand you the wrong test with no error message, which is why it comes before the modelling.
Describing data
- Mean, median, mode — and which survives an outlier
- Variance, standard deviation, interquartile range
- Skew and kurtosis in plain terms; what a long tail does to an average
- Distributions: normal, binomial, Poisson, uniform, log-normal
- "Normal" as an assumption you check, not a fact you assume
From sample to population
- Populations, samples, and sampling frames
- Sampling bias, survivorship bias, and non-response
- The sampling distribution, and why it is not the data distribution
- Standard error, and the central limit theorem stated carefully
- Confidence intervals as interval estimates
- The specific wrong sentence — "95% chance the true value is in here" — that ends an interview
Hypothesis testing
- Null and alternative hypotheses; one- and two-tailed tests
- What a p-value measures, and the four things people wrongly think it measures
- Significance level, Type I and Type II error, statistical power
- t-tests, chi-square, ANOVA — and choosing by the shape of your question
- Non-parametric alternatives when the assumptions fail
- Multiple comparisons: test twenty variants and one comes back significant for free
- Bonferroni and false discovery rate corrections
- Effect size, and why statistical significance is not importance
Experiments
- A/B test design; randomisation and what it protects you from
- Power analysis before the test, not after it disappoints you
- Minimum detectable effect, and choosing a sample size honestly
- Peeking, and why stopping when it looks good invalidates the result
- Novelty effects and seasonality
Relationships and traps
- Covariance and correlation; Pearson vs Spearman
- Correlation, causation and confounding
- Simpson's paradox, worked through on real reversed data
- Regression to the mean, and the interventions that appear to work because of it
- Bootstrapping as the escape hatch when no closed-form interval exists
Regression with inference
- Ordinary least squares, and what the coefficients mean
- Standard errors, t-statistics, p-values on coefficients, R² and adjusted R²
- Assumptions: linearity, independence, homoscedasticity, normal residuals
- Reading a residual plot
- Multicollinearity and the variance inflation factor
- statsmodels for inference, as distinct from scikit-learn's prediction-only view
Practical work
You are handed the results of an A/B test that appears to show a win. Decide whether it does, and defend the decision out loud against questions.
By the end of this module you should be able to
- State what a p-value and a confidence interval do and do not mean
- Choose and justify a test for a given question
- Design an experiment with the sample size worked out in advance
- Recognise Simpson's paradox and multiple-comparison inflation in someone else's analysis
Module 04
Exploratory analysis and honest visualisation
The half of the job that happens before any model, and the half that decides whether anybody believes the model afterwards.
The EDA loop
- Shape, types, ranges, missingness, distributions, relationships — in that order
- Univariate, then bivariate, then multivariate
- Profiling a dataset you have never seen in under an hour
- Writing down what you expected before you look
Data quality
- Missing data: MCAR, MAR, MNAR — and why the mechanism decides the fix
- Why mean-imputation is usually the wrong reflex
- Telling an outlier from a data-entry error from the interesting finding
- Duplicates, near-duplicates and fuzzy matching
- Inconsistent categories, whitespace, casing, and the city spelled six ways
- Type coercion damage, and recovering what you can
Plotting
- matplotlib's explicit object API (fig, ax) rather than the pylab state machine
- Figures, axes, subplots, and saving at a usable resolution
- seaborn for statistical plots: distributions, categorical, relational, regression
- Choosing a chart from the question rather than from what looks impressive
- Histograms and bin width; box plots and what they hide; violin and strip plots
- Scatter, hexbin and density for overplotted data
- Small multiples instead of one crowded chart
How charts lie
- Truncated axes, and when truncation is legitimate
- Dual axes, and why they can manufacture a correlation
- Pie charts with nine slices; area encoding radius instead of area
- Colour scales that imply an order that is not there
- Cherry-picked ranges and misleading aggregation
Communicating it
- Colour that survives colour-blindness and a monochrome printout
- Annotation, direct labelling, and removing the legend
- Writing the two-sentence finding that goes above the chart
- One chart, one message
Practical work
A dataset with three planted problems and one genuine finding. Produce a one-page summary that identifies all four.
By the end of this module you should be able to
- Profile an unfamiliar dataset methodically
- Choose an imputation strategy and justify it from the missingness mechanism
- Build publication-quality figures with matplotlib and seaborn
- Identify the common ways a chart misleads, including in your own work
Module 05
Supervised learning: fit, fail, diagnose
Organised around the fact that your first model overfits. The skill being taught is diagnosis, not model selection — anyone can call .fit().
The discipline
- Train, validation and test; not touching test until the end
- Cross-validation: k-fold, stratified, grouped, time-aware
- Nested cross-validation when you are also tuning
- Baselines first: the majority class, the mean, last week's value
Leakage
- The single most common reason a student's model scores 0.99 and then dies
- Target leakage: a feature that encodes the answer
- Temporal leakage: using the future to predict the past
- Preprocessing leakage: fitting the scaler or the encoder before the split
- Group leakage: the same customer in both train and test
- How to find it — a suspiciously good score is a symptom, not a success
Models, in the order they should be tried
- Linear regression; logistic regression for classification
- Regularisation: L1 and L2, what each does to coefficients, and why
- k-nearest neighbours, and why scaling decides its answer
- Decision trees: splitting criteria, depth, and how they overfit
- Random forests: bagging, feature subsampling, out-of-bag error
- Gradient boosting: XGBoost, LightGBM, CatBoost — and the parameters that matter
- Support vector machines and the kernel trick, in outline
- Our position, stated as ours: gradient-boosted trees are the default you have to beat
Diagnosis
- Bias and variance, and reading them off a learning curve
- The train/validation gap as the overfit signal
- Validation curves against a single hyperparameter
- Residual analysis for regression; error analysis by segment for classification
- Looking at the examples you got wrong, one by one
Getting the evaluation right
- Accuracy is useless at a 2% positive rate
- Confusion matrix, precision, recall, F1, specificity
- ROC-AUC vs PR-AUC, and which to trust on imbalanced data
- Choosing an operating threshold from a business cost rather than from 0.5
- Regression metrics: MAE, RMSE, MAPE and its divide-by-zero problem, R²
- Probability calibration — why "the model said 0.8" usually does not mean 80%
- Reliability diagrams, Platt scaling, isotonic regression
Features
- Scaling and normalisation, and which models care
- Categoricals: one-hot, ordinal, target encoding and its leakage risk
- High-cardinality categoricals without exploding the feature space
- Dates into features: parts, cycles, elapsed time, lags
- Interactions and polynomial terms
- Pipeline and ColumnTransformer, so preprocessing is fitted inside each fold
Tuning, and the second-order trap
- Grid search, random search, and successive halving
- Bayesian optimisation in outline
- Overfitting the validation set by searching it too hard
- Class imbalance: class weights, resampling, and being honest about what SMOTE did
Explaining a model
- Coefficients and odds ratios for linear models
- Impurity vs permutation feature importance, and why the first misleads
- Partial dependence and individual conditional expectation
- SHAP values: what they mean and what they do not
- Explaining a prediction to somebody who will act on it
Practical work
A dataset with leakage planted in it. Build a model, notice the score is too good, find the leak, and report the honest number.
By the end of this module you should be able to
- Build a leak-free pipeline with preprocessing inside cross-validation
- Diagnose overfitting from curves rather than guessing
- Choose metrics and a threshold that match the actual decision
- Explain a model's behaviour to a non-technical stakeholder
Module 06
Unsupervised learning and time series
Two areas where the method will happily give you an answer whether or not there is one there, so most of the work is deciding whether to believe it.
Clustering
- k-means, and its unstated assumptions: spherical, comparable variance, k known
- Choosing k honestly — elbow, silhouette, gap statistic, and their disagreement
- Why scaling changes the answer entirely
- Hierarchical clustering and reading a dendrogram
- DBSCAN for non-convex shapes and noise; eps and min_samples
- Gaussian mixture models as soft clustering
- Cluster validity with no ground truth, and profiling clusters into a description
Dimensionality reduction
- The curse of dimensionality, concretely
- PCA as a rotation: eigenvectors, explained variance, loadings
- Choosing the number of components; what a component actually means
- When PCA is the wrong tool
- t-SNE and UMAP for visualisation only — distances and cluster sizes in those plots do not mean what they appear to mean
- Perplexity and n_neighbors, and how much the picture changes with them
Association and anomaly
- Market basket analysis: support, confidence, lift
- Anomaly detection: isolation forest, local outlier factor, one-class SVM
- The base-rate problem — a 99% accurate detector on a 0.1% event
Time series
- Trend, seasonality, cyclicality and noise; additive vs multiplicative decomposition
- Stationarity, differencing, and the augmented Dickey-Fuller test
- Autocorrelation and partial autocorrelation, and reading ACF/PACF plots
- Why a random train/test split on time series is leakage
- Backtesting with expanding and rolling windows
- Naive and seasonal-naive baselines, which beat most elaborate models and must be reported alongside them
- Exponential smoothing and Holt-Winters
- ARIMA and SARIMA: what the orders mean and how to choose them
- Prophet and gradient boosting on lag features as practical alternatives
- Forecast intervals, and why they widen
Practical work
Segment a customer dataset, then defend the number of segments and describe each one in language a marketing manager would use.
By the end of this module you should be able to
- Cluster data and justify k rather than asserting it
- Use PCA and read what the components mean
- Backtest a forecast correctly and beat a seasonal-naive baseline, or admit you did not
- Produce a forecast with an interval and explain the widening
Module 07
Deep learning with PyTorch
Enough to build, train and debug a network, and enough judgement to know when not to. PyTorch is our teaching choice; we do not prop that up with a market-share figure.
Foundations
- Tensors, devices, dtypes; the shape errors that account for most of the debugging
- Autograd: the computation graph, backward, and gradient accumulation
- Writing one training loop by hand before touching any abstraction
- nn.Module, optimiser, loss, DataLoader — the shape of every PyTorch script you will read
- Datasets, transforms, batching and shuffling
Training that works
- Activations: ReLU and its relatives, and where sigmoid still belongs
- Loss functions matched to the task
- Optimisers: SGD, momentum, Adam, AdamW
- Learning rate as the hyperparameter that matters most; schedules and warmup
- Weight initialisation, batch and layer normalisation
- Regularisation: dropout, weight decay, early stopping, augmentation
- Reading a divergent loss curve, and the usual causes
- Reproducibility: seeds, and the parts that stay non-deterministic anyway
The head-to-head
- Run a gradient-boosted tree and a neural approach on more than one tabular dataset
- Report both accuracies, plus training time, inference latency, and the hardware each needs
- We do not tell you the result in advance. Measuring it is the exercise, and stating an outcome before the experiment is the habit module 3 exists to kill
Architectures
- Convolutional networks: filters, stride, padding, pooling
- Transfer learning — fine-tune a pretrained backbone, never train from scratch on two thousand images
- Freezing layers, discriminative learning rates
- Sequence models in outline: RNN, LSTM and why attention replaced them
- The transformer block: self-attention, multi-head attention, positional encoding
- Embeddings, as the bridge into module 8
Practicalities
- GPU realities on a student budget: free tiers, batch size, mixed precision
- What will not fit, and how to tell before you start
- Checkpointing and resuming
- Keras 3 as a multi-backend API over JAX, TensorFlow and PyTorch
- Reading older TensorFlow code: tf.Session and tf.placeholder were demoted to tf.compat.v1 in TensorFlow 2.0, not removed, and still run
Practical work
Fine-tune an image classifier on a small dataset you assemble yourself, and report where it fails rather than only where it succeeds.
By the end of this module you should be able to
- Write and debug a PyTorch training loop from scratch
- Fine-tune a pretrained model on a small dataset
- Diagnose a training run from its loss curves
- Decide between a tree ensemble and a network on evidence you gathered
Module 08
LLMs as a data scientist's tool, not a job title
Deliberately provider-agnostic. You will learn to use language models on messy real data and — more importantly — to measure whether what they gave you is right.
How they behave
- Tokens, context windows, and what a token limit costs you in practice
- Temperature, top-p, and determinism you cannot fully have
- Why the model is fluently and confidently wrong, and what that means for a pipeline
- System and user roles; message structure
Using one inside a pipeline
- The API pattern: request, response, retries, timeouts, backoff
- Structured output against a JSON schema — what makes a language model usable inside a data pipeline at all
- Batching, concurrency and rate limits
- Caching, idempotency, and not paying twice for the same row
- Failure handling when the model returns something unparseable
The boring eighty per cent, which is the useful part
- Classifying free-text survey responses
- Extracting structured fields from messy PDFs and emails
- Normalising inconsistent product, company and city names
- Summarising at scale, and where summarisation quietly loses the point
- Building a hand-labelled gold set FIRST, so accuracy is a measured number rather than an impression
Embeddings and retrieval
- What an embedding is; cosine similarity
- Vector stores and approximate nearest neighbour search
- Chunking strategy, overlap, and why retrieval quality dominates generation quality
- Hybrid search: combining keyword and vector retrieval
- Re-ranking
- One small retrieval system built end to end so the shape is understood
Evaluation
- Building an eval set that reflects the real distribution
- LLM-as-judge, and its known biases: position, verbosity, self-preference
- Automated hallucination and groundedness checks
- Regression testing a prompt when the model version changes underneath you
- When fine-tuning is the answer and when it is not — usually it is not; usually the fix is better retrieval or a better prompt
Cost, latency and privacy
- Cost and latency arithmetic per thousand records — the calculation that decides whether the approach ships at all
- Choosing a smaller model deliberately
- Customer names, phone numbers and email addresses cannot be pasted into a third-party API. Worked through on the kind of enquiry data an institute holds
- Redaction and pseudonymisation before a call
- Using AI coding assistants deliberately: fast at pandas, unreliable at statistics, which is why module 3 comes first
Practical work
Classify a few hundred real free-text responses with a language model, against a gold set you labelled by hand first. Report the accuracy and the cost per thousand rows.
By the end of this module you should be able to
- Get reliable structured output out of a language model
- Build and evaluate a small retrieval system
- Measure a model's accuracy on your own task rather than trusting a demo
- Work out whether an approach is affordable before building it
Module 09
Shipping: notebook to something someone else can run
The difference between an analysis and a deliverable. Most of what separates a student project from a working one is in this module.
Version control
- git: commits, branches, merges, and a history somebody can read
- A repository someone can clone and run
- .gitignore for data, secrets and notebook output
- Pull requests and review, even on your own work
Structure
- Getting logic out of the notebook into importable modules
- Notebook as a thin presentation layer over tested code
- Project layout, configuration, and secrets that are not in the repository
- Command-line entry points
Reproducibility
- Lockfiles and pinned versions
- Seeds set everywhere that has randomness
- Data versioning, and recording where a dataset came from
- Model serialisation, and the version-mismatch trap: a pickle written under one scikit-learn and loaded under another
Testing data and code
- pytest over transformation functions
- Schema and range checks on incoming data
- Testing the pipeline, not just the model
- What to assert about a model: not accuracy, but shape, range and monotonicity
Serving
- Experiment tracking, or plain structured files done consistently
- A FastAPI prediction endpoint: request validation, response schema, error handling
- Streamlit or Gradio for something a stakeholder can click during a review
- Docker to the level of "it runs on the other machine"
- Batch scoring on a schedule
After it is live
- Logging predictions and inputs
- Data drift and concept drift — the model decays quietly and nobody files a ticket
- Monitoring, alerting, and deciding a retraining trigger in advance
- Writing the model's limitations down, in the repo, honestly
Practical work
Take your own module 5 model and ship it: repository, tests, API, container, and a README somebody else can follow without asking you anything.
By the end of this module you should be able to
- Turn a notebook into a repository someone else can run
- Test data assumptions as well as code
- Serve a model behind an API and containerise it
- Plan for drift before deployment rather than after
Module 10
Capstone and interview readiness
A project on data you sourced yourself, and the practice at defending it that decides how the interview goes.
The project
- Sourcing or scraping your own data, and why that alone sets the project apart
- Framing the problem with a stakeholder before writing code
- Agreeing the metric in advance, and what happens when you do not
- Scoping to something finishable
- We do not build capstones on Titanic or Iris. Both are teaching sets — small, clean, and solved thousands of times over — so a project built on one shows you followed a tutorial. Boston Housing we do not use at all: scikit-learn deprecated it in 1.0 and removed it in 1.2 on ethical grounds, and its own documentation points at California housing or Ames
The write-up
- Decision, method, result, limitations, and what you would do with another month
- Writing for the person who will act on it, not for the person who built it
- A portfolio README that explains why the choices were made, not what the code does
- Charts that survive being screenshotted into a slide
The defence
- A ten-minute presentation with hostile questions
- "Why this model and not a simpler one?"
- "How do you know it is not overfitting?"
- "What would make this wrong?"
- Saying "I do not know, here is how I would find out" without flinching
Interview practice
- Whiteboard SQL, weighted towards window functions
- Statistics fundamentals, asked the way interviewers ask them
- Case questions: "this metric dropped 8% last Tuesday — what do you check?"
- Guesstimates and structured thinking out loud
- Explaining a gradient boosting model to a manager who does not want to hear the word gradient
- Questions worth asking them, and what the answers tell you
Practical work
The capstone itself, defended in front of the group.
By the end of this module you should be able to
- Take a problem from a vague question to a defended result
- Write up work so somebody can act on it
- Answer hostile technical questions without bluffing
- Walk into an interview with something of your own to talk about