Data Science Programme

Programme Overview

Most data science graduates can train a model. Far fewer have taken a vague business question, turned it into an analytical problem with a baseline, built the pipeline that feeds the model every night, deployed it, watched it drift, and explained the result to a manager who does not care about the algorithm. That gap is what employers notice, and it is what this programme is designed to close.

Over sixteen weeks, at around six hours a week, you work through thirteen sections and an optional pre-course: Python, SQL and statistics; machine learning and the evaluation discipline that keeps it honest; data engineering, deployment and monitoring; cloud platforms; responsible AI; communicating to people who make decisions; language models as one more step in a data workflow; the discovery work that decides what to build; a consulting-style capstone; and a team challenge set by an employer. There are 223 lessons and 114 hands-on labs, every one of which runs in your own JupyterLab workspace on Vecorra, our learning platform, with exercises that check your own answers.

The material is written and taught by the practitioners who do this work for Trillectra AI’s clients. The case studies, from a regional A&E performance review to a credit default model for a UK lender, are modelled on it.

Who the Programme Is For

The programme is designed for:

• Final-year students and recent graduates in data science, computer science, mathematics, statistics, engineering or another quantitative subject, who want to start a career as a data scientist
• Analysts and early-career data scientists who can already produce a notebook and now need the engineering, evaluation and communication discipline to be trusted with a project end to end
• Career changers with a quantitative background who have learned some Python and now need the full workflow, a portfolio and the vocabulary of the job

What you need before you start

You need to be able to write basic Python: functions, loops, lists and dictionaries, reading a file, installing a package. You should be comfortable with a web browser and willing to learn a terminal and Git. Undergraduate-level statistics helps but is taught from the ground up in Section 2.

You do not need prior experience of machine learning, SQL, cloud platforms or software engineering practice. The optional pre-course covers version control, reproducible environments, code review and debugging, and a short diagnostic at the start tells you honestly which of its modules you need and which you can skip.

If you are unsure whether your Python is strong enough, use Talk to us first on the training page and tell us. We would rather talk it through than have you rule yourself out.

How the Programme Is Taught

Everything runs on Vecorra. Each section is split into short modules, and each module into lessons of ten to forty minutes. Most lessons are paired with a lab: a JupyterLab notebook, already set up with the libraries and data it needs, in which you do the thing the lesson just explained. The labs check your answers as you go, so you know whether you have got it before you move on, and a quiz at the end of each module gives you immediate feedback with an explanation for every answer.

A trainer leads a live online session each week, introducing the week’s topic and working through an example with the cohort. Between sessions you work through the lessons at your own pace. An AI tutor is available in every lesson and lab for the first question, and you can message your trainer directly on the platform; the trainer also posts announcements to the cohort, so you never have to hunt through email for what was said.

Each core section ends with a case study for a fictional client, marked against a published rubric: the checkout experiment, the fraud model, the hiring model audit, the board pack. These are the best preparation for the capstone, and you can choose how many to attempt. The datasets throughout are realistic and synthetic, built so that the problems in them are the problems you will meet at work: duplicates, late-arriving records, leakage, class imbalance, a sponsor whose number does not match the data.

You will work in Python with NumPy, pandas and scikit-learn, SQL, statistics by simulation, FastAPI and Docker, PySpark and a Databricks-style lakehouse, Streamlit, and the discipline of Git throughout. Section 10’s model calls run from cached replies, so no API key is needed.

Programme Structure

Duration: 16 weeks Effort: About 100 hours of guided work, around 6 hours a week, plus an optional pre-course of about 10 hours Format: Weekly live online sessions, self-paced lessons and labs on Vecorra, a quiz per module Delivery: Online

The sections

0. Pre-course: Working Like a Data Professional (optional, about 10 hours). Version control, reproducible environments, code that survives review, debugging without guesswork, and a practical in which you inherit a broken repository.
1. Python, SQL & Data Analysis (9 hours). Idiomatic Python and NumPy, data wrangling with pandas, SQL up to window functions, exploratory analysis, data quality and leakage, time-aware analysis.
2. Statistics for Data Science (9 hours). Distributions, sampling and bias, the central limit theorem, confidence intervals and the bootstrap, hypothesis testing, causation and A/B testing, taught simulation-first.
3. Machine Learning Modelling (15 hours). Framing, baselines and validation discipline, feature engineering, the core algorithms and when to use them, pipelines, tuning and class imbalance, interpretability.
4. Model Evaluation (6 hours). Confusion matrices by hand, ROC and precision–recall, calibration, cost-sensitive thresholds, regression metrics, validation splits that do not leak, error analysis by segment.
5. Data Engineering & Pipelines (8 hours). Loading without double-counting, warehouse layers, a tiny orchestrator, backfills, data tests and monitors, and the runbook for 03:00.
6. Model Deployment & Monitoring (13 hours). From notebook to module, batch and real-time serving with FastAPI, containers and CI, shadow and canary rollouts, drift detection with PSI and KS, retraining strategy.
7. Cloud & Production Data Platforms (6 hours). Cloud foundations and cost, object storage and Parquet, PySpark for data pandas cannot hold, the medallion lakehouse, MLflow tracking, choosing a platform for a real team.
8. Responsible AI in Practice (7 hours). Where bias enters, fairness metrics and why they conflict, UK GDPR for practitioners, anonymisation and re-identification, model cards, oversight and governance.
9. Business Communication for Data Scientists (6 hours). Framing the problem, answer-first writing, charts that drive decisions, impact and uncertainty, and a Streamlit decision tool built to answer one question.
10. LLMs for Data Scientists (6 hours). Text as data, when a small classifier beats a language model, structured extraction and labelling with a model, evaluating an LLM step like any other model, working with an assistant without outsourcing the thinking.
11. Discovery & Delivery (6 hours). Stakeholder interviews, from a sentence to a problem statement with a baseline, the business case and the honest no, tickets, estimates and demos, handover to the person who owns it on Monday.
12. Capstone Project (8 hours of guided work). An independent, portfolio-grade consulting engagement for a fictional UK energy supplier.
13. Employer Challenge (6 hours of guided work, plus the team’s own sprint time). A team project on an employer’s brief, through three sprints and five gates to a demonstration, a handover and an individual viva.

A typical cohort spends one week on each section, two weeks each on machine learning and on deployment, and the final three weeks on the employer challenge.

Curriculum

Section 0: Working Like a Data Professional (optional)

The repository: why data work needs version control; branches, commits and history; remotes, merges and conflicts; what never goes in a repo; the pull request and the review. Environments that reproduce: virtual environments and pinning; how a project is laid out; configuration and secrets. Code that survives review: from notebook cell to function; testing data code with pytest; giving and receiving review. Debugging and getting unstuck: reading a traceback; logging and breakpoints; asking a good question. Practical: inherit a broken repository and leave it working, tested and reviewable.

Section 1: Python, SQL & Data Analysis

Python foundations for data work: essentials for analysis; NumPy arrays and vectorisation; reproducible analysis workflows. Data wrangling with pandas: loading and inspecting; cleaning and transforming; grouping and aggregation; merging and reshaping. SQL for data analysis: select, filter and sort; joins and set operations; aggregation; window functions and subqueries. Exploratory data analysis and data quality: the EDA workflow; duplicates and outliers; visualisation principles. Time-aware and trustworthy analysis: time series fundamentals; avoiding data leakage; an end-to-end analysis project. Case study: a regional A&E performance review.

Section 2: Statistics for Data Science

Describing data and distributions: centre, spread and shape; common probability distributions; sampling methods and sources of bias. Estimation and uncertainty: the central limit theorem and standard errors; confidence intervals and how to read them; the bootstrap. Hypothesis testing: fundamentals; t-tests and non-parametric alternatives; chi-squared tests; p-value pitfalls and multiple comparisons. Causation and A/B testing: correlation, causation and confounding; designing A/B tests; power and sample size; peeking, sample-ratio mismatch and guardrails. Case study: the checkout experiment.

Section 3: Machine Learning Modelling

Framing, baselines and validation discipline: framing the prediction problem; start with a baseline; train, validation and test; the classic forms of leakage. Feature engineering: encoding categoricals; scaling and transformations; target encoding and its risks; interactions and cyclical features. Core algorithms: linear models and regularisation; decision trees and random forests; gradient boosting; k-nearest neighbours and naive Bayes. Pipelines, tuning and class imbalance: pipelines and ColumnTransformer; hyperparameter tuning; handling imbalance. Interpretability and modelling challenges: coefficients and permutation importance; SHAP intuition; drift, label noise and messy reality. Case study: a credit default model for a UK lender.

Section 4: Model Evaluation

Classification metrics: reading the confusion matrix; precision, recall and F1; accuracy pitfalls under imbalance. Curves, calibration and thresholds: ROC and AUC; precision–recall curves; calibration and the Brier score; cost-sensitive threshold selection. Regression metrics and validation strategy: MAE against RMSE; MAPE pitfalls and R² misinterpretation; holdout against cross-validation; time-based and grouped splits. Evaluation in practice: error analysis by segment; evaluating rankers and recommenders; honest reporting and champion/challenger. Case study: choosing the fraud model.

Section 5: Data Engineering & Pipelines

For a fictional UK mobile operator whose data arrives the way real data arrives: a snapshot, an event stream and a database, with duplicates, late arrivals and unannounced schema changes. Getting data in: what a pipeline is and why your notebook is not one; files, databases and contracts; incremental loads and idempotency; when the schema changes. Transforming in layers: staging, marts and why layers exist; from landing to marts; tests on data, not only on code. Orchestration: from script to scheduled job; a tiny orchestrator; backfills and late-arriving data. Data quality in production: knowing at 03:05 whether it worked; freshness, volume and distribution; the 03:00 runbook. Practical: the nightly pipeline that feeds the churn model.

Section 6: Model Deployment & Monitoring

From notebook to production code: refactoring into modules; separating training from prediction; serialising models; pinning environments and versioning artefacts. Serving patterns: batch scoring pipelines; a minimal FastAPI scorer; choosing between batch and real-time. Containers, CI and safe rollouts: containers for data scientists; continuous integration for machine learning; shadow, canary and rollback. Monitoring and retraining: data drift, concept drift and performance decay; PSI and KS statistics; schema checks, prediction monitoring and alerting; retraining triggers, gates and feedback loops. Case study: from notebook to production.

Section 7: Cloud & Production Data Platforms

Cloud foundations: elasticity, managed services and the cost model; core AWS building blocks; CSV, Parquet and partitioning; FinOps basics. Distributed computing with Spark: when pandas stops scaling; Spark architecture in plain English; PySpark DataFrames; Spark SQL and window functions; shuffles, caching and small files. The Databricks-style lakehouse: lakehouse, warehouse and lake; bronze, silver and gold; Delta-style tables, time travel and schema enforcement; orchestration and jobs; MLflow tracking and feature stores. Choosing and operating your platform: AWS native, Databricks or Snowflake; security and governance; dev, staging, prod and the cost review. Case study: the streaming service migration.

Section 8: Responsible AI in Practice

Where bias enters: how bias enters the pipeline; building and measuring a biased dataset; proxy variables for protected attributes; feedback loops in deployed systems. Measuring fairness: demographic parity and equalised odds; calibration within groups; why fairness metrics conflict; disaggregated evaluation. Privacy and transparency: UK GDPR for practitioners; anonymisation and re-identification attacks; model cards and datasheets. Oversight, governance and the LLM era: human oversight that works; deployment governance and fairness drift; the new risks that arrive with language models. Case study: the hiring model audit.

Section 9: Business Communication for Data Scientists

Framing the problem: translating business questions into analytical ones; scoping conversations; managing expectations and saying no well. Structuring and writing findings: answer first; executive summaries that get read; READMEs, model cards and documentation habits. Charts that drive decisions: the right chart for the decision; chart crimes; declutter, highlight, annotate. Impact, uncertainty and recommendations: impact in money and time; communicating uncertainty honestly; presenting trade-offs. Dashboards and decision tools: what a dashboard is for; a Streamlit decision tool; defaults, filters and one question. Case study: the board pack.

Section 10: LLMs for Data Scientists

Working from 1,500 support tickets for a fictional UK mobile operator. Text as data: why text is different; from strings to features; meaning as geometry; when a small classifier trained on 300 labelled examples beats a zero-shot language model. LLMs inside a data workflow: a model call is a pipeline step; structured extraction from messy text; labelling with a model, and what it costs you; evaluating an LLM step like any other model. Working with an assistant: what to delegate and what to verify; verify what you delegated; provenance, so you know where every label came from.

Section 11: Discovery & Delivery

Working from a fictional leisure trust whose chief executive wants “AI to stop members leaving”. Finding the real problem: stakeholder interviews; from a sentence to a problem statement a validator can check; data, process and risk discovery. Sizing the value: the business case; cost, value and the honest no. Delivering in a team: tickets, estimates, stand-ups and demos; a plan a machine can check. Handover and adoption: a handover is artefacts, not a meeting; who owns it on Monday. Practical: a full discovery pack for the client.

Section 12: Capstone Project

You act as the consulting data scientist for Meridian Energy, a fictional UK supplier facing rising customer churn after a price rise and unreliable regional demand forecasting. From a realistic data room you frame the business problem, audit the data, build a leakage-safe churn model evaluated against a business cost matrix, improve a regional demand forecast, run a responsible-AI review with a model card, write a deployment and monitoring plan, and present your recommendations to a stakeholder panel, through four milestones with a published marking rubric. The finished workspace becomes the centrepiece of your portfolio and your rehearsal for the certification practical exam.

Section 13: Employer Challenge

Working in a team of three to five, you take on a brief from an employer, with approved or synthetic data, a named sponsor and three sprints: a baseline and a thin end-to-end slice; quality and integration; hardening and handover preparation. You write the statement of work the sponsor signs, measure the baseline from the data and from the people who do the job today, freeze an evaluation set and prove it never changed, log every experiment, and keep a human boundary around anything consequential. You finish with a final evaluation and value case, a demonstration to the employer, a handover pack, and an individual viva in which you explain your own contribution. Every team member must author meaningful code, review a colleague’s work and leave a Git record that shows it.

Learning Outcomes

By the end of the programme you will be able to:

• Take a business problem from the first conversation to a problem statement with a measured baseline, and say honestly when the answer is not to build anything
• Wrangle, query and explore real-world data with Python, pandas and SQL, and spot the quality problems and leakage that would mislead a model
• Reason about uncertainty with simulation, confidence intervals and well-designed experiments, and read an A/B test without fooling yourself
• Build leak-proof scikit-learn pipelines, choose and tune algorithms, handle imbalance and explain what a model is doing
• Evaluate a model against the business cost of its errors, with the right metric, the right split and an honest report
• Build the nightly pipeline that feeds a model, with incremental loads, data tests, a runbook and monitors that tell you at 03:05 whether it worked
• Refactor a notebook into a tested service, containerise it, roll it out safely and detect drift once it is live
• Work productively on a cloud data platform with PySpark and a lakehouse, and explain what a platform costs
• Detect and measure bias, protect personal data under UK GDPR, and write the model card and oversight plan a deployment needs
• Present findings answer-first to decision-makers, in writing, in charts and in a decision tool they can use
• Put a language model to work inside a data workflow where it earns its place, and measure it like any other model
• Work in a team through Git branches, pull requests and code review, and explain your own contribution under questioning

Certification

The programme prepares you for the Vecorra Certified Data Scientist (Associate) certification, code VCA-DSA. It has two parts: a 90-minute theory exam of 50 scenario-based questions drawn from a six-domain blueprint (Python, SQL and data analysis; statistics; ML modelling; model evaluation; business communication; responsible AI), with a pass mark of 70 per cent, and a practical exam completed in a JupyterLab workspace and graded on the artefacts you produce. The certification is valid for three years.

The capstone in Section 12 is designed as a rehearsal for the practical exam, and the module quizzes throughout the programme draw on the same question bank as the theory exam.

What You Leave With

• A capstone repository and write-up you built independently, marked against a published rubric
• A contribution record from an employer challenge, with the employer’s feedback where they consent to share it
• A model you have built a pipeline for, evaluated, deployed and monitored yourself
• A Git history of branches, pull requests and reviews that shows how you work in a team
• Three interview stories you can tell with evidence: a technical decision, a failure you debugged, and a trade-off you negotiated with a stakeholder
• Preparation for the VCA-DSA certification

Fees and How to Enrol

The programme costs £699, including VAT. You can pay it in one payment or as four monthly payments of £174.75; the total is the same either way, and the monthly payments stop automatically after the fourth. Both give you access to the course material for life and to the JupyterLab lab environment for six months from your first payment. Vecorra certification exams are booked separately.

Enrolment is on Vecorra, our training platform. Create an account, choose the programme and pay; your workspace is ready the same day, and your trainer and cohort are on the platform with you. If you are not sure you meet the prerequisites, or you want to talk about timing or funding before you pay, use Talk to us first on the training page and we will reply by email.

About Trillectra AI

Trillectra AI is a UK company that builds Artificial Intelligence systems for organisations, provides Data Science and Generative AI training, and carries out applied research with universities and industry. The people who wrote and teach this programme are the same people who deliver our client work, and the case studies are modelled on it.

Innovate. Educate. Elevate.