Leet School
FULL PROGRAMME

Data Science to AI Engineering

Start with a raw export of orders and payments and finish with a trained model and features built on Claude, behind an API, each one measured, monitored and documented.

  • 6 to 9 months
  • Beginner
  • 10 to 20 hours a week
  • Self-paced, text-based
  • Code checks and AI feedback
$1,000One price, any pace
  • Pay in full$1,000
  • 2 instalments2 × $525
  • 4 instalments4 × $275
Start this programme

Start today. 14-day full refund.

Pace
Yours, 6 to 9 months
Level
Beginner
You build
8 production apps
Lessons
85 text lessons, about 37 hours of reading
Feedback
Code checks every project, then AI

{about this course}

What it is

This programme follows the order in which the work is done in a business. You start with the terminal and Python, then load a shop's orders, payments and refunds into PostgreSQL and pandas and answer real questions from them, checking every answer against a total you trust. You learn the statistics that tell a real change from noise, and you build a weekly report that runs with one command. You do not need to have written code before.

Then you train scikit-learn models that predict which subscribers will cancel, evaluate them honestly, and serve one behind a FastAPI service on a free host. From module 11 you build on Claude, Anthropic's language model, through its API: triage of customer messages with output checked against a schema, evals that score every change, answers grounded in a shop's own policies, and the cost and speed of every answer. The course ends with monitoring and a product of your own.

An orientation and sixteen modules each end in a project written as a brief from a business, eight of them production projects. Every lesson is text, every code example was run, and every project is checked automatically and read by AI. "AI engineering" here means building dependable software around models that others trained. It does not include training neural networks or language models.

{outcomes}

By the end you can

  • Answer business questions from raw exports with SQL on PostgreSQL and with pandas, and check each answer against a known total
  • Say how certain a number is, and tell a real difference from noise with simulation
  • Produce a weekly report with charts and a written summary from one command
  • Train a churn model with scikit-learn, evaluate it on a time-based split free of leakage, and write a model card
  • Serve a model behind a tested FastAPI service with validated input, and deploy it
  • Build features on Claude that return validated structured output, and score them with evals on labelled data
  • Answer questions from a business's own documents with citations, and measure recall, cost and latency
  • Log what a service does and notice when its inputs drift or its accuracy falls

{projects}

What you build

  1. Project 1: Revenue query pack on PostgreSQL

    A PostgreSQL database of customers, orders, payments and refunds with tested queries and views for weekly net revenue, refund and failed charge rates and cohort retention. These are the numbers a founder asks for every month, each checked against a total.

    • PostgreSQL
    • SQL
    • psql
  2. Project 2: Sales workbook from a raw export

    A script that cleans a payment provider's raw export, checks it, and writes a workbook the owner opens in Google Sheets or Excel, with net revenue, refund rate, failed charges and best sellers by week. Any small business that only has its exports could use it.

    • Python
    • pandas
    • openpyxl
    • pytest
  3. Project 3: Automated weekly sales report

    One command that reads the database and writes the Monday report, published as a web page with the week's numbers beside their usual range, three charts and a summary written by code. A team that builds its weekly numbers by hand could run it instead.

    • Python
    • pandas
    • Matplotlib
    • Jinja
    • PostgreSQL
    • GitHub Pages
  4. Project 4: Churn model with a model card

    A scikit-learn model that ranks subscribers by their risk of cancelling in the next 30 days, built on point-in-time features, evaluated on a time-based split against a baseline, with a threshold chosen from costs and a model card. A retention team would use it to decide whom to call.

    • scikit-learn
    • pandas
    • SQL
    • PostgreSQL
  5. Project 5: Churn scoring API

    The churn model behind a deployed FastAPI service with validated input, the model version in every response, an API key, logs, tests, a Dockerfile and a smoke test. The developer of a back office can call it without knowing any machine learning.

    • FastAPI
    • Pydantic
    • scikit-learn
    • pytest
    • Docker
    • Render
  6. Project 6: Customer message triage service with evals

    A service that reads a customer message and returns a validated category, urgency and order reference from Claude, with a labelled test set, scorers in code and evals that run on every change. A support team would use it to route refund and failed payment messages.

    • Claude API
    • Pydantic
    • FastAPI
    • pytest
    • GitHub Actions
  7. Project 7: Support answers from your documents, within a budget

    An endpoint that answers customer questions from a shop's own policies and cites the passages it used. It ships with measured recall, answer quality, cost per answer and p95 latency, and a daily budget enforced in code.

    • Claude API
    • Embeddings
    • PostgreSQL
    • FastAPI
    • NumPy
  8. Project 8: Your own product, live

    A product you specify and build from the earlier parts, with at least one trained model and one Claude feature behind one deployed API, evals, prediction logging and monitoring, a model card, full documentation and a portfolio page.

    • FastAPI
    • PostgreSQL
    • scikit-learn
    • Claude API
    • GitHub Actions
    • Render

{syllabus}

Everything you will read and build

17 modules · 85 lessons · 17 projects

How the school works, the six-step method for solving problems, how to debug and ask for help, and the accounts you will use to learn in public and, later, to call AI services.

  • How Leet School works

    You can describe the loop of a lesson, a week and a project, explain the path of this programme from data to models, and plan your own week of study.

    15 min
  • The six-step method

    You can name the six steps of the method and use them on a problem with no code: a monthly refund rate worked out by hand.

    15 min
  • Debugging and asking for help

    You can follow the debugging loop, write a question that gets a useful answer, and use the AI assistant to learn instead of to copy.

    15 min
  • Your accounts

    You can set up the GitHub, LinkedIn and blog accounts you will use through the course, know which later accounts the programme needs, and keep them all safe.

    15 min
  • Learning in public

    You can write a daily learning log from five prompts, share it, plan a weekly article, and say what must never be posted.

    15 min
  • Weekly check and weekly article

    A few questions answered in your own words, marked at once, and one article about the week.

  • Your learning home

    You publish a profile page on GitHub that says who you are and what you are learning, and you write your first public post.

    Set-up project

{is this for you}

Who Data Science to AI Engineering is for

It suits you if

  • Complete beginners who want a structured route into data and AI work and can give 10 to 20 hours a week
  • Analysts and finance or operations staff who live in spreadsheets and want SQL, Python and machine learning
  • Developers who want the data, modelling and language model side of the job and will move fast through the early modules
  • Founders and freelancers who want reporting, churn prediction and message handling for a business they know

Pick something else if

  • Anyone who wants to train neural networks or language models from scratch, or work on GPUs. This course uses existing models through their APIs
  • Anyone looking for mathematical theory or research training. The statistics here is practical and taught by simulation
  • People whose main goal is building websites and web apps. Software Engineering is the programme for that
  • Anyone who cannot give about 10 hours in most weeks. Start with the Free Track and come back when you can

{before you start}

What you need

  • No coding experience. Module 1 starts with your first command in a terminal
  • A laptop or desktop with Windows, macOS or Linux on which you can install software. 8 GB of memory is enough. A phone or tablet alone is not
  • School arithmetic: percentages, averages and reading a table of numbers
  • Enough English to read technical documentation slowly and carefully
  • From module 11, a Claude Console account with about $5 of credit. Check that Anthropic serves your country before you enrol

{tools}

Tools you will use

  • Python
  • Git and GitHub
  • PostgreSQL
  • SQL
  • pandas
  • NumPy
  • Matplotlib
  • Jinja
  • scikit-learn
  • FastAPI
  • Pydantic
  • pytest
  • Claude API
  • Voyage AI embeddings
  • Docker
  • GitHub Actions
  • Render

{faq}

Questions about this course

Something else? Ask us directly.

About $5, once. Python, PostgreSQL, every library, GitHub, and the free plans of Render and Neon cost nothing. From module 11 your code calls Claude through Anthropic's API, which is paid to Anthropic by usage. With the small, cheap model the course uses, we estimate about $3.50 of usage for the whole programme, and the smallest purchase of credit is about $5. Embeddings come from Voyage AI's free allowance, and every project accepts a free method in their place.

Start Data Science to AI Engineering today.

$1,000. No application. Change your mind within 14 days for a full refund.