## 1. Project Overview & Quickstart (DataTalksClub/05-machine-learning-in-bigquery)

# 05-machine-learning-in-bigquery

Open-source repository DataTalksClub/05-machine-learning-in-bigquery

### Repository Details
- **Repository:** [DataTalksClub/05-machine-learning-in-bigquery](https://github.com/DataTalksClub/05-machine-learning-in-bigquery)
- **Primary Language:** Code

*Note: High-volume repository documentation is actively indexed and synchronized by YakaAI.*

## 2. Official Technical Reference & Guides (DataTalksClub/docs)

## File: README.md

# DataTalks.Club Zoomcamps Notes

This website is currently under development and contains community-contributed notes and resources. Content is being actively added and improved by DataTalks.Club community.

| Course | Duration | Next Cohort | Description | Register | Repository |
|:---|:---:|:---:|:---|:---:|:---:|
| [Machine Learning Zoomcamp](https://github.com/DataTalksClub/machine-learning-zoomcamp) | 16 weeks | September 15, 2025 | ML engineering with deployment focus covering regression, classification, deep learning, and practical projects | [Register](https://courses.datatalks.club/register/ml-zoomcamp/) | [](https://github.com/DataTalksClub/machine-learning-zoomcamp) |
| [AI Dev Tools Zoomcamp](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp) | 6 weeks | November 18, 2025 | Modern AI development tools and workflows for building, testing, and deploying AI applications | [Register](https://courses.datatalks.club/register/ai-dev-tools/) | [](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp) |
| [Data Engineering Zoomcamp](https://github.com/DataTalksClub/data-engineering-zoomcamp) | 9 weeks | January 2026 | Complete data engineering bootcamp covering Docker, SQL, Terraform, GCP, Kafka, and Spark | [Register](https://courses.datatalks.club/register/de-zoomcamp/) | [](https://github.com/DataTalksClub/data-engineering-zoomcamp) |
| [MLOps Zoomcamp](https://github.com/DataTalksClub/mlops-zoomcamp) | 12 weeks | – | Production ML systems & best practices including experiment tracking, model deployment, and monitoring | [Register](https://courses.datatalks.club/register/mlops-zoomcamp/) | [](https://github.com/DataTalksClub/mlops-zoomcamp) |
| [LLM Zoomcamp](https://github.com/DataTalksClub/llm-zoomcamp) | 10 weeks | June 2026 | Large Language Models course covering fine-tuning, RAG systems, and LLM application development | [Register](https://courses.datatalks.club/register/llm-zoomcamp/) | [](https://github.com/DataTalksClub/llm-zoomcamp) |
| [Stock Market Analytics Zoomcamp](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp) | 8 weeks | April 2026 | Financial data analysis and algorithmic trading strategies using Python and modern analytics tools | [Register](https://pythoninvest.com/course) | [](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp) |




## Running Locally

This site is built with [Rustkyll](https://github.com/alexeygrigorev/rustkyll). To run it locally:

### Using Make (recommended)

```bash
make install   # Install dependencies (first time only)
make serve     # Start the development server at http://localhost:4000
```

Available make targets:
- `make help` - Show all available targets
- `make install` - Download the pinned Rustkyll release binary
- `make serve` - Start the Rustkyll development server
- `make serve-livereload` - Start server with live reload
- `make build` - Build the site for production
- `make clean` - Remove generated files and caches

### Manual commands

```bash
mkdir -p .bin
curl -fsSL -o .bin/rustkyll https://github.com/alexeygrigorev/rustkyll/releases/download/v0.4.6/rustkyll-linux-amd64
chmod +x .bin/rustkyll
.bin/rustkyll serve
```

## What's in this Repository

- **Course Notes**: Detailed notes from each course session
- **Resources**: Links to datasets, tools, and materials
- **Tips & Tricks**: Best practices and helpful hints
- **Examples**: Sample projects and implementations

## About DataTalks.Club



DataTalks.Club of the biggest global online community of data enthusiasts with more than 79,000 members. We organize free online events, courses, and other community activities.



All the activity at DataTalks.Club mainly happens on [Slack](https://datatalks.club/slack.html). We post updates there and discuss different aspects of data, career questions, and more.

At DataTalksClub, we organize online events, community activities, and free courses. You can learn more about what we do at [DataTalksClub Community Navigation](https://www.notion.so/DataTalksClub-Community-Navigation-bf070ad27ba44bf6bbc9222082f0e5a8?pvs=21).

## Contributing

We welcome contributions from the community! You can help by:

- **Reporting Issues**: Found an error or broken link? Let us know
- **Improving Content**: Submit pull requests with corrections or enhancements
- **Adding Notes**: Share your own course notes and insights
- **Answering Questions**: Help fellow learners in discussions

### How to Contribute
1. Fork this repository
2. Create a new branch for your changes
3. Make your improvements
4. Submit a pull request with a clear description

## Contact

- **Alexey Grigorev**: [alexey@datatalks.club](mailto:alexey@datatalks.club): Founder and Community Lead
- **Valeriia Kuka**: [valeriia@datatalks.club](mailto:valeriia@datatalks.club): Content Manager

---

## File: _config.yml

# Welcome to Jekyll!
#
# This config file is meant for settings that affect your whole site, values
# which you are expected to set up once and rarely edit after that. If you find
# yourself editing these this file very often, consider using Jekyll's data files
# feature for the data you need to update frequently.
#
# For technical reasons, this file is *NOT* reloaded automatically when you use
# 'jekyll serve'. If you change this file, please restart the server process.

# Theme
theme: just-the-docs

# Site settings
# These are used to personalize your new site. If you look in the HTML files,
# you will see them accessed via {{ site.title }}, {{ site.github_repo }}, and so on.
# You can create any custom variable you would like, and they will be accessible
# in the templates via {{ site.myvariable }}.
title: DataTalks.Club Documentation
baseurl: "" # the subpath of your site, e.g. /blog
url: "https://datatalks.club" # the base hostname & protocol for your site, e.g. http://example.com
permalink: pretty

defaults:
  - scope:
      path: "" # an empty string here means all files in the project
      type: "pages"
    values:
      layout: "default"


exclude:
  # from https://github.com/jekyll/jekyll/blob/master/lib/site_template/_config.yml:
  - .sass-cache/
  - .jekyll-cache/
  - node_modules/
  # specific to the theme website:
  - bin/
  - lib/
  - LICENSE.txt
  - package.json
  - package-lock.json
  - Rakefile
  - README.md
  - CODE_OF_CONDUCT.md
  - docker-compose.yml
  - Dockerfile
  # theme test code
  - fixtures/
  # Project files not meant for site
  - CLAUDE.md
  - AGENTS.md
  - Makefile
  - .bin/
  - .claude/
  - .rustkyll/
  - playwright.config.js
  - playwright-report/
  - test-results/
  - tests/
  - scripts/

# Set a path/url to a logo that will be displayed instead of the title
logo: "assets/images/brand-assets/svg/logo_black.svg"

# Enable or disable the site search
# Supports true (default) or false
search_enabled: true
search:
  # Split pages into sections that can be searched individually
  # Supports 1 - 6, default: 2
  heading_level: 2
  # Maximum amount of previews per search result
  # Default: 3
  previews: 2
  # Maximum amount of words to display before a matched word in the preview
  # Default: 5
  preview_words_before: 3
  # Maximum amount of words to display after a matched word in the preview
  # Default: 10
  preview_words_after: 3
  # Set the search token separator
  # Default: /[\s\-/]+/
  # Example: enable support for hyphenated search words
  tokenizer_separator: /[\s/]+/
  # Display the relative url in search results
  # Supports true (default) or false
  rel_url: true
  # Enable or disable the search button that appears in the bottom right corner of every page
  # Supports true or false (default)
  button: false
  # Focus the search input by pressing `ctrl + focus_shortcut_key` (or `cmd + focus_shortcut_key` on macOS)
  focus_shortcut_key: "k"

# For copy button on code
enable_copy_code_button: true

# By default, consuming the theme as a gem leaves mermaid disabled; it is opt-in
mermaid:
  # Version of mermaid library
  # Pick an available version from https://cdn.jsdelivr.net/npm/mermaid/
  version: "9.1.6"
  # Put any additional configuration, such as setting the theme, in _includes/mermaid_config.js
  # See also docs/ui-components/code
  # To load mermaid from a local library, also use the `path` key to specify the location of the library; e.g.
  # for (v10+):
  # path: "/assets/js/mermaid.esm.min.mjs"
  # for (<v10):
  # path: "/assets/js/mermaid.min.js"
  # Note: copy both `mermaid.esm.min.mjs` (v10+) or `mermaid.min.js` (<v10) and the associated `.map` file from the specified version of `mermaid/dist` to `/assets/js/`.

# Enable or disable heading anchors
heading_anchors: false

# Aux links for the upper right navigation
aux_links:
  "DataTalks.Club":
    - "https://datatalks.club/"

# Makes Aux links open in a new tab. Default is false
aux_links_new_tab: false

# Enable or disable the side/mobile menu globally
# Nav menu can also be selectively enabled or disabled using page variables or the minimal layout
nav_enabled: true

# Sort order for navigation links
# nav_sort: case_insensitive # default, equivalent to nil
nav_sort: case_sensitive # Capital letters sorted before lowercase

# External navigation links
nav_external_links:
  - title: DataTalks.Club
    url: https://datatalks.club/

# Show navigation error report
nav_error_report: true # default is false/nil.

liquid:
  error_mode: strict
  strict_filters: true

# Footer content
# appears at the bottom of every page's main content

# Back to top link
back_to_top: false
back_to_top_text: "Back to top"

footer_content: ''

# Footer last edited timestamp
last_edit_timestamp: true # show or hide edit time - page must have `last_modified_date` defined in the frontmatter
last_edit_time_format: "%b %e %Y at %I:%M %p" # uses ruby's time format: https://ruby-doc.org/stdlib-2.7.0/libdoc/time/rdoc/Time.html

# Footer "Edit this page on GitHub" link text
gh_edit_link: true # show or hide edit this page link
gh_edit_link_text: "Edit this page on GitHub"
gh_edit_repository: "https://github.com/DataTalksClub/docs" # the github URL for your repo
gh_edit_branch: "main" # the branch that your docs is served from
# gh_edit_source: docs # the source that your files originate from
gh_edit_view_mode: "tree" # "tree" or "edit" if you want the user to jump into the editor immediately

# Color scheme currently only supports "dark", "light"/nil (default), or a custom scheme that you define
color_scheme: datatalks

callouts_level: quiet # or loud
callouts:
  highlight:
    color: yellow
  important:
    title: Important
    color: blue
  new:
    title: New
    color: green
  note:
    title: Note
    color: purple
  warning:
    title: Warning
    color: red

# Google Analytics Tracking (optional)
# Supports a CSV of tracking ID strings (eg. "UA-1234567-89,G-1AB234CDE5")
# Note: the main Just the Docs site does *not* use Google Analytics.
# ga_tracking: UA-2709176-10,G-5FG1HLH3XQ
# ga_tracking_anonymize_ip: true # Use GDPR compliant Google Analytics settings (true/nil by default)

plugins:
  - jekyll-seo-tag
  - jekyll-github-metadata
  - jekyll-include-cache
  - jekyll-sitemap

kramdown:
  syntax_highlighter_opts:
    block:
      line_numbers: false

compress_html:
  clippings: all
  comments: all
  endings: all
  startings: []
  blanklines: false
  profile: false
  # ignore:
  #   envs: all

---

## File: AGENTS.md

## Style

- Don't use long dashes. Always put spaces around dashes.
- Don't use bold or italic formatting in markdown files. Use plain text.
- Don't use tables. Use lists instead.

## Links and Images

Internal links and images should use Jekyll's `relative_url` filter to ensure they work correctly regardless of the site's base URL configuration.

### Internal Links

Use the `relative_url` filter for internal links:

```markdown
[Link text]({{ '/path/to/page/' | relative_url }})
```

Example:
```markdown
[platform documentation]({{ '/courses/course-management-platform/' | relative_url }})
```

Do NOT include `/notes/` prefix in the path - `relative_url` handles this automatically.

Incorrect:
```markdown
[Link text](/notes/courses/course-management-platform/)
```

### Images

Use HTML img tags with `relative_url` filter:

```markdown
<img src="{{ '/assets/images/path/to/image.jpg' | relative_url }}" alt="Description" width="80%">
```

Do NOT use markdown image syntax:
```markdown
![Description](/notes/assets/images/path/to/image.jpg)
```

Do NOT include `/notes/` prefix in the path - `relative_url` handles this automatically.

---

## File: CONTRIBUTING.md

# Contributing to DataTalks.Club Zoomcamps Notes and Resources

Thank you for contributing to our notes and resources repository! This document provides guidelines to ensure consistency across the repository.

## Image References

When adding images to your markdown files, please follow these guidelines:

1. Place your images in the appropriate directory under `assets/images/`.
2. When referencing images in markdown files, always include the `/notes` prefix in the path.

**Correct Image Reference:**
```markdown
<img src="{{ '/assets/images/your-path/image.png' | relative_url }}" alt="Image Description" width="80%">
```

**Incorrect Image Reference:**
```markdown
![Image Description](/notes/assets/images/your-path/image.png)
```

This is necessary because the site is configured with a baseurl of `/notes` in the `_config.yml` file. Without this prefix, images will not display correctly when the site is deployed.

## Building and Testing

To build and test the site locally:

```bash
bundle install
bundle exec jekyll serve
```

Visit `http://localhost:4000/notes/` to view the site.

## Pull Requests

1. Fork the repository
2. Create a new branch for your changes
3. Make your changes
4. Test your changes locally
5. Submit a pull request

Thank you for helping improve our documentation!

---

## File: example-structure.md

# Example: How to Use Unique Names with Display Masking

## Method 1: Using display_name (requires custom navigation)

### Module Index File
```yaml
---
title: "de-zoomcamp-module-01-docker-terraform"  # Unique internal ID
display_name: "Module 1: Docker & Terraform"    # What users see
parent: "Data Engineering Zoomcamp"
nav_order: 1
---
```

### FAQ Index File  
```yaml
---
title: "de-zoomcamp-module-01-faq"              # Unique internal ID
display_name: "FAQ"                             # What users see
parent: "de-zoomcamp-module-01-docker-terraform"
nav_order: 2
---
```

### Specific FAQ Files
```yaml
---
title: "de-zoomcamp-module-01-docker-faq"      # Unique internal ID
display_name: "Docker Issues"                  # What users see  
parent: "de-zoomcamp-module-01-faq"
nav_order: 1
---
```

## Method 2: Using Jekyll's built-in hierarchy (recommended)

### Module Index File
```yaml
---
title: "DE Module 1: Docker & Terraform"       # Unique but readable
parent: "Data Engineering Zoomcamp"
nav_order: 1
---
```

### FAQ Index File
```yaml
---
title: "FAQ"                                   # Generic name is OK
parent: "DE Module 1: Docker & Terraform"     # Parent makes it unique
nav_order: 2
---
```

### Specific FAQ Files
```yaml
---
title: "Docker Issues"                         # Descriptive name
parent: "FAQ"                                  # Now unique due to hierarchy
nav_order: 1
---
```

## Method 3: Short Prefix System

### Module Index File
```yaml
---
title: "DE-M1: Docker & Terraform"            # Short prefix
parent: "Data Engineering Zoomcamp"
nav_order: 1
---
```

### FAQ Index File
```yaml
---
title: "FAQ"                                  # Generic is fine
parent: "DE-M1: Docker & Terraform"          # Unique parent
nav_order: 2
---
```

## Method 4: Using nav_title (custom implementation)

### Module Index File
```yaml
---
title: "data-engineering-zoomcamp-module-01-containerization-infrastructure-code"
nav_title: "Module 1: Docker & Terraform"
parent: "Data Engineering Zoomcamp"
nav_order: 1
---
```

This would require modifying the navigation templates to use:
`{{ node.nav_title | default: node.title }}`

---

## File: index.md

---
title: Home
layout: default
nav_order: 1
permalink: /
---

# DataTalks.Club Zoomcamps Notes and Resources
{: .fs-9 }

A comprehensive collection of notes and resources for the DataTalks.Club Zoomcamps. These are our free courses on data engineering, machine learning, and AI.
{: .fs-6 .fw-300 }

---

## File: package.json

{
  "name": "docs-testing",
  "version": "1.0.0",
  "private": true,
  "scripts": {
    "test": "playwright test",
    "test:headed": "playwright test --headed"
  },
  "devDependencies": {
    "@playwright/test": "^1.48.0"
  }
}

---

## File: _includes/lunr/custom-data.json

[Empty file]

---

## File: activities/book-of-the-week.md

---
title: "Book of the Week"
layout: default
nav_order: 4
parent: Activities
---

# Book of the week

Each week we invite a book author to DataTalks.Club to answer questions about their book and the topic it covers.

We don't regularly host this event at the moment. If you know a book author and want to ask them questions, reach out to the DataTalks.Club team. We can invite them.

Archive of past book discussions: [datatalks.club/books.html](https://datatalks.club/books.html)

## How it works

To take part:

- Join the [`#book-of-the-week`](https://app.slack.com/client/T01ATQK62F8/C01H403LKG8) channel in Slack
- Ask as many questions as you'd like
- The book authors answer questions from Monday till Thursday
- On Friday, the authors decide who wins free copies of their book

## Information for authors

Book of the week is an AMA-like event. The community asks authors questions about their books and the topics the books cover.

It's not a live event. The interaction happens asynchronously in Slack, so you can answer questions at a time that is convenient for you.

If you'd like to take part, email [alexey@datatalks.club](mailto:alexey@datatalks.club) or contact the DataTalks.Club team in [Slack](https://datatalks.club/slack.html).

## Community support

DataTalks.Club helps with:

- Promote the event in the DataTalks.Club newsletter
- Announce the event internally in Slack
- Give the community a place to ask questions during the week
- Help select giveaway winners randomly if you prefer not to choose them yourself
- Send a calendar invite to remind you to answer questions

DataTalks.Club has a mailing list with 120k subscribers and an average open rate of 30%. More than 36,000 people can see the book announcement. The Slack community has 90,000 registered members. More than 3,000 people are in the `#book-of-the-week` channel.

On average, authors get 10-20 questions per week.

## Author responsibilities

Authors usually:

- Join Slack at least once per day from Monday to Thursday and answer questions from the community
- Reply in Slack threads so the discussion stays organized
- On Friday, choose who wins free copies of the book
- Provide 5 free ebooks for the community
- Optionally, announce the event on social media

If you don't want to answer some questions, that's fine.

Winners can be selected randomly or based on the most interesting questions. If you want random selection, we can take care of it.

Ebooks are preferred because printed books can be difficult to ship. We already have agreements with Manning, O'Reilly, and Packt. If your book is with one of these publishers, you don't need to arrange anything separately. If your book is with another publisher, we'll be happy to talk to their marketing team.

## Materials we need

Please send:

- Your bio and a picture, or a link to a website where we can take them
- Optionally, social media accounts such as Twitter, LinkedIn, GitHub, and your personal website
- The book cover image and description, or a link to a website where we can take them
- Optionally, links to the publisher's page, book landing page, GitHub repository, or other supplemental materials

## Publishing answers

Your Slack answers will be published on the DataTalks.Club website, so people can read them without logging in to Slack.

If you don't want to publish your answers, let us know. We can also remove or edit specific answers.

You can look at previous discussions in the [book archive](https://datatalks.club/books.html).

## Typical schedule

The usual weekly schedule:

- After the announcement, people start asking questions in Slack
- From Monday to Thursday, come to Slack every day and answer questions
- On Thursday, we'll ask whether you want to select the winners yourself or use random selection
- On Friday, we'll announce the winners

## Feedback from authors

> Hi Alexey. We're only part of the way through the week but I wanted to thank you for inviting me to be part of the DataTalks.Club book of the week. The questions in Slack have been super high quality and I've been getting a lot of positive feedback via LinkedIn as well. I would highly recommend this format to any author. Thanks!
>
> - Mark Ryan, author of "Deep Learning with Structured Data"

---

## File: activities/index.md

---
title: "Activities"
layout: default
nav_order: 5
has_children: true
---

# Activities

We host multiple types of events and activities to help you learn and connect with the data science community.

All upcoming and past events: [datatalks.club/events.html](https://datatalks.club/events.html)

All events are published on our [YouTube channel](https://www.youtube.com/c/datatalksclub). Subscribe to our events on [Luma](https://luma.com/dtc-events) or add [our Google calendar](https://calendar.google.com/calendar/?cid=ZjhxaWRqbnEwamhzY3A4ODA5azFlZ2hzNjBAZ3JvdXAuY2FsZW5kYXIuZ29vZ2xlLmNvbQ) to get notified (calendar subscription works from desktop only).

## Events

Live and recorded event formats:

- [Podcast]({{ '/activities/podcast/' | relative_url }}) - live conversations with data science practitioners, published as podcast episodes
- [Webinars]({{ '/activities/webinars/' | relative_url }}) - technical talks with slides
- [Workshops]({{ '/activities/workshops/' | relative_url }}) - hands-on tutorials about technical topics

## Courses

We also run free online courses called zoomcamps that cover data engineering, machine learning, MLOps, and LLMs. See the [courses section]({{ '/courses/' | relative_url }}) for details. You can also read our [guide to free online courses](https://datatalks.club/blog/guide-to-free-online-courses-at-datatalks-club.html).

## Other activities

Other formats:

- [Book of the Week]({{ '/activities/book-of-the-week/' | relative_url }}) - book authors answer community questions (currently not active)
- [Open-Source Spotlight]({{ '/activities/open-source-spotlight/' | relative_url }}) - short demos of open-source tools by their authors
- [Project of the Week]({{ '/activities/project-of-the-week/' | relative_url }}) - learn-by-doing study groups (currently inactive)

---

## File: activities/open-source-spotlight.md

---
title: "Open-Source Spotlight"
layout: default
nav_order: 5
parent: Activities
---

# Open-source spotlight

We invite open-source authors to record a short demo of their tool. The format is a 15-20 minute video where the author shows what the tool does, followed by a few questions.

- [YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hJ5t5nnjzC0F2zan76Dpsz0) - recordings

If you'd like to show your open-source project, reach out to the DataTalks.Club team.

## Notes for guests

Please don't prepare slides - it's best when we jump into a demo directly.

## Plan

The usual structure:

- Intro, some info about you and about the tool (1-2 minutes)
- The demo
- Questions (3-4 minutes):
    - How many people are working on it?
    - How can people contribute?
    - What are your plans?
- Advice to anyone who's watching this (1 minute)

We should aim at 15-20 minutes for the entire video. If it's longer, then it's more likely that people won't watch it.

After the video, please send me:

- Link to your GitHub repo and documentation
- Everything else you'd like to add to the description

## Preparation tips

Make sure the font size is large enough (the default size is always too small).

- Prepare your browser, terminal, IDE, and anything else you want to share.
- Make the text visible on YouTube on 13" laptop screens without people having to go full screen.

Good examples:

- [Large readable terminal example](https://youtu.be/YwjauyAflmc?t=1707)
- [Large readable notebook example](https://youtu.be/hCAIVe9N0ow?t=65)

Examples where font could be larger:

- [Small terminal text example](https://youtu.be/UVI30Vxzd6c?t=962)
- [Small notebook text example](https://youtu.be/vzoYhI8KTlY?t=425)

---

## File: activities/podcast.md

---
title: "Podcast"
layout: default
nav_order: 1
parent: Activities
---

# Podcast

Live events where we invite data science practitioners, ML engineers, and AI researchers to share their experience. No slides - just a conversation between the guest and the host.

Everyone who joins the live broadcast can ask questions, and we cover them as we go. After the live event, the recording is published as a podcast episode. It is available on Spotify, Apple Podcasts, and other audio platforms. Transcripts and show notes are available on our website.

- [YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hK60wsCyvrEK2RjQsUi4Oa_) - video recordings
- [All episodes](https://datatalks.club/podcast.html) - transcripts and show notes
- [Upcoming events](https://datatalks.club/events.html) - register for live broadcasts

---

## File: activities/project-of-the-week.md

---
title: "Project of the Week"
layout: default
nav_order: 6
parent: Activities
---

# Project of the week

Project of the week is a study group with focus on building things and learning by doing. Every day we have a set of tasks. We finish them together and hold each other accountable.

This activity is currently not active. If you'd like to organize a project of the week, reach out to the DataTalks.Club team.

GitHub repository: [DataTalksClub/project-of-the-week](https://github.com/DataTalksClub/project-of-the-week)

## Taking part

To take part:

- Join the [`#project-of-the-week`](https://app.slack.com/client/T01ATQK62F8/C02BP4FQH36) channel in Slack
- Come to the channel every day to see the tasks
- Learn together
- Share your progress on social media using #ProjectOfTheWeek

[Intro video](https://www.loom.com/share/05b9e07f288f492bb15c4b61cdf6db6c)

## Past projects

Past topics:

- Docker
- Python package
- Getting started with Rust
- Getting started with Julia
- GitHub Actions
- FastAPI
- Recommender systems
- Clustering
- Streamlit frontend for ML

See the full list with details in the [GitHub repository](https://github.com/DataTalksClub/project-of-the-week).

Suggest other ideas in the [`#project-of-the-week`](https://app.slack.com/client/T01ATQK62F8/C02BP4FQH36) channel.

## Running the activity

Instructions for organizers on how to run the project of the week activity.

Video explaining how to make announcements in Slack:

[Slack announcement walkthrough](https://www.loom.com/share/6c20612326ff4d38a2be6f993b0b804b)

Schedule messages at 3:00 PM CET for every day.

## First message template

Include:

- Greeting
- Topic for the week
- Link with details
- Plan for the day

For the first day, the plan usually asks participants to choose a project idea and select a dataset. It also asks them to create a GitHub project and share progress.

## Template for other days

Include:

- Greeting
- Day number
- Topic for the day
- Plan for the day
- Suggested materials
- Link with details

---

## File: activities/webinars.md

---
title: "Webinars"
layout: default
nav_order: 2
parent: Activities
---

# Webinars

Talks with slides cover data engineering, machine learning, MLOps, and AI tools. The main part is the presentation, followed by Q&A. Webinars are typically 60 minutes.

- [YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hKPx7yVcu-9aAJxkCe8y_Ld) - recordings
- [Upcoming and past webinars](https://datatalks.club/events.html)

---

## File: activities/workshops.md

---
title: "Workshops"
layout: default
nav_order: 3
parent: Activities
---

# Workshops

Hands-on sessions have minimal slides and maximum practice. We pick a specific problem and solve it together throughout the session. Workshops are typically 90 minutes, so people learn by doing.

- [YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hKXoe5VllAqUa0nTp0k9Mbl) - recordings
- [Upcoming and past workshops](https://datatalks.club/events.html)

## Notes for instructors

## Format

We use Zoom for workshops.

- We have a Zoom call and broadcast it to our YouTube channel.
- Viewers join on YouTube. They do not join Zoom.
- The Zoom call is only for the host and workshop instructor or instructors.
- We typically start 5 minutes before to check that everything works fine.
- The host starts streaming to YouTube from Zoom.
- We only get the YouTube link after the stream starts.
- After that, the host shares the YouTube link via Luma, Meetup, and other channels.
- The host watches questions from YouTube and brings them up during the session.
- If a question fits the current topic, the host can bring it up right away.
- Otherwise, the host brings it up at the next logical point or at the end of the session.

## Examples

Typically, you prepare the workshop yourself. In some cases, the DataTalks.Club team can prepare it too.

- [How to Evaluate MCP-powered AI Agents Beyond Accuracy using Agent GPA - Josh Reini](https://www.youtube.com/watch?v=oMmJvlNuDZE)
- [From APIs to Warehouses: AI-Assisted Data Ingestion with dlt - Aashish Nair](https://www.youtube.com/watch?v=5eMytPBgmVs)
- [Build a Production-Ready YouTube AI Agent with Temporal - Step-by-Step Tutorial](https://www.youtube.com/watch?v=N1gaI3Qz6vw) - example prepared by the DataTalks.Club team

## Preparation

Before the workshop:

- Download Zoom for your operating system before the workshop.
- Test Zoom in advance. Start a meeting by yourself, then check audio and video.
- If this is your first time using Zoom, test screen sharing too.
- On macOS, Zoom may ask for permissions when you share your screen, so it is better to resolve them before the workshop.
- Make sure the font size is large enough. The default size is always too small.
- Prepare your browser, terminal, IDE, and anything else you want to share.
- Make the text visible on YouTube on a 13" laptop screen without people having to go full screen.

Good examples:

- [Large readable terminal example](https://youtu.be/YwjauyAflmc?t=1707)
- [Large readable notebook example](https://youtu.be/hCAIVe9N0ow?t=65)

Examples where font could be larger:

- [Small terminal text example](https://youtu.be/UVI30Vxzd6c?t=962)
- [Small notebook text example](https://youtu.be/vzoYhI8KTlY?t=425)

---

## File: assets/js/zzzz-search-data.json

---
layout: null
permalink: /assets/js/search-data.json
---
{
{%- assign i = 0 -%}
{%- assign pages_array = "" | split: "" -%}
{%- assign pages_array = pages_array | push: site.html_pages -%}
{%- if site.just_the_docs.collections -%}
  {%- for collection_entry in site.just_the_docs.collections -%}
    {%- assign collection_key = collection_entry[0] -%}
    {%- assign collection_value = collection_entry[1] -%}
    {%- assign collection = site[collection_key] -%}
    {%- if collection_value.search_exclude != true -%}
      {%- assign pages_array = pages_array | push: collection -%}
    {%- endif -%}
  {%- endfor -%}
{%- endif -%}
{%- for pages in pages_array -%}
  {%- for page in pages -%}
    {%- if page.title and page.search_exclude != true -%}
      {%- assign page_content = page.content -%}
      {%- assign heading_level = site.search.heading_level | default: 2 -%}
      {%- for j in (2..heading_level) -%}
        {%- assign tag = '<h' | append: j -%}
        {%- assign closing_tag = '</h' | append: j -%}
        {%- assign page_content = page_content | replace: tag, '<h1' | replace: closing_tag, '</h1' -%}
      {%- endfor -%}
      {%- assign parts = page_content | split: '<h1' -%}
      {%- assign title_found = false -%}
      {%- for part in parts offset: 1 -%}
        {%- assign titleAndContent = part | split: '</h1>' -%}
        {%- assign title = titleAndContent[0] | replace_first: '>', '<h1>' | split: '<h1>' -%}
        {%- assign title = title[1] | strip_html -%}
        {%- assign content = titleAndContent[1] -%}
        {%- assign url = page.url -%}
        {%- if title == page.title and parts[0] == '' -%}
          {%- assign title_found = true -%}
        {%- else -%}
          {%- assign id = titleAndContent[0] -%}
          {%- assign id = id | split: 'id="' -%}
          {%- if id.size == 2 -%}
            {%- assign id = id[1] -%}
            {%- assign id = id | split: '"' -%}
            {%- assign id = id[0] -%}
            {%- capture url -%}{{ url | append: '#' | append: id }}{%- endcapture -%}
          {%- endif -%}
        {%- endif -%}
  {%- unless i == 0 -%},{%- endunless -%}
  "{{ i }}": {
    "doc": {{ page.title | jsonify }},
    "title": {{ title | jsonify }},
    "content": {{ content | replace: '</h', ' . </h' | replace: '<hr', ' . <hr' | replace: '</p', ' . </p' | replace: '<ul', ' . <ul' | replace: '</ul', ' . </ul' | replace: '<ol', ' . <ol' | replace: '</ol', ' . </ol' | replace: '</tr', ' . </tr' | replace: '<li', ' | <li' | replace: '</li', ' | </li' | replace: '</td', ' | </td' | replace: '<td', ' | <td' | replace: '</th', ' | </th' | replace: '<th', ' | <th' | strip_html | remove: 'Table of contents' | normalize_whitespace | replace: '. . .', '.' | replace: '. .', '.' | replace: '| |', '|' | append: ' ' | jsonify }},
    "url": "{{ url | relative_url }}",
    {% include lunr/custom-data.json page=page %}
    "relUrl": "{{ url }}"
  }
        {%- assign i = i | plus: 1 -%}
      {%- endfor -%}
      {%- unless title_found -%}
  {%- unless i == 0 -%},{%- endunless -%}
  "{{ i }}": {
    "doc": {{ page.title | jsonify }},
    "title": {{ page.title | jsonify }},
    "content": {{ parts[0] | replace: '</h', ' . </h' | replace: '<hr', ' . <hr' | replace: '</p', ' . </p' | replace: '<ul', ' . <ul' | replace: '</ul', ' . </ul' | replace: '<ol', ' . <ol' | replace: '</ol', ' . </ol' | replace: '</tr', ' . </tr' | replace: '<li', ' | <li' | replace: '</li', ' | </li' | replace: '</td', ' | </td' | replace: '<td', ' | <td' | replace: '</th', ' | </th' | replace: '<th', ' | <th' | strip_html | remove: 'Table of contents' | normalize_whitespace | replace: '. . .', '.' | replace: '. .', '.' | replace: '| |', '|' | append: ' ' | jsonify }},
    "url": "{{ page.url | relative_url }}",
    {% include lunr/custom-data.json page=page %}
    "relUrl": "{{ page.url }}"
  }
        {%- assign i = i | plus: 1 -%}
      {%- endunless -%}
    {%- endif -%}
  {%- endfor -%}
{%- endfor %}
}

---

## File: courses/index.md

---
title: "Courses"
layout: default
nav_order: 4
has_children: true
has_toc: false
---

# Courses
{: .fs-9 }

Welcome to the DataTalks.Club courses section. Here you'll find comprehensive notes, resources, and guides for all our free zoomcamp courses.
{: .fs-6 .fw-300 }

## Available Courses

Current course pages:

- [Machine Learning Zoomcamp]({{ '/courses/ml-zoomcamp/' | relative_url }}) - Learn ML engineering with deployment focus
- [Data Engineering Zoomcamp]({{ '/courses/data-engineering-zoomcamp/' | relative_url }}) - Complete data engineering bootcamp
- [MLOps Zoomcamp]({{ '/courses/mlops-zoomcamp/' | relative_url }}) - Production ML systems and best practices
- [LLM Zoomcamp]({{ '/courses/llm-zoomcamp/' | relative_url }}) - Build RAG and AI applications with hosted LLMs
- [AI Dev Tools Zoomcamp]({{ '/courses/ai-dev-tools-zoomcamp/' | relative_url }}) - Modern AI development tools and workflows
- [Stock Market Analytics Zoomcamp]({{ '/courses/stock-markets-analytics-zoomcamp/' | relative_url }}) - Financial data analysis, predictive modeling, and trading strategies

## Course Resources

Each course includes:
- Detailed lecture notes
- FAQ and troubleshooting guides
- Assignment instructions
- Prerequisites and setup guides
- Additional learning resources

---

## File: courses/ai-dev-tools-zoomcamp/curriculum.md

---
title: "Curriculum"
layout: default
nav_order: 3
parent: AI Dev Tools Zoomcamp
has_children: false
---

# Curriculum

In the 2026 AI Dev Tools Zoomcamp, you complete five modules plus a final project. You follow one application from specification through development and deployment. You then add operations and agent extensions.

For the canonical curriculum (videos, code, exact homework), see the [GitHub repository](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp).

## Modules

[Module 1: AI-Native Developer Workflow](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp/tree/main/01-ai-native-workflow)

- Compare AI developer tools, turn an idea into a specification and backlog, give agents durable project context, and verify their work independently.

[Module 2: Build and Ship an AI-Assisted Full-Stack App](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp/tree/main/02-end-to-end)

- Write a product specification, build a frontend, define the API with OpenAPI, implement the backend, add persistence, and test the main behavior.

[Module 3 - Test, Containerize, and Deploy](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp/tree/main/03-deployment)

- Add integration tests and move from SQLite to Postgres. Package the application with Docker, run checks in CI, and deploy from the main branch.

[Module 4: DevOps and Observability for AI-Built Apps](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp/tree/main/04-devops)

- Connect metrics, logs, and traces, alert on user impact, investigate incidents with bounded agent access, and run recurring security audits.

[Module 5: Coding Agent Capabilities](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp/tree/main/05-agent-capabilities)

- Extend coding agents with project instructions, MCP, reusable skills, hooks, specialized subagents, plugins, and custom agents. You also document permissions and guardrails.

[Final Project](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp/tree/main/project)

- Build and deploy a full-stack application of your own. Document how you directed and reviewed AI tools, then add the operations, security, and agent-extension work covered in the later modules.

## Homework and project

We score homework during the live cohort and show it on the leaderboard, but it isn't required for the certificate. To earn the certificate, submit a passing final project and complete the required peer reviews during the live cohort. See [Project]({{ '/courses/ai-dev-tools-zoomcamp/project/' | relative_url }}) for the course requirements and the [course platform](https://courses.datatalks.club/ai-dev-tools-2026/) for exact deadlines.

---

## File: courses/ai-dev-tools-zoomcamp/environment-setup.md

---
title: "Environment Setup"
layout: default
nav_order: 4
parent: AI Dev Tools Zoomcamp
has_children: false
---

# Environment Setup

You can follow the course with whichever AI coding tools you prefer. Use this page to choose your tools and development environment.

## AI coding tools

You can use one or more of:

- Chat assistants: ChatGPT, Claude, Gemini, DeepSeek.
- Coding assistants / IDEs: Claude Code, GitHub Copilot, Cursor, Antigravity, Gemini CLI.
- Project bootstrappers: Bolt, Lovable, and similar tools.

Use the tool you're comfortable with because we teach transferable workflows instead of requiring one product.

## Costs

You can complete most of the course with free tiers or low-cost tools. Free tiers have quota limits, and some exercises may use paid model APIs or cloud services. Check current provider pricing before you start. Set budget limits where available, and ask in Slack before paying for a service you're unsure about.

See [Before You Start]({{ '/courses/zoomcamp-logistics/before-you-start/' | relative_url }}) for the shared guidance on cloud costs and account setup.

## Development environment

You can work locally or in GitHub Codespaces. The examples use Git and GitHub, Python with `uv`, Node.js, and Docker. Check each module README for its setup commands and additional requirements.

## Cloud and deployment

Modules 3 and 4 use a deployed application. You can choose a platform such as Render, Fly.io, Railway, or Cloud Run. Keep credentials in environment variables, check current pricing, and remove resources you no longer use.

---

## File: courses/ai-dev-tools-zoomcamp/getting-started.md

---
title: "Getting Started"
layout: default
nav_order: 2
parent: AI Dev Tools Zoomcamp
has_children: false
---

# Getting Started

For the shared onboarding steps, read [Joining a Cohort]({{ '/courses/zoomcamp-logistics/joining/' | relative_url }}) first. It explains registration, account setup, calendar, and newsletter updates. Then use this page to join the AI Dev Tools Zoomcamp resources.

## Star the GitHub repository

[github.com/DataTalksClub/ai-dev-tools-zoomcamp](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp)

We keep all course materials in the repository. Open module folders such as `01-ai-native-workflow` or `03-deployment`, and find cohort-specific homework under `cohorts/2026`.

Create an account on the [2026 course platform](https://courses.datatalks.club/ai-dev-tools-2026/) to see the schedule, submit homework and the final project, and track your score. Registration for email updates and the course-platform account are separate.

## Join the Slack channel

After joining the [DataTalks.Club Slack workspace](https://datatalks.club/slack), find the `#course-ai-dev-tools-zoomcamp` channel for questions and discussion. Before asking, read [Asking Questions]({{ '/courses/zoomcamp-logistics/asking-questions/' | relative_url }}).

## Follow the announcements

Use Telegram for course announcements and YouTube for recordings:

- Join the [course Telegram channel](https://t.me/aidevtoolszoomcamp).
- Subscribe to the [DataTalks.Club YouTube channel](https://www.youtube.com/@DataTalksClub) and check the [course playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hLuyafXPyhTdbF4s_uNhc43).

## Course workflow

Work through each module in this order:

1. Start with the [2026 course launch](https://www.youtube.com/watch?v=58pn873XO04) and Module 1, AI-Native Developer Workflow.
2. Read the README in each module folder for an overview and video links.
3. Watch the lectures (all pre-recorded) and do the homework.
4. Finish with the final project, then complete the peer reviews assigned on the course platform.

See [Environment Setup]({{ '/courses/ai-dev-tools-zoomcamp/environment-setup/' | relative_url }}) for the tools you'll use.

---

## File: courses/ai-dev-tools-zoomcamp/index.md

---
title: "AI Dev Tools Zoomcamp"
layout: default
nav_order: 6
parent: Courses
has_children: true
---

# AI Dev Tools Zoomcamp

AI Dev Tools Zoomcamp is a free, hands-on course on AI-native software engineering. You use AI developer tools to build, test, and deploy software. You also extend and audit it without losing engineering discipline.

The 2026 cohort starts on August 31, 2026. [Register for the free cohort](https://courses.datatalks.club/register/ai-dev-tools/) and use the [2026 course platform](https://courses.datatalks.club/ai-dev-tools-2026/) for the schedule, deadlines, homework submissions, and scores.

## Docs order

Read in this order:

1. [Community Guidelines]({{ '/general/guidelines/' | relative_url }}) - code of conduct, how to ask questions, how to use Slack channels.
2. [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}) - how DataTalks.Club zoomcamps work in general (joining, homework, project, peer review, certification).
3. Read the course-specific pages for the curriculum, environment, project, and resources.
4. The [AI Dev Tools Zoomcamp FAQ](https://datatalks.club/faq/ai-dev-tools-zoomcamp.html) - module-specific and technical questions from previous cohorts.

## Course outcomes

Across five modules, you take an application from an idea to a deployed system:

- Direct coding agents with specifications, project context, and independent verification.
- Build a tested full-stack application from an OpenAPI specification.
- Add integration tests, containers, CI/CD, and a public deployment.
- Add observability, bounded incident response, and security audits.
- Extend coding agents with MCP, skills, hooks, plugins, and specialized agents.

See the [curriculum]({{ '/courses/ai-dev-tools-zoomcamp/curriculum/' | relative_url }}) for module links. The materials also remain available for self-paced study, but graded submissions, peer review, and certificates are available only during a live cohort.

---

## File: courses/ai-dev-tools-zoomcamp/prerequisites.md

---
title: "Prerequisites"
layout: default
nav_order: 1
parent: AI Dev Tools Zoomcamp
has_children: false
---

# Prerequisites

The AI Dev Tools Zoomcamp is approachable for anyone who writes code. You don't need prior experience with AI tools.

For general expectations about zoomcamp time commitment, see [Before You Start]({{ '/courses/zoomcamp-logistics/before-you-start/' | relative_url }}).

## Required skills

Before you start, you should have:

- A basic ability to program in Python, JavaScript, TypeScript, or a similar language.
- Comfort with the command line.
- Git and GitHub basics.

## You do not need

You can start without:

- Prior experience with AI tools, coding assistants, or agents. The course introduces them from the start.
- Prior web development or Docker experience. Familiarity helps, but the course introduces the parts you need.
- A powerful machine. A standard laptop is enough. Hosted models and cloud APIs handle the computationally intensive work.

## Intended audience

The course is for anyone who writes code and wants to use AI tools with an explicit engineering workflow. Software developers, ML and MLOps engineers, and AI engineers can apply the material. It's also relevant to data scientists, data engineers, analysts, and technical students.

This isn't a non-technical AI introduction. We also don't focus on model training, fine-tuning, vector databases, or RAG.

---

## File: courses/ai-dev-tools-zoomcamp/project.md

---
title: "Project"
layout: default
nav_order: 7
parent: AI Dev Tools Zoomcamp
has_children: false
---

# Project

For the shared project rules, see [Final Project (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}). There you can check attempts and deadlines as well as peer review and certification. For the AI Dev Tools Zoomcamp, follow the requirements here.

## Goal

Build and deploy a full-stack application of your own with AI assistance. Apply the course workflow from specification and implementation through testing, deployment, operations, and agent extensions.

## Project requirements

You choose the idea and the stack:

- Choose your own problem and tech stack.
- Include a frontend, backend, API contract, and persistent storage.
- Add automated tests, containerization, CI/CD, and a public deployment.
- Document the specification, architecture, setup, tests, and deployment.
- Explain how you gave AI tools context, delegated work, reviewed generated code, and verified the result.
- Add the agent capabilities, operations, and security work required by the current rubric.

Read the [current project requirements and scoring rubric](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp/tree/main/project) before you start. The course platform contains the exact submission and peer-review deadlines.

## Certificate

To earn the certificate, submit a passing final project and complete the required peer reviews on time during the live cohort. Homework isn't required. See [Certification]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}) for the shared certificate process.

---

## File: courses/ai-dev-tools-zoomcamp/resources.md

---
title: "Resources"
layout: default
nav_order: 8
parent: AI Dev Tools Zoomcamp
has_children: false
---

# Resources

Use these course-specific links for the AI Dev Tools Zoomcamp. For shared rules, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}).

## GitHub repository

[github.com/DataTalksClub/ai-dev-tools-zoomcamp](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp)

Each module has its own folder with a README and video links. Find the homework released for the live cohort under `cohorts/2026`.

## Video lectures

Find all lectures on the [course YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hLuyafXPyhTdbF4s_uNhc43), starting with the [2026 course launch](https://www.youtube.com/watch?v=58pn873XO04).

## Course platform

Use the [2026 course platform](https://courses.datatalks.club/ai-dev-tools-2026/) for the schedule and deadlines. You also submit homework and the project there, track scores, and receive peer-review assignments.

## FAQ

The [AI Dev Tools Zoomcamp FAQ](https://datatalks.club/faq/ai-dev-tools-zoomcamp.html) collects module-specific and technical questions from previous cohorts.

## Slack

Questions and discussion happen in the `#course-ai-dev-tools-zoomcamp` channel on [DataTalks.Club Slack](https://datatalks.club/slack.html). Read [Asking Questions]({{ '/courses/zoomcamp-logistics/asking-questions/' | relative_url }}) first.

## Tools used in the course

The examples draw from these tool categories:

- AI coding tools such as Claude Code, Codex, GitHub Copilot, Cursor, Antigravity, and Gemini CLI.
- [Model Context Protocol](https://modelcontextprotocol.io/), reusable skills, hooks, plugins, and specialized agents.
- GitHub, Python with [uv](https://docs.astral.sh/uv/), Node.js, OpenAPI, FastAPI or Django, Docker, and GitHub Actions.
- OpenTelemetry, Grafana, Prometheus, Loki, and Tempo for observability examples.

---

## File: courses/ai-dev-tools-zoomcamp/whats-new.md

---
title: "What's New"
layout: default
nav_order: 5
parent: AI Dev Tools Zoomcamp
has_children: false
---

# 2026 Cohort

The 2026 cohort starts on August 31, 2026. The course is free, and you can still join after the start date if you can meet the remaining deadlines.

## Join the cohort

Use these links to join and follow the course:

- [Register for course updates](https://courses.datatalks.club/register/ai-dev-tools/).
- Use the [2026 course platform](https://courses.datatalks.club/ai-dev-tools-2026/) for deadlines, submissions, and scores.
- Follow the [course materials](https://github.com/DataTalksClub/ai-dev-tools-zoomcamp) and [YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hLuyafXPyhTdbF4s_uNhc43).
- Join [Slack](https://datatalks.club/slack.html) for questions and the [Telegram channel](https://t.me/aidevtoolszoomcamp) for announcements.

The pre-recorded lectures let you study on your schedule. During a live cohort, you also get shared deadlines and scored homework. You can complete peer review and become eligible for a certificate. See [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}) for the shared rules.

---

## File: courses/course-management-platform/contributing.md

---
title: "Contributing"
layout: default
nav_order: 99
parent: Course Management Platform
has_children: false
---

# Contributing to the Course Management Platform

The course management platform is open source. Contributions are welcome from the community.

## GitHub Repository

The platform code is public:

- [Course Management Platform on GitHub](https://github.com/DataTalksClub/course-management-platform)

## Contributing

## Reporting Issues

If you find a bug or have a suggestion:

1. Check existing issues first
2. [Create a new issue](https://github.com/DataTalksClub/course-management-platform/issues) with:
   - Clear description of the problem
   - Steps to reproduce (for bugs)
   - Expected behavior
   - Screenshots if applicable

## Areas to Contribute

Useful contribution areas include:

- Bug fixes
- Feature suggestions
- Documentation improvements
- User interface improvements
- Performance optimizations

## Communication

For questions about contributing:

- Join the [`#course-management-platform`](https://app.slack.com/client/T01ATQK62F8/C06EKF95CQ3) channel on Slack (see [Slack guide]({{ '/general/slack/' | relative_url }}))
- Discuss your ideas before making major changes

---

## File: courses/course-management-platform/dashboard.md

---
title: "Dashboard"
layout: default
nav_order: 7
parent: Course Management Platform
has_children: false
---

# Course Dashboard

The dashboard provides statistics about course participation and engagement across the entire cohort.



This is not your personal progress page. It shows aggregate statistics for everyone taking the course.

## Participation Statistics

The dashboard tracks how students are engaging with the course material:

## Homework Statistics

A table for each homework assignment showing:

- Number of submissions
- Average time spent on lectures
- Average time spent on homework
- Average total time invested
- Score to pass (minimum correct answers needed)

## Project Statistics

Overall capstone project participation:

- Total project submissions
- Completion rate percentage
- Number of students passed and failed
- Average project score

## Cohort Overview

The cohort overview summarizes registration:

- Total enrollments - Number of students registered for the course

## Access Your Dashboard

Log in to your course platform:

- [ML Zoomcamp 2025 dashboard](https://courses.datatalks.club/ml-zoomcamp-2025/dashboard)
- [Data Engineering Zoomcamp 2026 dashboard](https://courses.datatalks.club/de-zoomcamp-2026/dashboard)
- [MLOps Zoomcamp 2025 dashboard](https://courses.datatalks.club/mlops-zoomcamp-2025/dashboard)

---

## File: courses/course-management-platform/homework.md

---
title: "Homework"
layout: default
nav_order: 2
parent: Course Management Platform
has_children: false
---

# Homework Submission

This page covers the platform UI for submitting homework. For when homework is released, deadline policy, and what should be in your repository, see [Homework]({{ '/courses/zoomcamp-logistics/homework/' | relative_url }}).

## Homework on the platform

Log in to your course platform and open the course page. All homework assignments for the cohort are listed there with their deadlines and your submission status.



Direct links to the platform per cohort:

- [ML Zoomcamp 2025](https://courses.datatalks.club/ml-zoomcamp-2025/)
- [Data Engineering Zoomcamp 2026](https://courses.datatalks.club/de-zoomcamp-2026/)
- [MLOps Zoomcamp 2025](https://courses.datatalks.club/mlops-zoomcamp-2025/)

## Submission form

Each homework has its own submission page.



The form includes:

- Multiple-choice questions - select the correct answer for each question.
- Homework URL - link to your homework notebook or code.
- Time spent on lectures - number of hours spent watching videos.
- Time spent on homework - number of hours spent completing the assignment.
- Learning in public links - links to your social media posts (see [Learning in Public]({{ '/courses/course-management-platform/learning-in-public/' | relative_url }})).
- FAQ contribution - share insights for the [Course FAQ]({{ '/courses/faq/' | relative_url }}).

## After submitting

You receive immediate feedback and points after submitting. The platform shows which questions were correct and your running score.

You can resubmit before the deadline. Only your last submission counts.

## See also

Related pages:

- [Homework]({{ '/courses/zoomcamp-logistics/homework/' | relative_url }}) for general logistics (when released, deadlines, what to put in your repo).
- [Leaderboard]({{ '/courses/course-management-platform/leaderboard/' | relative_url }}) for how points are calculated.

---

## File: courses/course-management-platform/index.md

---
title: "Course Management Platform"
nav_order: 99
has_children: true
parent: Courses
---

# Course Management Platform

The DataTalks.Club course management platform helps you track your progress, submit homework and projects assignments.

[Visit the platform](https://courses.datatalks.club/)



The homepage displays all available DataTalks.Club courses. Click on any course card to access its dedicated platform.

## Available Courses

The platform hosts multiple zoomcamps:

- ML Zoomcamp - Machine Learning Engneering course
- Data Engineering Zoomcamp - Data pipelines and infrastructure
- MLOps Zoomcamp - Advanced ML Engineering course
- LLM Zoomcamp - AI Engineering course

## Getting Help

If you encounter any issues with the platform:

1. Check the [course FAQ]({{ '/courses/faq/' | relative_url }})
2. Ask in [`#course-management-platform`](https://app.slack.com/client/T01ATQK62F8/C06EKF95CQ3) channel on Slack (see [Slack guide]({{ '/general/slack/' | relative_url }}) for more channels)
3. [Create an issue](https://github.com/DataTalksClub/course-management-platform/issues) on GitHub

The platform is open source. For contributions, see the [contributing guide]({{ '/courses/course-management-platform/contributing/' | relative_url }}).

- [GitHub repository](https://github.com/DataTalksClub/course-management-platform)

---

## File: courses/course-management-platform/leaderboard.md

---
title: "Leaderboard"
layout: default
nav_order: 5
parent: Course Management Platform
has_children: false
---

# Leaderboard

This page covers the platform UI for the leaderboard. For what counts toward points and the misuse policy, see [Leaderboard and Learning in Public]({{ '/courses/zoomcamp-logistics/leaderboard/' | relative_url }}).

## Leaderboard page

Each cohort has its own leaderboard page on the platform.



Direct links per cohort:

- [ML Zoomcamp 2025 leaderboard](https://courses.datatalks.club/ml-zoomcamp-2025/leaderboard)
- [Data Engineering Zoomcamp 2026 leaderboard](https://courses.datatalks.club/de-zoomcamp-2026/leaderboard)

## Leaderboard contents

For each participant in the cohort:

- Position and display name (anonymous handles allowed).
- Total points earned.
- Progress bar showing course completion.

## Point values on the platform

The platform awards points as follows:

- Correct homework answers: +1 point each.
- Learning in public links: +1 point each.
- FAQ contributions: +1 point each (after acceptance into the public FAQ).
- Peer reviews completed on time: +3 points each.
- Project completion: variable, based on peer-review scoring.

## See also

Related pages:

- [Leaderboard and Learning in Public]({{ '/courses/zoomcamp-logistics/leaderboard/' | relative_url }}) for what counts and the misuse policy.
- [Learning in Public]({{ '/courses/course-management-platform/learning-in-public/' | relative_url }}) for the platform UI for submitting links.

---

## File: courses/course-management-platform/learning-in-public.md

---
title: "Learning in Public"
layout: default
nav_order: 6
parent: Course Management Platform
has_children: false
---

# Learning in Public

This page covers the platform UI for submitting learning-in-public links. For what counts as a valid post, the misuse policy, and templates, see [Leaderboard and Learning in Public]({{ '/courses/zoomcamp-logistics/leaderboard/' | relative_url }}).

## Submitting links

When you submit homework, a project, or a peer review, the form has a "Learning in public links" section.



Add links to your social media posts about what you learned. Each accepted link earns 1 extra point on the leaderboard.

## Link limits per submission type

The platform accepts these limits:

- Homework submissions: up to 7 links.
- Project submissions: up to 14 links.
- Peer reviews: up to 2 links.

## Reporting misuse

Report links in the course Slack channel if they are not the participant's own posts about the course. Examples include documentation pages, other people's content, and unrelated links. The cohort lead can remove their points and disable their ability to earn learning-in-public points.

For the rules and what counts as misuse, see [Leaderboard and Learning in Public]({{ '/courses/zoomcamp-logistics/leaderboard/' | relative_url }}).

## See also

Related pages:

- [Leaderboard and Learning in Public]({{ '/courses/zoomcamp-logistics/leaderboard/' | relative_url }}) for the rules.
- [Leaderboard]({{ '/courses/course-management-platform/leaderboard/' | relative_url }}) for how points appear.

---

## File: courses/course-management-platform/peer-review.md

---
title: "Peer Review"
layout: default
nav_order: 4
parent: Course Management Platform
has_children: false
---

# Peer Review

This page covers the platform UI for peer review. For the process behind peer review, see [Peer Review]({{ '/courses/zoomcamp-logistics/peer-review/' | relative_url }}). That page covers why peer review exists, how many reviews you do, 404 repos, and tips for writing good reviews.

## Assigned projects

After the project submission deadline, your assigned projects appear on the platform. Open the project page for the cohort and look for "Projects to Review".



If you submitted but do not see assignments yet, give it a day. The cohort lead releases assignments once after the deadline closes.

## Evaluation form

Click on a project card to open the evaluation form.



The form shows the course-specific rubric (criteria, point values per criterion). Score each criterion and add comments.

## Reviewing the project at the right commit

The author submitted a specific commit ID. Review the project as it was at that commit, not the latest version of the repo.

GitHub URL pattern to view a specific commit:

```text
https://github.com/user/repo/tree/COMMIT_ID
```

You can browse the project on GitHub at this URL without downloading anything. If you want to run the code locally, check out the project at the submitted commit ID before running.

## Reproducing the project

Reproducing projects you review (running them locally, deploying them) is good learning when you have time.

Sometimes full reproduction is not possible. You may need cloud credentials you do not have, or the setup may take longer than the review window allows. Use your judgment. You can evaluate all the criteria from reading the code and the README without running it.

## Plagiarism

If you notice plagiarism while reviewing, give the project zero points for everything and note it in the comments. The cohort lead investigates flagged cases.

Self-plagiarism rules:

- You cannot reuse a project from another course without changes.
- If you passed attempt one, you cannot submit the same project for attempt two (you would get double the points).
- If you failed attempt one, you can improve and resubmit for attempt two.

## See also

Related pages:

- [Peer Review (logistics)]({{ '/courses/zoomcamp-logistics/peer-review/' | relative_url }}) for general logistics.
- [Project Submission]({{ '/courses/course-management-platform/projects/' | relative_url }}) for the platform UI when submitting your own project.

---

## File: courses/course-management-platform/projects.md

---
title: "Projects"
layout: default
nav_order: 3
parent: Course Management Platform
has_children: false
---

# Project Submission

This page covers the platform UI for submitting your project. For project structure and logistics, see [Final Project]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}). That page covers attempts, dataset choice, and tech stack flexibility.

[Project submission walkthrough](https://www.loom.com/share/8f99d25893de4fb8aaa95c0395c740b6)

## Project page

Log in to your course platform and open the project page. You will see the active project window, the deadline, and the submission form when it is open.

## Submission form



The form fields:

- GitHub link - URL to your public project repository.
- Commit ID - the specific commit hash for your submission. Use the first seven characters of the commit hash.
- Learning in public links - links to your social media posts about the project (see [Learning in Public]({{ '/courses/course-management-platform/learning-in-public/' | relative_url }})).
- Time spent on project - number of hours invested.
- FAQ contribution - share insights for the [Course FAQ]({{ '/courses/faq/' | relative_url }}).
- Certificate name - name to appear on your certificate.

## Certificate name vs display name

Your certificate name and display name are separate:

- Display name appears on the leaderboard. You can keep it anonymous if you prefer.
- Certificate name is what gets printed on your certificate.

Set your certificate name before submitting. Otherwise you may end up with a placeholder.

## Commit ID and updating it

If you keep committing after submission, update the commit ID in the form. Reviewers should see what you intended them to review. They will look at the repo at the commit ID you submitted, not the latest version.

To check a specific commit on GitHub, use:

```text
https://github.com/user/repo/tree/COMMIT_ID
```

This is what reviewers will see. To run the project locally at that commit, check out the commit ID after fetching the repo.

## Project gallery

After cohorts complete, projects are visible in the platform's project gallery.



Browse past projects for inspiration:

- [ML Zoomcamp 2025 projects](https://courses.datatalks.club/ml-zoomcamp-2025/projects)
- [Data Engineering Zoomcamp 2025 projects](https://courses.datatalks.club/de-zoomcamp-2025/projects)
- [Data Engineering Zoomcamp 2024 projects](https://courses.datatalks.club/de-zoomcamp-2024/projects)

## See also

Related pages:

- [Final Project]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}) for general project logistics (rubric, attempts, dataset, tech stack).
- [Peer Review]({{ '/courses/course-management-platform/peer-review/' | relative_url }}) for the platform UI for reviewing other students' projects.
- [Peer Review (logistics)]({{ '/courses/zoomcamp-logistics/peer-review/' | relative_url }}) for how peer review works overall.

---

## File: courses/data-engineering-zoomcamp/curriculum.md

---
title: "Curriculum"
layout: default
nav_order: 3
parent: Data Engineering Zoomcamp
has_children: false
---

# Curriculum

The Data Engineering Zoomcamp covers six modules over seven weeks plus the final project. Each module has video lectures, reading material, and a homework assignment.

For the canonical curriculum (videos, code, exact homework questions), see the [GitHub repository](https://github.com/DataTalksClub/data-engineering-zoomcamp).

## Modules

[Module 1: Containerization and Infrastructure as Code](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/01-docker-terraform)

- Docker and Postgres.
- Setting up a development environment locally and on GCP.
- Terraform for infrastructure provisioning.
- Module 1 gets two weeks because environment setup can be the trickiest part.

[Module 2: Workflow Orchestration](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/02-workflow-orchestration)

- Workflow orchestration with Kestra.
- Building data pipelines that schedule, retry, and backfill.
- Loading data to Google Cloud Storage and BigQuery.

Data Ingestion with dlt Workshop

- Slotted between modules. Hands-on workshop on the dlt library for ingestion.
- Has its own homework. See [Workshops]({{ '/courses/zoomcamp-logistics/workshops/' | relative_url }}) for the workshop logistics.

[Module 3: Data Warehouse](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/03-data-warehouse)

- BigQuery as a data warehouse.
- Partitioning and clustering for performance.
- Cost optimization.

[Module 4: Analytics Engineering](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/04-analytics-engineering)

- dbt for analytics engineering.
- Building staging, intermediate, and mart models.
- Testing and documentation.
- Connecting BigQuery to a dashboard.

[Module 5: Batch Processing](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/05-batch)

- Apache Spark fundamentals.
- PySpark with the NYC taxi dataset.
- Running on Google Dataproc.

[Module 6: Streaming](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/06-streaming)

- Apache Kafka.
- Stream processing with Kafka and Flink.
- Schema registry and data serialization.

[Final Project](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/projects)

- Three weeks at the end of the cohort.
- Build an end-to-end pipeline of your choice.
- See the [Project page]({{ '/courses/data-engineering-zoomcamp/project/' | relative_url }}).

## Cohort changes

Most modules are stable across cohorts.

Notable past changes:

- 2023: Mage replaced Prefect as the workflow orchestrator.
- 2025: Kestra replaced Mage.
- 2026: New workshop on dlt continues. Some modules use updated tooling.

If a video references a tool you do not see in the current code, check the cohort folder. The [cohorts/2026/](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/cohorts/2026) folder has the current version.

## Pace

A typical week:

- Watch the module videos (3 to 5 hours).
- Work through the code examples (3 to 5 hours).
- Complete the homework (2 to 5 hours).

Plan for 10 to 15 hours per week. Module 1 takes more (two weeks instead of one).

For the final project, plan 2 to 3 weeks of focused work.

---

## File: courses/data-engineering-zoomcamp/environment-setup.md

---
title: "Environment Setup"
layout: default
nav_order: 4
parent: Data Engineering Zoomcamp
has_children: false
---

# Environment Setup

The Data Engineering Zoomcamp uses Docker, Terraform, Google Cloud Platform (GCP), and Python. This page covers the high-level setup decisions. For detailed step-by-step setup, follow the videos in [Module 1](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/01-docker-terraform).

## Runtime environment

You have three options. Pick one and stick with it for the cohort.

Local machine:

- Pros: full control, no time limits, free.
- Cons: setup is the most fiddly. Docker Desktop on Mac and Windows can be slow or finicky.

GitHub Codespaces:

- Pros: pre-configured Linux environment, no local setup.
- Cons: free tier has monthly hour limits. You may run out near the end of the cohort. GitHub Pro increases the quota.

GCP VM (Compute Engine):

- Pros: closest to a real production environment, integrates naturally with the GCS/BigQuery work later in the course.
- Cons: counts against your $300 GCP credits. Remember to stop the VM when not using it.

## Google Cloud Platform

The course uses GCP for storage (GCS), data warehouse (BigQuery), and (optionally) compute (Compute Engine, Dataproc).

New GCP accounts get $300 in free credits. This is enough for the entire course if you stop resources when you do not need them.

Common signup issues:

- Country availability: GCP free trial is not available in every country. Check the [free trial eligibility list](https://cloud.google.com/free/docs/free-cloud-features#country-restrictions).
- Card rejection (`OR_BACR2_34` or `OR_BACR2_44` errors): try a different card. Visa typically works better than Mastercard for some regions. Some prepaid cards do not work.
- Account already used: the $300 credits are one-time per Google account. If you used it before, create a new Google account.

If GCP signup is impossible for you, you can complete the course locally using Postgres and DuckDB. You can also use AWS or Azure. See "Other clouds" below.

## Service account credentials

For Terraform and the workflow tools to access GCP, you need a service account JSON key.

- Create a service account with appropriate roles (BigQuery Admin, Storage Admin, etc.) - the module 1 video walks through this.
- Download the JSON key.
- Set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to the path of the key file.

Never commit the JSON key to a public Git repository. Add it to `.gitignore` before committing.

## Other clouds (AWS, Azure, Oracle)

You can complete the course on AWS or Azure if GCP is not available to you. The videos use GCP, so you will need to translate concepts.

Common equivalents:

- GCS bucket → S3 bucket / Azure Blob.
- BigQuery → Athena, Redshift, Snowflake, or Synapse.
- Dataproc → EMR or Synapse.

There are community Slack channels for participants using alternative clouds:

- `#de-course-aws` for AWS users.

You can complete the project on any cloud regardless of what you used for the modules.

## Operating system notes

Mac (Apple Silicon, M1/M2/M3):

- Docker Desktop sometimes shows "Malware Blocked" warnings on installation. Allow it in System Settings if needed.
- Some images do not have ARM builds. Use `--platform linux/amd64` if you hit "no matching manifest" errors.
- Colima is a lighter alternative to Docker Desktop and works fine for the course.

Windows:

- Use WSL2 with Ubuntu. Native Windows Docker works but WSL2 is what the course videos demonstrate.
- Git Bash works for command-line examples in module 1.

Linux:

- Native installation works without surprises. Make sure to add your user to the `docker` group.

## Python and dependency management

The course recommends `uv` for Python dependency management. It is faster than pip/conda and handles virtual environments cleanly. See the [uv documentation](https://docs.astral.sh/uv/) for installation.

You can also use Anaconda or plain `pip + venv`. The choice does not affect the course content.

## Codespaces budget

If you are using GitHub Codespaces and run into the monthly quota:

- Stop your codespace when you are not actively using it (Codespaces bills by the hour).
- GitHub Pro (paid) increases the free quota.
- Switch to a local setup or a GCP VM for the rest of the cohort.
- Existing code is preserved when a codespace is stopped or paused. You do not lose work.

---

## File: courses/data-engineering-zoomcamp/getting-started.md

---
title: "Getting Started"
layout: default
nav_order: 2
parent: Data Engineering Zoomcamp
has_children: false
---

# Getting Started

For the cross-course onboarding, read [Joining a Cohort]({{ '/courses/zoomcamp-logistics/joining/' | relative_url }}) first. It covers registration, account setup, calendar, and newsletter updates.

This page covers the Data Engineering Zoomcamp specifics.

## Star the GitHub repository

[github.com/DataTalksClub/data-engineering-zoomcamp](https://github.com/DataTalksClub/data-engineering-zoomcamp)

Star the repo so you can find it later and access all course material. See [Resources]({{ '/courses/data-engineering-zoomcamp/resources/' | relative_url }}) for the repo structure.

## Join the DE Slack channel

After joining the [DataTalks.Club Slack workspace](https://datatalks.club/slack), find:

[`#course-data-engineering`](https://app.slack.com/client/T01ATQK62F8/C01FABYF2RG)

This is where DE-specific announcements, homework discussions, project Q+A, and the live-session links go. Use threads when replying.

## Subscribe to DE Telegram (optional, recommended)

[t.me/dezoomcamp](https://t.me/dezoomcamp) - announcement-only channel. Telegram is the most reliable place to catch important updates because Slack is busy.

Telegram announcements are auto-reposted to Slack, so you do not strictly need it.

## Subscribe to YouTube

The [DataTalks.Club YouTube channel](https://www.youtube.com/@DataTalksClub) has pre-recorded module lectures and live session recordings. For all DE playlists, see [Resources]({{ '/courses/data-engineering-zoomcamp/resources/' | relative_url }}).

## Set up your environment

The DE Zoomcamp uses Docker, Terraform, GCP, and Python. See [Environment Setup]({{ '/courses/data-engineering-zoomcamp/environment-setup/' | relative_url }}) for the choices you need to make (local vs Codespaces vs GCP VM, GCP signup, OS-specific notes).

You can start before the cohort begins to get setup out of the way.

## Start Module 1

Begin with [Docker, Postgres, and Terraform](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/01-docker-terraform). Module 1 gets two weeks because environment setup can be challenging.

For what each module covers, see [Curriculum]({{ '/courses/data-engineering-zoomcamp/curriculum/' | relative_url }}).

## Next pages

Useful next pages:

- [Prerequisites]({{ '/courses/data-engineering-zoomcamp/prerequisites/' | relative_url }}) - what you need to know before starting.
- [Curriculum]({{ '/courses/data-engineering-zoomcamp/curriculum/' | relative_url }}) - the modules.
- [Environment Setup]({{ '/courses/data-engineering-zoomcamp/environment-setup/' | relative_url }}) - GCP, Docker, OS notes.
- [Project]({{ '/courses/data-engineering-zoomcamp/project/' | relative_url }}) - the final project rubric.
- [Resources]({{ '/courses/data-engineering-zoomcamp/resources/' | relative_url }}) - all DE-specific links in one place.
- [Q+A]({{ '/courses/data-engineering-zoomcamp/qa/' | relative_url }}) - DE-specific frequently asked questions.
- [Learning in Public]({{ '/courses/zoomcamp-logistics/learning-in-public/' | relative_url }}) - hashtag for DE is `#dezoomcamp`.

---

## File: courses/data-engineering-zoomcamp/index.md

---
title: "Data Engineering Zoomcamp"
layout: default
nav_order: 3
parent: Courses
has_children: true
---

# Data Engineering Zoomcamp 2026

Data Engineering Zoomcamp returns for its 5th edition. It's a free, intensive course designed to take you from data engineering fundamentals to building production-grade data pipelines. It's run by [DataTalks.Club](https://datatalks.club), a community dedicated to AI and Data education.

The course runs for 10 weeks: 7 weeks of modules plus 3 weeks for the final project. You'll learn to build production-grade data pipelines from scratch using industry-standard tools.



See the [GitHub repository](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main) for the full curriculum and detailed module information.

No previous data engineering experience required. Join thousands of students learning data engineering together.

## Docs order

Read in this order:

1. [Community Guidelines]({{ '/general/guidelines/' | relative_url }}) - code of conduct, how to ask questions, how to use Slack channels, how to promote your work.
2. [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}) - how DataTalks.Club zoomcamps work in general (cohort schedule, joining, live sessions, homework, project, peer review, certification). Most of your logistical questions are answered there.
3. The pages in this section - what is specific to the Data Engineering Zoomcamp (curriculum, GCP setup, dataset, project rubric).
4. The [Data Engineering Zoomcamp FAQ](https://datatalks.club/faq/data-engineering-zoomcamp.html) - module-specific and technical questions from previous cohorts.

For platform mechanics (where to click on the submission form, how the leaderboard appears), see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

---

## File: courses/data-engineering-zoomcamp/prerequisites.md

---
title: "Prerequisites"
layout: default
nav_order: 1
parent: Data Engineering Zoomcamp
has_children: false
---

# Prerequisites

The Data Engineering Zoomcamp does not require prior data engineering experience. It does assume basic technical literacy.

For general expectations about zoomcamp time commitment, see [Before You Start]({{ '/courses/zoomcamp-logistics/before-you-start/' | relative_url }}).

## Required skills

You need these basics:

- Command line basics. Comfortable running commands in a terminal (Linux, Mac, Git Bash, or WSL).
- Basic programming concepts. Variables, functions, loops, conditionals.
- Python knowledge. Basic Python or the ability to pick it up quickly. The course uses Python heavily for ingestion scripts.
- SQL fundamentals. SELECT, WHERE, JOIN, GROUP BY. You will write more complex SQL during the course (window functions, CTEs, partitioning queries).
- Git basics. Cloning repositories, making commits, pushing.

If you are weak on any of these, the course is still doable. You will spend extra time on the fundamentals in the first weeks. The course is beginner-friendly for data engineering, not for programming.

## Tools you will install

Install these tools before or during module 1:

- Docker (Docker Desktop on Mac/Windows, Docker Engine on Linux).
- Python (3.10+ recommended).
- Terraform.
- A text editor or IDE (VS Code is the most common, but any IDE works).
- The Google Cloud SDK (`gcloud` CLI).

For the setup choices, see [Environment Setup]({{ '/courses/data-engineering-zoomcamp/environment-setup/' | relative_url }}).

## Time commitment

Plan around this schedule:

- Two weeks for Module 1 (longer to allow for environment setup).
- One week each for modules 2 to 6.
- Two to three weeks for the final project.

Plan for 10 to 15 hours per week. Past cohorts' actual time data is visible on the [2024](https://courses.datatalks.club/de-zoomcamp-2024/dashboard) and [2025](https://courses.datatalks.club/de-zoomcamp-2025/dashboard) dashboards.

## You do not need

You do not need these before starting:

- A degree.
- Prior data engineering jobs.
- Prior cloud experience (you will pick up GCP basics as you go).
- Prior experience with any specific tool the course teaches (Docker, Terraform, Spark, Kafka, dbt - all introduced from scratch).

## If you are stronger than the prerequisites

You can move faster, work ahead, and use the time for a more ambitious project. Some past participants have completed all modules in 4 to 5 weeks instead of 7.

---

## File: courses/data-engineering-zoomcamp/project.md

---
title: "Project"
layout: default
nav_order: 6
parent: Data Engineering Zoomcamp
has_children: false
---

# Final Project

For the cross-course logistics, see [Final Project (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}). That page covers attempts, deadlines, peer review, and certification mechanics.

This page covers what is specific to the Data Engineering Zoomcamp project.

## Project scope

Build an end-to-end data pipeline with a dashboard using any dataset, tools, and cloud provider you choose.

Over two to three weeks, create a pipeline that:

- Ingests data from your chosen source.
- Processes and stores it in a data lake.
- Moves it to a data warehouse.
- Transforms it for analysis.
- Visualizes results in a dashboard.

## Your choices

You decide:

- Dataset (any source you are interested in - see [project datasets](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/projects/datasets.md) on GitHub for suggestions).
- Processing approach (batch or stream).
- Cloud provider (AWS, GCP, Azure, or even local with DuckDB).
- Tools (Terraform, Airflow, Kestra, Spark, Kafka, dbt, etc.).

You are not restricted to the technologies covered in the course. If the course used GCP and you want to use AWS, that is fine. Document everything in detail so peer reviewers can understand your choices.

## Datasets you cannot use

The NYC taxi dataset is used throughout the course modules and homework. You cannot use it for your project. Pick any other dataset.

## Dashboard

Create a dashboard with at least two visualizations using any BI tool. Common choices include Looker Studio, Streamlit, Metabase, and Superset.

If your dashboard is private, include a screenshot in the README. A live link is preferred where possible.

## Evaluation criteria

Your project will be assessed on:

- Problem description and clarity.
- Cloud and infrastructure-as-code usage.
- Data ingestion pipeline (batch or stream).
- Data warehouse optimization.
- Data transformations.
- Dashboard quality.
- Code reproducibility and documentation.

The full rubric (with point values per criterion) is in the [project README on GitHub](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/projects/README.md).

## Certification

Submit the project and complete peer reviews. That is the only requirement to graduate.



What is not required:

- Homework scores. Homework is for learning, not grading.
- Live session attendance.
- Leaderboard points.

For when the certificate is issued and how to add it to LinkedIn, see [Certification (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}).

## Past projects for inspiration

Use these examples to calibrate scope:

- [2025 cohort projects](https://courses.datatalks.club/de-zoomcamp-2025/projects)
- [2024 cohort projects](https://courses.datatalks.club/de-zoomcamp-2024/projects)
- [Community projects gallery](https://datatalksclub-projects.streamlit.app/)
- [2023 examples](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/cohorts/2023/project.md)
- [2022 examples](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/cohorts/2022/project.md)

## Resources on GitHub

Project resources:

- [Project guidelines](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/projects)
- [Full README and rubric](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/projects/README.md)
- [Curated dataset suggestions](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/projects/datasets.md)

---

## File: courses/data-engineering-zoomcamp/qa.md

---
title: "Q&A"
layout: default
nav_order: 9
parent: Data Engineering Zoomcamp
has_children: false
---

# Questions and Answers

DE-specific questions. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}). For module-specific and technical issues, check the [Data Engineering Zoomcamp FAQ](https://datatalks.club/faq/data-engineering-zoomcamp.html).

## Google Cloud Platform

Three reasons:

- $300 free credits for new accounts. AWS's free tier is limited, and many services exclude the free tier. Azure's $200 expires after 30 days. GCP gives the most generous credits with the fewest service restrictions.
- No service limitations during the free trial. The course exercises all run on the free tier.
- Historical compatibility. dbt worked better with BigQuery when the course launched, and the curriculum was built around the GCP stack.

For the project, you can use any cloud. See [Environment Setup]({{ '/courses/data-engineering-zoomcamp/environment-setup/' | relative_url }}) for notes on alternatives.

## Jobs without a degree

Yes.

Multiple success stories from past cohorts:

- Students who landed jobs through the course network.
- Bruno (no formal degree, now Senior DE at US companies).
- Career switchers from analytics, support, and unrelated fields.

What works:

- A strong portfolio of projects.
- Networking (learning in public helps).
- Consistency and going beyond the basics.

## Age and career switching

No. In data engineering, the industry cares about skills, not age. In Germany, many DEs start their careers at 30+ after extended education. Career switchers from other engineering, finance, or analytics backgrounds are common.

Do not put your age on your CV if you want to avoid unconscious bias.

## Time commitment

The course usually takes:

- Two weeks for Module 1, one week each for modules 2 to 6.
- Two to three weeks for the project.
- Plan for 10 to 15 hours per week.

See [Prerequisites]({{ '/courses/data-engineering-zoomcamp/prerequisites/' | relative_url }}) for details.

## Out of scope

The course covers the essential 20% that handles 80% of real-world DE work.

Areas you will encounter in real DE jobs:

- Polars: a modern pandas alternative for data manipulation.
- Delta Lake / Apache Iceberg: advanced table formats for data lakes.
- Snowflake / Redshift / ClickHouse: other data warehouses (the course uses BigQuery).
- dbt incremental models: optimizing dbt for large datasets.
- Apache Flink: real-time streaming. Module 6 introduces it but only briefly.
- Data governance and catalogs: DataHub, Unity Catalog.
- Databricks: increasingly common in industry but not in the course.

The remaining 80% comes with experience in your first DE role.

## Final thoughts

Data engineering is a field that's "5 feet deep and 50 miles wide."

- Ask questions in Slack (after checking the FAQ and the Q+A in this section).
- Learn in public.
- Help your peers.
- Do not get discouraged. It gets challenging.
- You got this.

---

## File: courses/data-engineering-zoomcamp/resources.md

---
title: "Resources"
layout: default
nav_order: 8
parent: Data Engineering Zoomcamp
has_children: false
---

# Resources

Course-specific links for the Data Engineering Zoomcamp. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}).

## GitHub Repository

The repository is your primary navigation tool throughout the course.

[github.com/DataTalksClub/data-engineering-zoomcamp](https://github.com/DataTalksClub/data-engineering-zoomcamp)



How to use it:

1. Start in the module folder you are working on.
2. Read the README in that folder for an overview.
3. Follow the links to video lectures.
4. Complete the homework assignment.
5. Check the cohort folder for any cohort-specific materials.

Repository structure (one folder per module):

- [`01-docker-terraform/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/01-docker-terraform) - Docker, PostgreSQL, Terraform, Google Cloud setup.
- [`02-workflow-orchestration/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/02-workflow-orchestration) - Workflow orchestration with Kestra.
- [`03-data-warehouse/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/03-data-warehouse) - Data warehousing with BigQuery.
- [`04-analytics-engineering/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/04-analytics-engineering) - Analytics engineering with dbt.
- [`05-batch/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/05-batch) - Batch processing with PySpark.
- [`06-streaming/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/06-streaming) - Stream processing with Kafka and Flink.
- [`projects/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/projects) - Final project guidelines.

Cohort folders contain materials specific to each edition:

- [`cohorts/2026/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/cohorts/2026)
- [`cohorts/2025/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/cohorts/2025)
- [`cohorts/2024/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/cohorts/2024)
- [`cohorts/2023/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/cohorts/2023)
- [`cohorts/2022/`](https://github.com/DataTalksClub/data-engineering-zoomcamp/tree/main/cohorts/2022)

The 2026 cohort folder contains per-module subfolders, the cohort [README.md](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/cohorts/2026/README.md), and the [project guidelines](https://github.com/DataTalksClub/data-engineering-zoomcamp/blob/main/cohorts/2026/project.md).

## YouTube

Subscribe to the [DataTalks.Club YouTube channel](https://www.youtube.com/@DataTalksClub) for new content.



There are two playlist types:

Main playlist (pre-recorded lectures, the core curriculum):

- [Data Engineering Zoomcamp main playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hJed7dXYoJw8DoCuVHhGEQb)

Cohort playlists include live sessions and extra material:

- [2025 cohort](https://www.youtube.com/playlist?list=PL3MmuxUbc_hJZdpLpRHp7dg6EOx828q6y)
- [2024 cohort](https://www.youtube.com/playlist?list=PL3MmuxUbc_hKihpnNQ9qtTmWYy26bPrSb)
- [2023 cohort](https://www.youtube.com/playlist?list=PL3MmuxUbc_hJjEePXIdE-LVUx_1ZZjYGW)
- [2022 cohort](https://www.youtube.com/playlist?list=PL3MmuxUbc_hKVX8VnwWCPaWlIHf1qmg8s)

Cohort playlists are supplementary, so focus on the main playlist first. Explore the cohort playlist for extra insights.

## Course Platform

The [course management platform](https://courses.datatalks.club/de-zoomcamp-2026/) is where you submit homework, track your progress, and submit your project.



For the platform UI in detail, see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

## Slack

DE-specific channel: [#course-data-engineering](https://app.slack.com/client/T01ATQK62F8/C01FABYF2RG).

Use this channel for all DE-specific questions, homework discussion, and project Q+A. For all DTC Slack channels, see the [Slack guide]({{ '/general/slack/' | relative_url }}).

## Telegram

DE announcements channel: [t.me/dezoomcamp](https://t.me/dezoomcamp). It is announcement-only, so questions are not monitored there.



## FAQ

The [Data Engineering Zoomcamp FAQ](https://datatalks.club/faq/data-engineering-zoomcamp.html) contains answers to module-specific and technical questions from previous cohorts. Check it before posting in Slack.

## Community Notes

Past cohort participants contribute notes that summarize the course content. They live in the course repository (typically under a `notes/` or per-module folder). Browse the [GitHub repo](https://github.com/DataTalksClub/data-engineering-zoomcamp) and look for community-contributed notes referenced from each module's README.

## Course Dataset

Throughout the course you work with the New York City taxi trips dataset.



Why this dataset:

- Messy and imperfect. You will encounter missing values, inconsistent formats, and quality issues.
- Outliers and anomalies. Negative fares, impossible distances, trips from the future.
- Requires cleaning. You learn to validate, filter, and transform.
- Sufficiently large. Big enough to justify proper engineering, small enough to remain manageable.
- Evolving schema. The NYC TLC has modified the structure over time, so you learn to handle schema changes.
- Well-documented. The [official documentation](https://www.nyc.gov/site/tlc/about/tlc-trip-record-data.page) provides data dictionaries.
- Free and publicly available.

Data format:

- Historical data (2019-2021): CSV files in the [DataTalksClub mirror repository](https://github.com/DataTalksClub/nyc-tlc-data). The course uses these for some modules to demonstrate CSV-to-Parquet conversion.
- Recent data (2025+): Parquet files directly from the [official NYC TLC Trip Record Data page](https://www.nyc.gov/site/tlc/about/tlc-trip-record-data.page).

If you get a 403 Forbidden error when using the original `s3.amazonaws.com/nyc-tlc/...` URLs, NYC TLC has changed the source. Use the DataTalksClub mirror or the official NYC TLC parquet files instead.

---

## File: courses/faq/index.md

---
title: "Course FAQ"
layout: default
nav_order: 999
has_children: false
parent: Courses
---

# Course FAQ Repository

The DataTalks.Club FAQ contains answers to frequently asked questions from the community. Each course has its own comprehensive FAQ covering general questions, module-specific topics, and technical issues.

[Visit the FAQ website](https://datatalks.club/faq/)

## Available Course FAQs

Available FAQ pages:

- [Data Engineering Zoomcamp FAQ](https://datatalks.club/faq/data-engineering-zoomcamp.html)
- [Machine Learning Zoomcamp FAQ](https://datatalks.club/faq/machine-learning-zoomcamp.html)
- [MLOps Zoomcamp FAQ](https://datatalks.club/faq/mlops-zoomcamp.html)
- [LLM Zoomcamp FAQ](https://datatalks.club/faq/llm-zoomcamp.html)
- [AI Dev Tools Zoomcamp FAQ](https://datatalks.club/faq/ai-dev-tools-zoomcamp.html)
- [Stock Market Analytics Zoomcamp FAQ](https://datatalks.club/faq/stock-markets-analytics-zoomcamp.html)

## Contents

Each course FAQ is organized by:

- General questions about the course
- Module-specific questions and answers
- Technical issues and solutions
- Code examples and explanations
- Links to documentation and resources

## Contributing to the FAQ

The FAQ is maintained by the community. If you have a question that isn't answered, you can contribute it.

## Proposing an Entry

To propose an entry:

1. Go to the [FAQ Proposal form](https://github.com/DataTalksClub/faq/issues/new?template=faq-proposal.yml)
2. Fill out the form:
   - Course name
   - Your question
   - Your answer (with examples if possible)
3. Submit

The automated FAQ bot will:
- Analyze your proposal
- Compare it with existing FAQs
- Create a new entry or update an existing one
- Submit a pull request automatically

## Writing Good FAQ Entries

Good entries follow these guidelines:

- Be specific and clear in your question
- Use words students might search for
- Provide direct answers with examples
- Include code snippets when relevant
- Add links to helpful resources

## GitHub Repository

[DataTalksClub/faq](https://github.com/DataTalksClub/faq) - The FAQ is open source. You can also contribute directly via pull requests.

## Earning Points

When you contribute FAQ entries that are accepted into the repository, you earn leaderboard points in your course.

---

## File: courses/llm-zoomcamp/ai-shipping-labs.md

---
title: "AI Shipping Labs"
layout: default
nav_order: 9
parent: LLM Zoomcamp
has_children: false
---

# AI Shipping Labs

If you want extra support and structure while going through the course, [AI Shipping Labs](https://aishippinglabs.com/?utm_source=docs&utm_medium=referral&utm_campaign=llm_zoomcamp_2026_june&utm_content=homepage) is a paid community focused on AI engineering where you can get it. It is also a way to support the course.

But we want to assure you that everything we do at DataTalks.Club is free and will stay free. This is optional, only for people who want to get extra on top of the free content.

## What you get

- Regular [office hours](https://aishippinglabs.com/events/groups/llm-zoomcamp-2026-office-hours?utm_source=docs&utm_medium=referral&utm_campaign=llm_zoomcamp_2026_june&utm_content=office_hours) on Zoom where you can ask questions. They are recorded if you can't make it.
- Accountability sprints. You join a sprint, show up, and share your progress on a call. Knowing you have to report keeps you consistent. The sprint dedicated to LLM Zoomcamp starts one week after the course starts.
- Personalized onboarding. When you enroll, you have a one-on-one with the founders to set your goals and build a plan to reach them.
- Going through the course together with other members.

## Membership

- These benefits start from the middle tier. The basic tier does not include them.
- You can pay monthly or yearly. The benefits are the same. Yearly is cheaper (you get about two months free) and is a stronger commitment.
- There are no location-based discounts right now.

## What else you get

Membership is not tied only to LLM Zoomcamp. It also includes:

- Regular hands-on, member-only workshops and group coding sessions
- Career guidance, including resume, LinkedIn, and GitHub reviews
- Mini-courses on specialized AI topics
- Community hackathons
- Personal branding and developer productivity guidance
- A closed community of practitioners for mentorship and networking
- Exclusive content, tutorials, and breakdowns of new AI tools

## Links

- [AI Shipping Labs](https://aishippinglabs.com/?utm_source=docs&utm_medium=referral&utm_campaign=llm_zoomcamp_2026_june&utm_content=homepage)
- [Events and workshops](https://aishippinglabs.com/events?utm_source=docs&utm_medium=referral&utm_campaign=llm_zoomcamp_2026_june&utm_content=events)

For questions, ask on [Slack]({{ '/general/slack/' | relative_url }}).

---

## File: courses/llm-zoomcamp/curriculum.md

---
title: "Curriculum"
layout: default
nav_order: 3
parent: LLM Zoomcamp
has_children: false
---

# Curriculum

The LLM Zoomcamp covers the core flow for building LLM applications. You work with RAG, agents, vector search, and orchestration. You also work with evaluation and monitoring. The course covers production practices and a capstone project. Each module has video lectures, code, and usually a homework assignment.

For the canonical curriculum (videos, code, exact homework questions), see the [GitHub repository](https://github.com/DataTalksClub/llm-zoomcamp).

## Modules

[Module 1: Agentic RAG](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/01-agentic-rag)

- What LLMs and RAG are, and why LLMs need external context.
- A simple FAQ RAG pipeline with keyword search and minsearch.
- Prompt construction, calling an LLM, and wiring search plus prompts into a reusable RAG pipeline.
- Persistent keyword search with sqlitesearch.
- Function calling and the agentic loop, where the LLM decides when and what to search.
- The FAQ dataset comes directly from the DataTalks.Club FAQ website.

[Module 2: Vector Search](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/02-vector-search)

- Semantic search with embeddings.
- Generating embeddings for the FAQ dataset.
- Vector search with numpy and minsearch.
- RAG with vector search instead of keyword search.
- Persistent vector search with sqlitesearch and PGVector.
- Optional ONNX-based embedders for lightweight deployments.

[Module 3: Orchestration](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/03-orchestration)

- AI workflow orchestration with Kestra.
- Context engineering and why generic AI assistants can produce unreliable workflows.
- Using Kestra's AI Copilot to generate and refine flows.
- RAG workflows, agentic workflows, and multi-agent systems.
- Production considerations: cost, security, observability, and when to use each approach.

[Data Ingestion Workshop](https://github.com/DataTalksClub/llm-zoomcamp/blob/main/cohorts/2026/workshops/dlt.md)

- Pulling LLM traces from a monitoring service.
- Preparing trace data for analytics with dlt.
- This workshop runs between orchestration and evaluation in the 2026 syllabus.

[Module 4: Evaluation](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/04-evaluation)

- Systematic evaluation for search, RAG, and agent systems.
- Generating ground truth data with an LLM.
- Offline evaluation of retrieval quality with Hit Rate and MRR.
- Search parameter tuning based on evaluation metrics.
- Evaluating answer quality with LLM-as-a-judge.
- Capturing final answers and tool-call trajectories for agent evaluation.

[Module 5: Monitoring](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/05-monitoring)

- Online monitoring of a deployed RAG system.
- Building a Streamlit chat app.
- Tracking LLM call metrics, latency, and cost.
- PostgreSQL for storing conversations and feedback.
- User-feedback signals and built-in LLM-as-a-judge checks.
- Streamlit and Grafana dashboards.
- Docker Compose for running the app, database, and dashboards together.

[Module 6: Best Practices](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/06-best-practices)

- Optional module recorded in 2024.
- Hybrid search with Elasticsearch.
- Document reranking with Reciprocal Rank Fusion.
- Hybrid search with LangChain.
- The techniques are still relevant, but some code uses older libraries and approaches.

[Module 7: End-to-End Project Example](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/07-project-example)

- Optional module recorded in 2024.
- A complete project example: a fitness assistant built with LLMs.
- Search, evaluation, API, monitoring, and Docker containerization in one project.
- Chunking strategies for longer text sources.

[Capstone Project](https://github.com/DataTalksClub/llm-zoomcamp/blob/main/project.md)

- Three weeks at the end of the cohort.
- Build a complete RAG application on your own knowledge base.
- Implement retrieval, answer generation, evaluation, a user-facing interface, and monitoring or feedback loops.
- See the [Project page]({{ '/courses/llm-zoomcamp/project/' | relative_url }}).

## Out of scope

To keep the course focused, several adjacent topics are intentionally out of scope.

They are covered elsewhere or planned for future cohorts:

- Open-source LLMs (running, deploying, fine-tuning).
- MCP and deeper agentic frameworks: the course covers agents from first principles, but not every current framework.
- Image generation, multimodal embeddings, prompt engineering as a deep topic, guardrails, distributed training: not in this course.

## Pace

A typical week:

- Watch the module videos (3 to 5 hours).
- Code along and experiment (3 to 5 hours).
- Complete the homework (2 to 5 hours).

Plan for around 10 hours per week. Module 1 takes longer (two weeks), and the vector search module historically takes more time than the others.

For the capstone project, plan two weeks of focused work plus one week of peer review.

## Cohort changes

For changes specific to the current cohort, see [What's New]({{ '/courses/llm-zoomcamp/whats-new/' | relative_url }}).

---

## File: courses/llm-zoomcamp/environment-setup.md

---
title: "Environment Setup"
layout: default
nav_order: 4
parent: LLM Zoomcamp
has_children: false
---

# Environment Setup

The LLM Zoomcamp uses modern Python, `uv`, Docker, and Jupyter notebooks. You also need a hosted LLM provider. This page covers the high-level setup decisions. For step-by-step setup, follow [Module 1](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/01-agentic-rag).

## Runtime environment

The course is designed to run on your own laptop.

You need:

- A modern Python version. Python 3.10 or newer works. Use Python 3.11 or 3.12 if you are setting up a new environment.
- `uv` for Python dependency management.
- Docker (for the supporting services like the search engine and the monitoring stack).
- An LLM provider API key.

You do not need a GPU or a paid cloud account.

You can also run the course in GitHub Codespaces or on a cloud VM if your laptop is constrained. Choose an environment where you can run Docker.

## Choosing an LLM provider

The course examples use OpenAI, but the only real requirement is "an LLM you can call from Python".

Practical options:

- OpenAI: the default in the course examples and the most common API in industry. Pricing is per million tokens. A few dollars of credit covers the whole course. Even $10 of credit is hard to spend during the cohort.
- Groq: free tier is generous and hosts open-weight models. You can complete the entire course on Groq for free, as long as you do not hammer the API.
- Anthropic, AWS Bedrock, Google AI Studio, and similar: any provider with a Python SDK works.
- Ollama (fully local): runs an open-weight model on your own machine, no API key needed. Useful if you cannot or do not want to use a hosted API. The course mentions it but does not depend on it.

For a curated list of OpenAI-alternative providers, see the `awesome-llms` file in the course repo.

If you want to learn the OpenAI ecosystem because most paid roles touch it, use OpenAI. If you want to optimise for "no credit card", use Groq or Ollama.

## Python and dependency management

The course recommends `uv` for Python dependency management. It is faster than pip or conda and handles virtual environments cleanly. See the [uv documentation](https://docs.astral.sh/uv/) for installation.

Anaconda or plain `pip + venv` also work. The choice does not affect the course content.

## Notebooks

Some course materials use Jupyter notebooks.

You can run them:

- Locally.
- In VS Code with the Python and Jupyter extensions.
- In any Jupyter-compatible environment that can reach the services you run with Docker.

Google Colab is not recommended as the main course environment. It can work for isolated notebooks. Many modules need Docker services such as PostgreSQL, PGVector, the monitoring stack, or local containers.

## Docker

Docker runs the search engine, monitoring stack, and other supporting services. Install Docker before module 1 starts. The course does not teach Docker - it is a hard prerequisite.

## Operating system notes

Mac (Apple Silicon, M1/M2/M3):

- Most libraries have native ARM builds.
- Docker Desktop sometimes shows "Malware Blocked" warnings on installation. Allow it in System Settings if needed.
- Colima is a lighter alternative to Docker Desktop and works fine for the course.

Windows:

- WSL2 with Ubuntu is the smoothest path. Native Windows works but is rougher around the edges for Docker.

Linux:

- Native installation works without surprises. Make sure your user is in the `docker` group.

## Cost

The course is free.

The only spend you may incur:

- A few dollars on OpenAI credit, if you choose OpenAI. Most participants spend $1 to $5 across the whole cohort.
- $0 if you use Groq or Ollama.

There is no required cloud spend.

## AI tools (Cursor, ChatGPT, Claude)

Using AI tools to help you work through the course is fine and encouraged. You will get more out of the course if you understand the material well enough to debug AI-generated code. You should also be able to adapt that code to your own setup. For the AI usage policy on homework, projects, and peer review, see [AI Usage Policy]({{ '/courses/zoomcamp-logistics/ai-usage/' | relative_url }}).

---

## File: courses/llm-zoomcamp/getting-started.md

---
title: "Getting Started"
layout: default
nav_order: 2
parent: LLM Zoomcamp
has_children: false
---

# Getting Started

For cross-course onboarding, read [Joining a Cohort]({{ '/courses/zoomcamp-logistics/joining/' | relative_url }}) first. It covers registration, platform account setup, calendar, and newsletter updates.

This page covers the LLM Zoomcamp specifics.

## Star the GitHub repository

[github.com/DataTalksClub/llm-zoomcamp](https://github.com/DataTalksClub/llm-zoomcamp)

Star the repo so you can find it later. All course materials are there, and each module has its own folder. The course team adds cohort-specific homework, deadlines, and launch-stream links under `cohorts/` when published.

When many new participants star the repo around launch time, GitHub may surface it on Trending. That pulls more people into the cohort.

## Join the LLM Zoomcamp Slack channel

After joining the [DataTalks.Club Slack workspace](https://datatalks.club/slack), find the channel:

`#course-llm-zoomcamp`

This is your primary support and Q+A channel for the course. Use threads when replying. Don't tag instructors directly - other participants often answer first, and tagging discourages that.

## Subscribe to LLM Telegram (optional, recommended)

[t.me/llm_zoomcamp](https://t.me/llm_zoomcamp) is the announcement-only channel. Telegram is the most reliable place to catch important updates because Slack gets noisy. Telegram announcements are auto-reposted to Slack, so you do not strictly need it.

## Subscribe to YouTube

The lectures are pre-recorded and live in two playlists on the [DataTalks.Club YouTube channel](https://www.youtube.com/@DataTalksClub):

- LLM Zoomcamp main playlist: the canonical pre-recorded module videos.
- LLM Zoomcamp 2026: cohort-specific recordings (launch stream, office hours).

For all the playlist links, see [Resources]({{ '/courses/llm-zoomcamp/resources/' | relative_url }}).

## Bookmark the FAQ

The [LLM Zoomcamp FAQ](https://datatalks.club/faq/llm-zoomcamp.html) collects answers to module-specific and technical questions from previous cohorts. Check it before posting in Slack.

There is also a community-built bot that answers questions using the FAQ and Slack history. The link is saved in the course Slack channel.

## Pick your LLM provider

The course uses OpenAI in its examples. You are free to use any provider for your own work and project.

Practical options:

- OpenAI: the default. A few dollars of credit covers the whole course.
- Groq: free tier is generous enough to complete the course end to end.
- Ollama or similar: for fully local, no-API workflows on a normal laptop.

For tradeoffs and the recommended setup, see [Environment Setup]({{ '/courses/llm-zoomcamp/environment-setup/' | relative_url }}).

## Set up your environment

The course uses Python with Docker for the supporting services. Most lessons use notebooks.

You will install:

- Python (3.10 or newer).
- Docker.
- Jupyter (covered in module 1).
- An LLM provider account (OpenAI key, Groq key, or both).

For the choices you need to make, see [Environment Setup]({{ '/courses/llm-zoomcamp/environment-setup/' | relative_url }}).

## Start Module 1

Begin with [Module 1: RAG and Vector Search](https://github.com/DataTalksClub/llm-zoomcamp/tree/main/01-rag). Module 1 covers LLMs, RAG, and a FAQ assistant with keyword search and vector search. For the full module list, see [Curriculum]({{ '/courses/llm-zoomcamp/curriculum/' | relative_url }}).

## Next pages

Use these pages next:

- [Prerequisites]({{ '/courses/llm-zoomcamp/prerequisites/' | relative_url }}) - what you need to know before starting.
- [Curriculum]({{ '/courses/llm-zoomcamp/curriculum/' | relative_url }}) - the modules.
- [Environment Setup]({{ '/courses/llm-zoomcamp/environment-setup/' | relative_url }}) - Python, providers, local vs hosted.
- [Project]({{ '/courses/llm-zoomcamp/project/' | relative_url }}) - the project rubric.
- [Resources]({{ '/courses/llm-zoomcamp/resources/' | relative_url }}) - all LLM-specific links in one place.
- [What's New]({{ '/courses/llm-zoomcamp/whats-new/' | relative_url }}) - changes for the current cohort.
- [Learning in Public]({{ '/courses/zoomcamp-logistics/learning-in-public/' | relative_url }}) - hashtag for LLM is `#llmzoomcamp`.

---

## File: courses/llm-zoomcamp/index.md

---
title: "LLM Zoomcamp"
layout: default
nav_order: 4
parent: Courses
has_children: true
---

# LLM Zoomcamp

The LLM Zoomcamp is a free, hands-on course on building real-world applications with Large Language Models. Each cohort runs once a year and focuses on AI engineering. You use hosted LLMs such as OpenAI and Groq to build, evaluate, and monitor production-style RAG systems.

The 2026 edition runs from June through the end of summer. It lasts about 10 weeks. Module 1 takes roughly two weeks. The remaining modules take about one week each. The final project takes three weeks.

LLMs themselves are treated as black boxes here. The course is for people who want to build with LLMs rather than train them.

## Docs order

Read in this order:

1. [Community Guidelines]({{ '/general/guidelines/' | relative_url }}) - code of conduct, how to ask questions, how to use Slack channels, how to promote your work.
2. [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}) - how DataTalks.Club zoomcamps work in general (cohort schedule, joining, live sessions, homework, project, peer review, certification). Most of your logistical questions are answered there.
3. The pages in this section - what is specific to the LLM Zoomcamp (curriculum, environment, project rubric, LLM-specific resources).
4. The [LLM Zoomcamp FAQ](https://datatalks.club/faq/llm-zoomcamp.html) - module-specific and technical questions from previous cohorts.

For platform mechanics (where to click on the submission form, how the leaderboard appears), see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

---

## File: courses/llm-zoomcamp/prerequisites.md

---
title: "Prerequisites"
layout: default
nav_order: 1
parent: LLM Zoomcamp
has_children: false
---

# Prerequisites

The LLM Zoomcamp does not require any prior machine-learning or AI background. It is a course for developers and engineers who want to build LLM-powered applications.

For general expectations about zoomcamp time commitment, see [Before You Start]({{ '/courses/zoomcamp-logistics/before-you-start/' | relative_url }}).

## Required skills

You should have these skills:

- Comfortable programming. You do not need ten years of experience, but you should be able to write code, read someone else's code, and connect different pieces together. The course uses Python. If you know another language well, you can pick up the Python you need in a few days.
- Comfortable with the command line and Git basics.
- Docker installed and runnable. Docker is treated as a prerequisite. The course does not teach Docker. If you need to learn it, the [Data Engineering Zoomcamp](https://github.com/DataTalksClub/data-engineering-zoomcamp) and [Machine Learning Zoomcamp](https://github.com/DataTalksClub/machine-learning-zoomcamp) include Docker introductions.

## You do not need

You do not need:

- Prior machine-learning experience. The course does not look under the hood of LLMs.
- Advanced math.
- A GPU. The course uses hosted LLMs (OpenAI, Groq, and others) and a normal laptop is enough.
- Prior cloud experience. You can complete the entire course locally if you want to.
- A degree.

## Time commitment

Plan for:

- About 10 hours per week during the cohort. Past cohorts' homework data shows roughly 4 hours of lectures plus 3 hours of homework for module 1, and around 10 hours for vector search.
- Two weeks of focused project work plus one week for peer review.

The earliest you can receive your certificate is after the project peer-review deadline.

## Adapting to your background

Different backgrounds map to the course differently:

- Software developers and backend engineers: this is the most direct path. You already have the engineering skills. The course adds the AI patterns.
- Data engineers: AI engineering is largely data engineering in disguise (knowledge bases, ingestion, indexing, reliable connections). Your skills transfer directly.
- Data scientists who already work with LLMs at their job: you will fill in gaps on the engineering and evaluation side.
- Career switchers: if you can already program, you can take this course. If you cannot, build programming basics first. The course is challenging without them.

For environment and tooling choices, see [Environment Setup]({{ '/courses/llm-zoomcamp/environment-setup/' | relative_url }}).

---

## File: courses/llm-zoomcamp/project.md

---
title: "Project"
layout: default
nav_order: 6
parent: LLM Zoomcamp
has_children: false
---

# Project

For the cross-course logistics (deadlines, peer review, certification mechanics), see [Final Project (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}).

For the platform UI (where to submit, commit ID, project gallery), see [Course Management Platform: Projects]({{ '/courses/course-management-platform/projects/' | relative_url }}).

This page covers what is specific to the LLM Zoomcamp: what kind of project to build, how to choose a good idea, and what the reviewers expect to see.

## Project scope

Build a working LLM-powered application on a knowledge base of your choice. In most projects, this means a RAG application. You apply modules 1 to 5 to your own data and show that you can build, evaluate, and document an end-to-end system.

Your project should:

- Pick a domain.
- Ingest a knowledge base.
- Index it for retrieval.
- Wire up an LLM.
- Evaluate retrieval and the end-to-end RAG flow.
- Ideally include some monitoring.

Past projects from previous cohorts give a sense of the expected scope. Examples include a recipe search assistant, a fitness assistant, and a reference lookup tool for music notation. Most are modest in scope but cleanly built and well-documented.

## Choosing a project idea

A good project starts with a real question someone would ask, not with a tool choice. Before deciding on a stack, write down:

- Who the user is.
- What they need help with.
- What knowledge base the assistant will use.
- What a useful answer should look like.
- How you will tell whether the answer is good.

Good project ideas usually have these properties:

- The domain is specific enough that generic ChatGPT would not be enough.
- The knowledge base is available, clean enough to process, and large enough to make retrieval meaningful.
- The answers can be checked against the source documents.
- The scope fits into a few weeks.
- The README can explain the problem to someone outside the domain.

Avoid vague ideas like "a chatbot for documents" unless you make the user, documents, and task concrete. For example:

- Instead of a generic PDF chatbot, build an assistant for a specific set of product manuals, public policies, internal notes, or course materials.
- Instead of "medical assistant", build a tool that answers questions from a public clinical guideline dataset and clearly cites sources.
- Instead of "career assistant", build a tool that searches a curated set of job descriptions and explains which skills are repeatedly requested.

## Using the AI Engineering Field Guide

The [AI Engineering Field Guide]({{ '/courses/llm-zoomcamp/resources/#ai-engineering-field-guide' | relative_url }}) is a good source of project ideas. Its [home-assignments section](https://github.com/alexeygrigorev/ai-engineering-field-guide/blob/main/interview/questions/06-home-assignments.md) collects take-home assignments from 100+ company GitHub repositories.

Do not copy an assignment blindly. Use it as a prompt for a project you can finish and explain:

- Pick an assignment that sounds like work you would like to do in a real AI engineering role.
- Identify the core user problem in the assignment.
- Replace any missing or proprietary data with public data you can share.
- Adapt the task to the LLM Zoomcamp rubric: ingestion, retrieval, LLM answer generation, evaluation, and reproducibility.
- Keep the scope small enough that you can finish it, but real enough that it is useful as a portfolio piece.

The Field Guide is especially useful if you want the project to support your job search. Look at assignments from companies or roles you care about, then build a smaller version that demonstrates the same skills.

## More project inspiration

These write-ups show examples of finished AI engineering and agentic projects. Use them for scope, architecture ideas, and problem framing:

- [9 Real-Life AI Projects from AI Engineering Buildcamp Graduates](https://aishippingblog.com/p/9-real-life-ai-projects-from-ai-engineering)
- [5 ideas for AI agents and OpenAI's hidden skills](https://aishippingblog.com/p/5-ideas-for-ai-agents-and-openais)

## Knowledge base / dataset

You choose the knowledge base. It can be in any language, including non-English. The README must still be in English so peer reviewers can evaluate the project. Pick a domain you find interesting because you will work with it for several weeks.

Avoid:

- Any dataset the course uses in its lectures or homework. Choose something new so the project shows your own work.
- Trivially small or toy data that does not exercise retrieval meaningfully.

Strong sources for a knowledge base:

- Documentation for an open-source project.
- Public policy, legal, or government documents.
- Product manuals or technical support pages.
- Public datasets with text fields, reviews, complaints, or Q&A.
- Your own notes, if you can make enough of them public for reviewers.

## Required components

Every LLM Zoomcamp project must include:

- An ingestion path that turns your raw knowledge base into something searchable.
- A retrieval system (text search, vector search, or hybrid).
- An LLM-powered answering layer that uses the retrieved documents.
- A retrieval evaluation: which strategy you tried and how it scored.
- An end-to-end evaluation of the full RAG flow.
- Some form of interface that a reviewer can use, even if it is just a Python script or a notebook. A web UI (Streamlit, Gradio, Flask) is welcome but not required.

The rubric does not require these nice-to-haves:

- Monitoring with Grafana, PostgreSQL, or another tool.
- A deployed live system.

## Tech stack flexibility

You are not restricted to the technologies covered in the course. Use any LLM provider, vector database, framework, or programming language.

Caveats:

- Document your choices clearly in the README. Reviewers may not know your stack.
- Make the project reproducible. If a reviewer cannot run it, or at least understand how it would run, you lose reproducibility points.
- If you write the project in JavaScript, Go, or anything other than Python, give explicit setup instructions. Python is the only stack you can assume reviewers have ready.

## Frameworks

The course teaches RAG without frameworks so that you understand the underlying concepts. For your project, frameworks are allowed. You can use LangChain, LlamaIndex, Haystack, or similar tools. Document why you chose the framework and what it gives you.

## Evaluation criteria

Each course defines its own rubric. The platform shows the exact criteria when you review or are reviewed.

Common criteria for LLM Zoomcamp projects:

- Problem description and motivation.
- Knowledge base preparation and ingestion.
- Retrieval setup and evaluation of retrieval quality.
- LLM integration and end-to-end RAG flow.
- End-to-end evaluation.
- Reproducibility (can a reviewer run the project from your README).
- Documentation quality.
- Bonus: interface, monitoring, deployment, advanced techniques.

The full rubric for the current cohort is on the course platform under the project window.

## Past projects

Use past projects to calibrate scope:

- [LLM Zoomcamp 2025 project gallery](https://courses.datatalks.club/llm-zoomcamp-2025/projects)
- [LLM Zoomcamp 2024 project gallery](https://courses.datatalks.club/llm-zoomcamp-2024/projects)
- Browse other cohorts on the [course platform](https://courses.datatalks.club/).
- Use the project gallery flow described in [Course Management Platform: Projects]({{ '/courses/course-management-platform/projects/' | relative_url }}).

## Portfolio focus

Treat the project as a portfolio piece with a meaningful repository name such as `recipes-rag-assistant`, not `homework-final`. Include a clear README. Past graduates have used these projects in job applications and interviews.

A few habits make the difference between finishing the course and building something employers notice:

- Start building from day one. Do not wait for the project window to open. Read the project guidelines at the start, decide what you want to build, and apply each module to your own project as you learn it. Putting concepts into practice immediately beats going through the material passively.
- Build more than one project. Everyone finishes the course with a RAG app on the same course dataset, so that alone does not stand out. Build several projects on data and problems you chose yourself. A small portfolio of varied projects, such as a RAG app, an agent, or something in a different domain, is far stronger than a single one.
- Make them your own. The strongest projects solve a problem you actually have, on data you picked, cleaned, and structured yourself. That work is what shows your skills.

---

## File: courses/llm-zoomcamp/qa.md

---
title: "Q&A"
layout: default
nav_order: 9
parent: LLM Zoomcamp
has_children: false
---

# Questions and Answers

This page covers LLM-specific questions about course scope and philosophy. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}). For module-specific and technical issues, check the [LLM Zoomcamp FAQ](https://datatalks.club/faq/llm-zoomcamp.html).

## Agents module

The 2026 course includes agents because the basic patterns are now stable enough to teach. Agents are part of Module 1: Agentic RAG.

The module still builds from first principles. It starts with a RAG pipeline, then adds function calling, tool use, and the agentic loop.

## RAG focus

A year ago RAG was the most common LLM application in the wild. Today many providers offer built-in RAG features, but RAG remains the strongest teaching example. It shows how to combine retrieval, prompting, and evaluation in a real system. Skills you build for RAG transfer to most other LLM applications.

## MCP and LangGraph

The surface area is still changing quickly. The course teaches agents without depending on a large framework so that you understand the mechanics. Once you do, picking up MCP, LangGraph, or another framework takes less time.

LangChain is the one exception - it appears in the optional best-practices module for hybrid search and document reranking.

## LLM internals

This course is about LLM engineering, not LLM internals. LLMs are treated as black boxes you call through an API.

Building your own LLM from scratch is not on the roadmap and there are already strong courses on that elsewhere.

## Difference from ML Zoomcamp

ML Zoomcamp covers classical machine learning and looks under the hood at how models learn. It also covers model selection and evaluation. LLM Zoomcamp does not look under the hood. It teaches you to build applications on top of hosted LLMs, including evaluation and monitoring.

If you are deciding between the two, take ML Zoomcamp if you want to understand machine learning. Take LLM Zoomcamp if you want to build with LLMs.

## Difference from MLOps Zoomcamp

MLOps Zoomcamp covers the operational lifecycle of ML models, including experiment tracking and model registry. It also covers deployment, monitoring, and retraining.

LLM Zoomcamp's monitoring module covers similar ground for LLMs:

- Request volume
- Latency
- Cost
- Response quality

It does not cover training-side concerns.

## Retaking the course

The RAG focus is still there, but the 2026 flow is different from 2025. Module 1 is now Agentic RAG, and agents are no longer a separate Module A. Module 3 covers orchestration with Kestra. Evaluation now includes agent evaluation basics. Monitoring is a full module with PostgreSQL, Streamlit, and Grafana.

It is worth retaking if you want to refresh and re-implement with the current course structure.

## Existing RAG experience

If you already know RAG, skim module 1 first. If it feels familiar, jump straight to the project. Identify gaps as you build, then go back and fill just those.

## Jobs after the course

The course gives you engineering skills companies want. Whether you land a job depends on what you do outside the course.

Use the course as a base for:

- Build projects
- Learn in public
- Share your work
- Apply

There is anecdotal evidence of past graduates landing AI roles after the course but no clean data on conversion rates. Treat it as one strong piece of a portfolio, not a guaranteed path.

For data scientists who do not yet work with LLMs, this course is a strong way to extend your profile. Many DS roles now expect RAG familiarity.

## Career switchers

It is possible, with effort. The course assumes you can program. If you can, the LLM-specific concepts are accessible in a few weeks. If you cannot program yet, build programming basics first. The course is hard without them.

## Final thoughts

LLM engineering is mostly the engineering you already know, with a few new patterns layered on. Pick a problem you find interesting, build something end to end, and share what you learn.

- Ask questions in [`#course-llm-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C06TEGTGM3J) after checking the FAQ first.
- Learn in public.
- Help your peers.
- Do not get stuck on one tool. The patterns matter more than the brand names.

---

## File: courses/llm-zoomcamp/resources.md

---
title: "Resources"
layout: default
nav_order: 8
parent: LLM Zoomcamp
has_children: false
---

# Resources

Course-specific links for the LLM Zoomcamp. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}).

## GitHub Repository

The repository is your primary navigation tool throughout the course.

[github.com/DataTalksClub/llm-zoomcamp](https://github.com/DataTalksClub/llm-zoomcamp)

How to use it:

1. Start in the module folder you are working on.
2. Read the README in that folder for an overview and the list of videos.
3. Open the module's `lessons/` directory for the lesson notes and per-lesson links.
4. Follow the links to the video lectures.
5. Complete the homework assignment.
6. Check the `cohorts/2026/` folder for cohort-specific homework, schedule links, and cohort recordings.

Repository structure:

- `01-agentic-rag/` - RAG, function calling, and the agentic loop.
- `02-vector-search/` - embeddings, semantic search, minsearch, sqlitesearch, and PGVector.
- `03-orchestration/` - AI orchestration with Kestra.
- `04-evaluation/` - offline evaluation of retrieval, RAG, and agent behavior.
- `05-monitoring/` - online monitoring with PostgreSQL, Streamlit, and Grafana.
- `06-best-practices/` - optional older material on hybrid search, reranking, and LangChain.
- `07-project-example/` - optional end-to-end fitness assistant project example.
- `project.md` - capstone project guidelines.
- `cohorts/` - cohort-specific homework, deadlines, launch links, and older materials.

## YouTube

Main video links:

- [DataTalks.Club YouTube channel](https://www.youtube.com/@DataTalksClub)
- [LLM Zoomcamp main playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hLZFNgSad56pDBKK8KO0XIv) - canonical pre-recorded module videos.
- [LLM Zoomcamp 2026 playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hJAmLLf2x1LSKRKbZwKXoHd) - cohort-specific recordings.

For how live sessions work in general (timing, where to watch, recordings), see [Live Sessions]({{ '/courses/zoomcamp-logistics/live-sessions/' | relative_url }}).

## Course Platform

Use the [LLM Zoomcamp 2026 course page](https://courses.datatalks.club/llm-zoomcamp-2026/) on the course management platform. There you submit homework, track progress, and submit your project.

For the platform UI in detail, see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

To register for the live cohort, use the [LLM Zoomcamp signup form](https://courses.datatalks.club/register/llm-zoomcamp/).

## Slack

LLM-specific channel: [`#course-llm-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C06TEGTGM3J) in the [DataTalks.Club Slack workspace](https://datatalks.club/slack.html).

Use this channel for LLM-specific questions, homework discussion, and project Q+A. Use threads when replying. Do not tag instructors. For all DTC Slack channels, see the [Slack guide]({{ '/general/slack/' | relative_url }}).

## Telegram

Use [t.me/llm_zoomcamp](https://t.me/llm_zoomcamp) for LLM announcements. It is announcement-only, so questions are not monitored there and Telegram messages are auto-reposted to Slack.

## Newsletter

The [DataTalks.Club newsletter](https://datatalks.club/newsletter.html) goes out every Monday with course announcements and community updates. Everyone who signs up for a cohort is automatically subscribed.

## FAQ

The [LLM Zoomcamp FAQ](https://datatalks.club/faq/llm-zoomcamp.html) collects answers to module-specific and technical questions from previous cohorts. Check it before posting in Slack.

The course repo also has an [asking questions guide](https://github.com/DataTalksClub/llm-zoomcamp/blob/main/asking-questions.md) with tips for posting useful questions in Slack.

## AI Engineering Field Guide

The [AI Engineering Field Guide](https://github.com/alexeygrigorev/ai-engineering-field-guide) is a companion resource by the course instructor. It is a data-driven guide to AI engineering roles, skills, and interviews, built from analyzing thousands of real job descriptions, interview experiences, and practitioner stories.

It is useful both during and after the course:

- **Project ideas.** The [home-assignments section](https://github.com/alexeygrigorev/ai-engineering-field-guide/blob/main/interview/questions/06-home-assignments.md) collects take-home assignments from 100+ company GitHub repos. Pick one that resonates and build it as your capstone project.
- **Interview preparation.** Theory, coding, project deep-dive, system design, and behavioral questions consolidated from 100+ sources, plus company-by-company interview process data.
- **Career direction.** Role and skills analysis, real-world use cases, and learning paths for moving into AI engineering from data engineering, data science, or other backgrounds.

---

## File: courses/llm-zoomcamp/whats-new.md

---
title: "What's New"
layout: default
nav_order: 5
parent: LLM Zoomcamp
has_children: false
---

# Changes

Notable changes for the current cohort. The previous version of the course page described the 2025 flow, so this page focuses on what changed for 2026.

## 2026

Course structure

- Module 1 is now Agentic RAG. It combines the RAG introduction with function calling and the agentic loop.
- Agents are no longer a separate "Module A" after the dlt workshop. They are part of the main course flow from the first module.
- Module 2 is now dedicated to Vector Search. It covers embeddings, semantic search, minsearch, sqlitesearch, PGVector, and optional ONNX-based embedders.
- Module 3 is a new Orchestration module with Kestra. It covers context engineering, AI Copilot, RAG workflows, agentic workflows, multi-agent systems, and production considerations.
- The dlt workshop remains in the 2026 course, now focused on pulling LLM traces from a monitoring service and preparing them for analytics.
- Evaluation moved from Module 3 in 2025 to Module 4 in 2026. It now covers search evaluation, RAG answer evaluation, and the basics of agent evaluation.
- Monitoring is now a full Module 5. In 2025, the main course page ended after evaluation. In 2026, monitoring is part of the main sequence.
- Best Practices is Module 6 and End-to-End Project Example is Module 7. These are optional modules based on older material, but they are included in the 2026 syllabus as useful follow-up content.
- The capstone project remains the final requirement for certificate eligibility.

Tooling

- The course recommends modern Python and `uv` for dependency management.
- Docker is more central because several modules need services such as PostgreSQL, PGVector, and monitoring dashboards.
- The FAQ dataset now comes directly from the DataTalks.Club FAQ website.
- Kestra is used for orchestration.
- PostgreSQL, Streamlit, and Grafana are used for monitoring.

What stayed

- The course is still practical and incremental.
- RAG remains the main application pattern.
- The FAQ assistant remains an important running example.
- The course still does not require a GPU.
- You can still complete the course on a normal laptop with a few dollars of OpenAI credit, or with a compatible alternative provider.

For the full curriculum, see [Curriculum]({{ '/courses/llm-zoomcamp/curriculum/' | relative_url }}). For environment setup, see [Environment Setup]({{ '/courses/llm-zoomcamp/environment-setup/' | relative_url }}).

---

## File: courses/ml-zoomcamp/curriculum.md

---
title: "Curriculum"
layout: default
nav_order: 3
parent: Machine Learning Zoomcamp
has_children: false
---

# Curriculum

The Machine Learning Zoomcamp covers nine main modules plus project work. Each module has video lectures, reading material, and a homework assignment.

For the canonical curriculum (videos, code, exact homework questions), see the [GitHub repository](https://github.com/DataTalksClub/machine-learning-zoomcamp).

## Modules

[Module 1: Introduction](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/01-intro)

- Setup, basic Python and pandas, basic linear algebra refresher.

[Module 2: Linear Regression](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/02-regression)

- Predicting car prices.
- Feature engineering, training, evaluation.

[Module 3: Binary Classification](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/03-classification)

- Customer churn prediction.

[Module 4: Model Evaluation](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/04-evaluation)

- ROC curves, precision-recall, cross-validation.
- Often the most challenging module conceptually.

[Module 5: Model Deployment](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/05-deployment)

- FastAPI for serving models.
- Docker for packaging.

[Module 6: Tree-Based Models](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/06-trees)

- Decision trees, random forests, gradient boosting.
- Loan default prediction.

Module 7: Midterm Project

- Three weeks of independent work.
- Apply what you have learned through Module 6.

[Module 8: Neural Networks and Deep Learning](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/08-deep-learning)

- PyTorch fundamentals.

[Module 9: Serverless Deployment](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/09-serverless)

- AWS Lambda with ONNX runtime.

[Module 10: Kubernetes](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/10-kubernetes)

- Deploying ML services on Kubernetes.

[Module 11: KServe](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/11-kserve)

- Optional and potentially outdated. Focus on Kubernetes (Module 10) instead.

Capstone Project

- Three weeks of independent work after Module 10.

## Learning philosophy

The course follows a project-first approach: theory is introduced as needed to solve real problems. Practical over theoretical, focused on ML engineering skills used in industry.

The course is community-driven. Learning together, sharing your progress, and helping each other are part of the design.

## Pace

A typical week:

- Watch the module videos (3 to 5 hours).
- Code along and experiment (3 to 5 hours).
- Complete the homework (2 to 5 hours).

Plan for 10 to 15 hours per week. Module 4 (model evaluation) is harder, so allocate more time.

For the project blocks (midterm and capstone), plan 2 to 3 weeks of focused work each.

## Cohort changes

For changes specific to the current cohort, see [What's New]({{ '/courses/ml-zoomcamp/whats-new/' | relative_url }}).

---

## File: courses/ml-zoomcamp/environment-setup.md

---
title: "Environment Setup"
layout: default
nav_order: 4
parent: Machine Learning Zoomcamp
has_children: false
---

# Environment Setup

The Machine Learning Zoomcamp uses Python with scikit-learn, FastAPI, Docker, and AWS for cloud examples. This page covers the high-level setup decisions. For step-by-step setup, follow the videos in [Module 1](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/01-intro).

## Python and dependency management

The course recommends `uv` for Python dependency management. It is faster than pip/conda and handles virtual environments cleanly. See the [uv documentation](https://docs.astral.sh/uv/) for installation.

You can also use Anaconda. On Windows, Anaconda is often the easiest way to get Python plus scientific libraries running.

Plain `pip + venv` works too. The choice does not affect the course content.

## Notebook environment

The course uses Jupyter notebooks throughout. You can run them locally, in Google Colab, or in any Jupyter-compatible environment.

VS Code with the Python and Jupyter extensions is a popular choice. It gives you notebook support and full IDE features.

## Cloud (AWS)

The course uses AWS for deployment in modules 9 and 10 (Lambda, EKS). New AWS accounts get free tier credits, though the free tier is more limited than GCP's.

You can complete the course without AWS:

- Module 5 (basic deployment) runs locally with Docker.
- Module 9 (serverless) can be done with the free Lambda tier or skipped.
- Module 10 (Kubernetes) can be done locally with `kind` or `minikube` instead of EKS.

For your project, you can use any cloud provider or stay local. AWS, GCP, and Azure all work. Document your choices for peer reviewers.

## AI tools (Cursor, ChatGPT, etc.)

The course welcomes AI tools like Cursor, ChatGPT, and Claude. You will get more out of the course if you understand the concepts well enough to debug AI-generated code. Keep control over your implementations and build custom solutions when AI tools fall short.

## Operating system notes

Mac (Apple Silicon, M1/M2/M3):

- Most ML libraries now have native ARM builds.
- Docker Desktop sometimes shows "Malware Blocked" warnings on installation. Allow it in System Settings if needed.

Windows:

- Anaconda is the smoothest path for the scientific Python stack.
- For deployment modules with Docker, WSL2 with Ubuntu is what most students use.

Linux:

- Native installation works without surprises.

## Common challenges

Module 4 (model evaluation) is consistently the most challenging section. Topics like ROC curves, precision-recall trade-offs, and cross-validation can feel abstract. Allocate extra time for this module and join study groups for additional explanations.

Set up your development environment early. Document your setup process with specific versions and commands. Use version control for all your work from the beginning.

---

## File: courses/ml-zoomcamp/getting-started.md

---
title: "Getting Started"
layout: default
nav_order: 2
parent: Machine Learning Zoomcamp
has_children: false
---

# Getting Started

For the cross-course onboarding, read [Joining a Cohort]({{ '/courses/zoomcamp-logistics/joining/' | relative_url }}) first. It covers registration, account setup, calendar, and newsletter updates.

This page covers the Machine Learning Zoomcamp specifics.

## Star the GitHub repository

[github.com/DataTalksClub/machine-learning-zoomcamp](https://github.com/DataTalksClub/machine-learning-zoomcamp)

Star it so you can find it later. All course materials are here, with each module having its own folder. Cohort-specific homework and deadlines are under `cohorts/2025/`.



See [Resources]({{ '/courses/ml-zoomcamp/resources/' | relative_url }}) for more.

## Join the ML Zoomcamp Slack channel

After joining the [DataTalks.Club Slack workspace](https://datatalks.club/slack), find:

[`#course-ml-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C0288NJ5XSA)

This is your primary support and Q+A channel for the course.



## Subscribe to ML Telegram (optional, recommended)

[t.me/mlzoomcamp](https://t.me/mlzoomcamp) for course announcements. Telegram is announcement-only and is the most reliable place to catch important updates because Slack is busy.



## Subscribe to YouTube

The lectures are pre-recorded and available in the [ML Zoomcamp YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hIhxl5Ji8t4O6lPAOpHaCLR). The course is largely self-paced. Live sessions are limited to a kickoff and occasional updates.



## Bookmark the FAQ

The [Machine Learning Zoomcamp FAQ](https://datatalks.club/faq/machine-learning-zoomcamp.html) is a comprehensive resource with answers from previous cohorts. Check it before posting in Slack.



## Set up your environment

The course uses Python with scikit-learn, FastAPI for deployment, and AWS for cloud examples. See [Environment Setup]({{ '/courses/ml-zoomcamp/environment-setup/' | relative_url }}) for the choices you need to make.

## Start Module 1

Begin with [Module 1: Introduction](https://github.com/DataTalksClub/machine-learning-zoomcamp/tree/main/01-intro). For what each module covers, see [Curriculum]({{ '/courses/ml-zoomcamp/curriculum/' | relative_url }}).

## Next pages

Useful next pages:

- [Prerequisites]({{ '/courses/ml-zoomcamp/prerequisites/' | relative_url }}) - what you need to know before starting.
- [Curriculum]({{ '/courses/ml-zoomcamp/curriculum/' | relative_url }}) - the modules.
- [Environment Setup]({{ '/courses/ml-zoomcamp/environment-setup/' | relative_url }}) - Python, AWS, dev tools.
- [Project]({{ '/courses/ml-zoomcamp/project/' | relative_url }}) - the project rubric (2 of 3 projects required).
- [Resources]({{ '/courses/ml-zoomcamp/resources/' | relative_url }}) - all ML-specific links in one place.
- [What's New]({{ '/courses/ml-zoomcamp/whats-new/' | relative_url }}) - changes for the current cohort.
- [Learning in Public]({{ '/courses/zoomcamp-logistics/learning-in-public/' | relative_url }}) - hashtag for ML is `#mlzoomcamp`.

---

## File: courses/ml-zoomcamp/index.md

---
title: "Machine Learning Zoomcamp"
layout: default
nav_order: 2
parent: Courses
has_children: true
---

# Machine Learning Zoomcamp

Welcome to the 5th edition of the Machine Learning Zoomcamp. It is a completely free, hands-on course that attracts thousands of participants each year.

## Docs order

Read in this order:

1. [Community Guidelines]({{ '/general/guidelines/' | relative_url }}) - code of conduct, how to ask questions, how to use Slack channels, how to promote your work.
2. [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}) - how DataTalks.Club zoomcamps work in general (cohort schedule, joining, live sessions, homework, project, peer review, certification). Most of your logistical questions are answered there.
3. The pages in this section - what is specific to the Machine Learning Zoomcamp (curriculum, environment, project rubric, ML-specific resources).
4. The [Machine Learning Zoomcamp FAQ](https://datatalks.club/faq/machine-learning-zoomcamp.html) - module-specific and technical questions from previous cohorts.

For platform mechanics (where to click on the submission form, how the leaderboard appears), see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

---

## File: courses/ml-zoomcamp/prerequisites.md

---
title: "Prerequisites"
layout: default
nav_order: 1
parent: Machine Learning Zoomcamp
has_children: false
---

# Prerequisites

The Machine Learning Zoomcamp does not require prior ML experience. It does assume general programming literacy.

For general expectations about zoomcamp time commitment, see [Before You Start]({{ '/courses/zoomcamp-logistics/before-you-start/' | relative_url }}).

## Required skills

You need these basics:

- Strong programming experience in any major language. Python is what the course uses, but if you are proficient in another language you can pick up Python fundamentals as you go.
- Comfort with the command line, Git, and Docker basics.

## You do not need

You do not need these before starting:

- Prior machine learning experience. The course takes you from beginner to practitioner.
- Advanced math. Module 1 covers the basic linear algebra you need.
- Prior cloud experience. The course uses AWS for deployment but introduces it from scratch.
- A degree.

## Time commitment

Plan around this schedule:

- Module-week pace for the curriculum.
- Two weeks of project work followed by one week of peer review (per project).
- Plan for 10 to 15 hours per week.

The earliest you can receive your certificate is after the final project's peer-review deadline.

## Adapting to your background

Use your background to decide where to spend more time:

- Data engineers transitioning to ML: focus on the modeling modules, you can move faster on deployment.
- Infrastructure / SRE backgrounds: you can move faster on deployment modules.
- Career switchers from non-tech fields: rely on study groups and expect to spend extra time on programming basics in module 1.

For dev tools and environment choices, see [Environment Setup]({{ '/courses/ml-zoomcamp/environment-setup/' | relative_url }}).

---

## File: courses/ml-zoomcamp/project.md

---
title: "Project"
layout: default
nav_order: 6
parent: Machine Learning Zoomcamp
has_children: false
---

# Project

For the cross-course logistics, see [Final Project (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}). That page covers attempts, deadlines, peer review, and certification mechanics.

This page covers what is specific to the Machine Learning Zoomcamp.

## Project structure

The ML Zoomcamp has three project slots:

- Midterm
- Capstone
- Second capstone

To earn the certificate, complete two of three:

- Midterm + capstone, or
- Capstone + second capstone.

Each project follows a structured timeline:

- 2 weeks for development.
- 1 week for peer reviews.

You complete 3 peer reviews per project you submit.

## Required: deployed model

Every ML Zoomcamp project must include a working deployed model. You cannot just train a model in a notebook. Make it accessible through deployment to demonstrate real-world ML engineering skills.

Options for deployment:

- FastAPI in a Docker container (the course pattern).
- AWS Lambda with ONNX runtime.
- Streamlit, Gradio, or similar interactive demos that wrap your model.
- Kubernetes (EKS, kind, or minikube).

Document the deployment in your README. Peer reviewers should be able to run it themselves or evaluate the deployment from screenshots and code.

## Tech stack flexibility

You are not restricted to the technologies covered in the course. Use any framework, model architecture, or cloud provider.

Make sure to:

- Document your choices clearly. Your reviewers need full context to evaluate technologies they may not know.
- Make the project reproducible. If a reviewer cannot run it (or at least understand how it would run), you will lose reproducibility points.

## Dataset

You choose the dataset.

It should:

- Have at least 100 rows for meaningful model development.
- Be public (so peer reviewers can verify).
- Reflect a problem worth solving.

Avoid datasets that are too clean, such as Titanic or Iris. They do not let you demonstrate the data engineering and feature engineering skills the rubric looks for.

## Datasets you cannot use

You cannot use any dataset that the course uses in lectures or homework. Choose something new so the project shows your own work.

Datasets used in the course include:

- Car price prediction (Module 2 / Linear Regression).
- Customer churn / Telco (Module 3 / Binary Classification).
- Loan default (Module 6 / Tree-Based Models).
- Datasets used in the deep learning, serverless, and Kubernetes modules.

For the canonical list, see the project rubric in the course repo.

## Evaluation criteria

Each course defines its own rubric. The platform shows the exact criteria when you review or are reviewed.

Common criteria:

- Problem description and motivation.
- Data preparation and exploratory analysis.
- Model training, validation, and selection.
- Final model deployment.
- Reproducibility (can the reviewer run your code).
- Documentation quality.

The full rubric for the current cohort is on the course platform under the project window.

## Certification

Submit two of three projects on time, complete peer reviews for each, and reach the passing scores. That is the only requirement to graduate.

What is not required:

- Homework scores. Homework is for learning.
- Live session attendance.
- Leaderboard points.

The earliest you can receive your certificate is after the final project's peer-review deadline. For when the certificate is issued and how to add it to LinkedIn, see [Certification (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}).

## Past projects for inspiration

Use these examples to calibrate scope:

- [ML Zoomcamp 2025 projects](https://courses.datatalks.club/ml-zoomcamp-2025/projects)
- Browse past cohorts on the [course platform](https://courses.datatalks.club/).

## Portfolio focus

Treat every project as a portfolio piece with a meaningful repository name such as `telecom-churn-prediction-xgboost`, not `homework3`. Include comprehensive setup instructions. Past graduates have used these projects to land roles at companies like Meta and to secure ML internships.

---

## File: courses/ml-zoomcamp/resources.md

---
title: "Resources"
layout: default
nav_order: 8
parent: Machine Learning Zoomcamp
has_children: false
---

# Resources

Course-specific links for the Machine Learning Zoomcamp. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}).

## GitHub Repository

The repository is your primary navigation tool throughout the course.

[github.com/DataTalksClub/machine-learning-zoomcamp](https://github.com/DataTalksClub/machine-learning-zoomcamp)



How to use it:

1. Start in the module folder you are working on.
2. Read the README in that folder for an overview.
3. Follow the links to video lectures.
4. Complete the homework assignment.
5. Check the cohort folder under `cohorts/2025/` for cohort-specific materials.

For the module list and what each covers, see [Curriculum]({{ '/courses/ml-zoomcamp/curriculum/' | relative_url }}).

## YouTube

The lectures are pre-recorded:

[ML Zoomcamp main playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hIhxl5Ji8t4O6lPAOpHaCLR)



The course is mostly self-paced. Only a kickoff and occasional updates are streamed live. If new videos are added or workshops are scheduled, they are announced in Slack and Telegram.

## Course Platform

The [course management platform](https://courses.datatalks.club/ml-zoomcamp-2025/) is where you submit homework, track your progress, and submit your projects.



For the platform UI in detail, see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

## Slack

ML-specific channel: [`#course-ml-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C0288NJ5XSA).

Use this channel for all ML-specific questions, homework discussion, and project Q+A. For all DTC Slack channels, see the [Slack guide]({{ '/general/slack/' | relative_url }}).



## Telegram

ML announcements channel: [t.me/mlzoomcamp](https://t.me/mlzoomcamp). It is announcement-only, so questions are not monitored there.



## Newsletter

The [DataTalks.Club Newsletter](https://datatalks.club/newsletter.html) goes out every Monday with course announcements and community updates. The [newsletter archive](https://us19.campaign-archive.com/home/?u=0d7822ab98152f5afc118c176&id=97178021aa) is browsable.

## FAQ

The [Machine Learning Zoomcamp FAQ](https://datatalks.club/faq/machine-learning-zoomcamp.html) contains answers to module-specific and technical questions from previous cohorts. Check it before posting in Slack.



## Community Notes

Past cohort participants contribute notes that summarize the course content. They live in the course repository (typically under a `notes/` or per-module folder). Browse the [GitHub repo](https://github.com/DataTalksClub/machine-learning-zoomcamp) and look for community-contributed notes referenced from each module's README.

## Asking for help

For tips on writing a good question (what to include, how to format errors), see the [asking for help guide]({{ '/general/guidelines/asking-for-help/' | relative_url }}).

Most help requests benefit from including:

- The exact error message.
- A code snippet (use triple backticks for code blocks).
- Your operating system and Python version.
- A link to your GitHub repository so helpers see your full setup.

---

## File: courses/ml-zoomcamp/whats-new.md

---
title: "What's New"
layout: default
nav_order: 5
parent: Machine Learning Zoomcamp
has_children: false
---

# Changes

Notable changes for the current cohort. Older changes are folded into the curriculum.

## 2025

Main changes:

- FastAPI replaces Flask in the deployment modules. FastAPI is now the industry default for new Python APIs.
- PyTorch materials added alongside Keras. Both major deep learning frameworks are now covered.
- ONNX Runtime replaces TensorFlow Lite for serverless deployment. Better cross-framework compatibility.
- The `uv` package manager is now recommended over Conda for environment management.

For the full curriculum, see [Curriculum]({{ '/courses/ml-zoomcamp/curriculum/' | relative_url }}). For environment setup, see [Environment Setup]({{ '/courses/ml-zoomcamp/environment-setup/' | relative_url }}).

---

## File: courses/mlops-zoomcamp/curriculum.md

---
title: "Curriculum"
layout: default
nav_order: 3
parent: MLOps Zoomcamp
has_children: false
---

# Curriculum

The MLOps Zoomcamp covers six main modules plus a final project. Each module has video lectures, hands-on material, and a homework assignment.

For the canonical curriculum (videos, code, exact homework questions), see the [GitHub repository](https://github.com/DataTalksClub/mlops-zoomcamp).

## Modules

[Module 1: Introduction](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/01-intro)

- What is MLOps and why it matters.
- MLOps maturity model.
- The NY Taxi dataset used as the running example.
- Course structure and environment setup.

[Module 2: Experiment Tracking & Model Management](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/02-experiment-tracking)

- Experiment tracking with MLflow.
- Saving and loading models.
- The model registry.

[Module 3: Orchestration & ML Pipelines](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/03-orchestration)

- Turning notebooks into orchestrated ML pipelines.
- Workflow orchestration.

[Module 4: Model Deployment](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/04-deployment)

- Online vs. offline deployment.
- Web service deployment with Flask.
- Streaming deployment with AWS Kinesis and Lambda.
- Batch scoring for offline processing.

[Module 5: Model Monitoring](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/05-monitoring)

- Monitoring ML services.
- Web service monitoring with Prometheus, Evidently, and Grafana.
- Batch job monitoring with Prefect, MongoDB, and Evidently.

[Module 6: Best Practices](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/06-best-practices)

- Unit and integration testing.
- Linting, formatting, and pre-commit hooks.
- CI/CD with GitHub Actions.
- Infrastructure as Code with Terraform.

[Final Project](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/07-project)

- An end-to-end project that integrates experiment tracking, orchestration, deployment, and monitoring.

## Homework and project

Each module has a homework assignment. To earn the certificate, you also complete the final project during a live cohort. See [Project]({{ '/courses/mlops-zoomcamp/project/' | relative_url }}) for details.

---

## File: courses/mlops-zoomcamp/environment-setup.md

---
title: "Environment Setup"
layout: default
nav_order: 4
parent: MLOps Zoomcamp
has_children: false
---

# Environment Setup

The MLOps Zoomcamp uses Python with common ML and MLOps tooling: MLflow, Prefect, Docker, Evidently, Grafana, Prometheus, Terraform, and AWS for cloud examples. This page covers the high-level setup decisions. For step-by-step setup, follow the videos in [Module 1](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/01-intro).

## Where to run the course

You can work locally or on a cloud VM. Module 1 demonstrates both:

- A local machine with Python and Docker installed.
- GitHub Codespaces.
- A cloud VM (the course shows an AWS EC2 instance).

A cloud VM is convenient because the later modules use AWS services anyway, and it keeps your environment consistent.

## Python and dependency management

The course uses Python with the scientific stack (pandas, scikit-learn) plus MLOps libraries. You can manage dependencies with `uv`, conda, or pip + venv. The choice does not affect the course content.

On Windows, Anaconda is often the easiest way to get Python plus scientific libraries running. Docker Desktop covers the container side.

## Docker

Docker is used throughout the course for packaging models, running services, and reproducing environments. Install Docker and Docker Compose early. Module 1 includes the installation steps.

## Cloud (AWS)

The course uses AWS for several modules:

- Module 4 deploys a streaming service with Kinesis and Lambda.
- Module 6 provisions infrastructure with Terraform.

New AWS accounts get free tier credits. You introduce each service as the modules reach it, so you do not need prior AWS experience.

## Tools introduced per module

- Module 2: MLflow.
- Module 3: a workflow orchestrator.
- Module 4: Flask, AWS Kinesis, AWS Lambda, Docker.
- Module 5: Evidently, Grafana, Prometheus, Prefect, MongoDB.
- Module 6: pytest, pre-commit, GitHub Actions, Terraform.

Each module README lists exactly what to install for that module.

---

## File: courses/mlops-zoomcamp/getting-started.md

---
title: "Getting Started"
layout: default
nav_order: 2
parent: MLOps Zoomcamp
has_children: false
---

# Getting Started

For the cross-course onboarding, read [Joining a Cohort]({{ '/courses/zoomcamp-logistics/joining/' | relative_url }}) first. It covers registration, account setup, calendar, and newsletter updates.

This page covers the MLOps Zoomcamp specifics.

## Star the GitHub repository

[github.com/DataTalksClub/mlops-zoomcamp](https://github.com/DataTalksClub/mlops-zoomcamp)

Star it so you can find it later. All course materials are here, with each module having its own folder. Cohort-specific homework and deadlines are under the `cohorts/` folder.

See [Resources]({{ '/courses/mlops-zoomcamp/resources/' | relative_url }}) for more.

## Join the MLOps Zoomcamp Slack channel

After joining the [DataTalks.Club Slack workspace](https://datatalks.club/slack), find the `#course-mlops-zoomcamp` channel. This is where questions, announcements, and discussion happen.

Before asking questions, read [Asking Questions]({{ '/courses/zoomcamp-logistics/asking-questions/' | relative_url }}) and the [community guidelines](https://datatalks.club/slack/guidelines.html).

## Follow the announcements

So you don't miss anything:

- Join the [course Telegram channel with announcements](https://t.me/dtc_courses).
- Subscribe to the [DataTalks.Club YouTube channel](https://www.youtube.com/c/DataTalksClub) and check the [course playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hIUISrluw_A7wDSmfOhErJK).

Course announcements, including when certificates are ready, go out in Slack and Telegram.

## Watch the course videos

All lectures are on the [course YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hIUISrluw_A7wDSmfOhErJK). The repository README and each module folder link to the relevant videos in order.

## Set up your environment

Module 1 walks through environment setup, including Python, Docker, and an optional cloud VM. See [Environment Setup]({{ '/courses/mlops-zoomcamp/environment-setup/' | relative_url }}) for the high-level decisions before you start.

## How to work through the course

1. Start in the module folder you are working on.
2. Read the README in that folder for an overview.
3. Follow the links to the video lectures.
4. Complete the homework assignment.
5. Check the cohort folder for cohort-specific materials and deadlines.
6. Finish with the final project, which ties the modules together.

## Getting your certificate

Completing the final project during a live cohort earns you the certificate. See [Certification]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}) for how it is issued and how to add it to LinkedIn.

---

## File: courses/mlops-zoomcamp/index.md

---
title: "MLOps Zoomcamp"
layout: default
nav_order: 5
parent: Courses
has_children: true
---

# MLOps Zoomcamp

Welcome to the MLOps Zoomcamp. It is a completely free, hands-on course on productionizing machine learning services, from training and experimentation to deployment and monitoring.

## Docs order

Read in this order:

1. [Community Guidelines]({{ '/general/guidelines/' | relative_url }}) - code of conduct, how to ask questions, how to use Slack channels, how to promote your work.
2. [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}) - how DataTalks.Club zoomcamps work in general (cohort schedule, joining, live sessions, homework, project, peer review, certification). Most of your logistical questions are answered there.
3. The pages in this section - what is specific to the MLOps Zoomcamp (curriculum, environment, project, MLOps-specific resources).
4. The [MLOps Zoomcamp FAQ](https://datatalks.club/faq/mlops-zoomcamp.html) - module-specific and technical questions from previous cohorts.

For platform mechanics (where to click on the submission form, how the leaderboard appears), see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

## Current status

The MLOps Zoomcamp is currently available for self-paced study. We don't plan to run a live cohort in 2026. [Register here](https://courses.datatalks.club/register/mlops-zoomcamp/) if you'd like to be notified in case we run it again.

---

## File: courses/mlops-zoomcamp/prerequisites.md

---
title: "Prerequisites"
layout: default
nav_order: 1
parent: MLOps Zoomcamp
has_children: false
---

# Prerequisites

The MLOps Zoomcamp builds on existing machine learning and programming experience. It is not a beginner ML course; it teaches you how to take models you already know how to build and run them in production.

For general expectations about zoomcamp time commitment, see [Before You Start]({{ '/courses/zoomcamp-logistics/before-you-start/' | relative_url }}).

## Required skills

You need these basics:

- Python programming.
- Comfort with the command line.
- Docker basics.
- Machine learning fundamentals: training a model, evaluating it, and understanding the typical ML workflow. The [Machine Learning Zoomcamp](https://github.com/DataTalksClub/machine-learning-zoomcamp) is a good way to cover this.
- At least 1 year of programming experience.

## You do not need

You do not need these before starting:

- Prior MLOps or DevOps experience. The course introduces experiment tracking, orchestration, deployment, and monitoring from the ground up.
- Prior cloud experience. The course uses AWS but introduces the services it relies on.
- Deep math. The focus is on engineering and operations, not modeling theory.

## If you are missing a prerequisite

If you are new to machine learning, take the [Machine Learning Zoomcamp](https://github.com/DataTalksClub/machine-learning-zoomcamp) first. If you are comfortable building models but new to Python tooling, Docker, or the command line, work through Module 1, which covers environment setup before the MLOps content begins.

---

## File: courses/mlops-zoomcamp/project.md

---
title: "Project"
layout: default
nav_order: 6
parent: MLOps Zoomcamp
has_children: false
---

# Project

For the cross-course logistics, see [Final Project (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}). That page covers attempts, deadlines, peer review, and certification mechanics.

This page covers what is specific to the MLOps Zoomcamp.

## Goal

The project is an end-to-end MLOps pipeline. You pick a problem and a dataset, train a model, and then apply the practices from the course to put it into production and operate it.

## What the project should demonstrate

A complete project applies the modules together:

- A clear problem description.
- Experiment tracking and a model registry (Module 2).
- A training pipeline that can be run reproducibly (Module 3).
- Model deployment, as a web service, streaming, or batch (Module 4).
- Model monitoring (Module 5).
- Best practices: tests, linting, CI/CD, and Infrastructure as Code where appropriate (Module 6).
- Reproducibility: clear instructions and pinned dependencies so a reviewer can run it.

## Where to find the details

The [07-project folder](https://github.com/DataTalksClub/mlops-zoomcamp/tree/main/07-project) in the repository contains the project instructions and the evaluation criteria. The rubric there is the authoritative description of what is graded.

## Certificate

Completing the project during a live cohort is how you earn the certificate. Since there is no live 2026 cohort, the project is currently for self-assessment and portfolio building. See [Certification]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}) for how the certificate is issued, the cross-course rules, and how to add it to LinkedIn.

---

## File: courses/mlops-zoomcamp/resources.md

---
title: "Resources"
layout: default
nav_order: 7
parent: MLOps Zoomcamp
has_children: false
---

# Resources

Course-specific links for the MLOps Zoomcamp. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}).

## GitHub Repository

The repository is your primary navigation tool throughout the course.

[github.com/DataTalksClub/mlops-zoomcamp](https://github.com/DataTalksClub/mlops-zoomcamp)

How to use it:

1. Start in the module folder you are working on.
2. Read the README in that folder for an overview.
3. Follow the links to video lectures.
4. Complete the homework assignment.
5. Check the cohort folder for cohort-specific materials.

## Video lectures

All lectures are on the [course YouTube playlist](https://www.youtube.com/playlist?list=PL3MmuxUbc_hIUISrluw_A7wDSmfOhErJK).

## FAQ

The [MLOps Zoomcamp FAQ](https://datatalks.club/faq/mlops-zoomcamp.html) collects module-specific and technical questions from previous cohorts.

## Slack

Questions and discussion happen in the `#course-mlops-zoomcamp` channel on [DataTalks.Club Slack](https://datatalks.club/slack.html). Read [Asking Questions]({{ '/courses/zoomcamp-logistics/asking-questions/' | relative_url }}) first.

## Tools used in the course

- [MLflow](https://mlflow.org/) - experiment tracking and model registry.
- [Prefect](https://www.prefect.io/) - workflow orchestration.
- [Evidently](https://www.evidentlyai.com/) - data and model monitoring.
- [Grafana](https://grafana.com/) and [Prometheus](https://prometheus.io/) - metrics and dashboards.
- [Docker](https://www.docker.com/) - containerization.
- [Terraform](https://www.terraform.io/) - Infrastructure as Code.
- [AWS](https://aws.amazon.com/) - cloud deployment (Kinesis, Lambda).

---

## File: courses/mlops-zoomcamp/whats-new.md

---
title: "What's New"
layout: default
nav_order: 5
parent: MLOps Zoomcamp
has_children: false
---

# Changes

Notable points about the current state of the course.

## Current status

The MLOps Zoomcamp is in self-paced mode. We don't plan to run a live cohort in 2026. All materials remain freely available, and the GitHub repository is the source of truth for the latest content.

For the canonical list of changes, follow the commit history and module READMEs in the [GitHub repository](https://github.com/DataTalksClub/mlops-zoomcamp). Materials from previous cohorts are preserved under the `cohorts/` folder.

For the full curriculum, see [Curriculum]({{ '/courses/mlops-zoomcamp/curriculum/' | relative_url }}). For environment setup, see [Environment Setup]({{ '/courses/mlops-zoomcamp/environment-setup/' | relative_url }}).

---

## File: courses/stock-markets-analytics-zoomcamp/curriculum.md

---
title: "Curriculum"
layout: default
nav_order: 3
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Curriculum

The Stock Market Analytics Zoomcamp covers five modules plus a final project. Each module has a lecture and a homework assignment.

The modules build on each other. You start with data sources, combine them into one dataset, train a model on it, define a trading strategy on top of the predictions, and finally automate the whole workflow.

For the canonical curriculum (videos, code, exact homework), see the [GitHub repository](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp).

## Modules

[Module 1: Introduction and Data Sources](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp/tree/main/01-intro-and-data-sources)

- Data-driven decisions, the mindset of a long-term investor versus a short-term trader, and the landscape of personal investment options.
- Risk and reward.
- Setting up Google Colab and downloading your first financial data with yfinance.
- Choosing APIs as the primary data source, free versus paid, plus a brief look at web scraping and alternative data.

[Module 2: Working with the Data in Pandas](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp/tree/main/02-dataframe-analysis)

- Numpy, pandas, matplotlib, seaborn, and Plotly Express.
- Data types and manipulation, and the specifics of time series data.
- Feature generation: growth over different periods, hour and day of week, and technical indicators through TA-Lib.
- Data cleaning, joining multiple datasets, and descriptive and correlation analysis.

[Module 3: Analytical Modeling](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp/tree/main/03-modeling)

- Framing a hypothesis and turning it into a prediction problem.
- Heuristics and hand rules before any machine learning, which is where classical technical analysis fits.
- Time series predictions: trend, seasonality, and remainder.
- Regression and binary classification for the direction of growth, with neural networks as an optional extra.
- Feeding a large set of generated technical indicators into a model instead of hand-picking a few.

[Module 4: Trading Strategy and Simulation](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp/tree/main/04-trading-strategy-and-simulation)

- What a trading strategy adds on top of a model: when to trade, at what size, how to combine predictions, and how to time entry.
- Trading fees and why they decide whether a high-frequency idea can work at all.
- Strategy examples: single stock investment, diversified portfolios, market-neutral long and short positions, mean reversion, pairs trading, dividend strategies, and basic options.
- Simulating financial results on historical data, with metrics that differ from the model quality metrics of Module 3.
- Screenshots from real trading platforms such as Interactive Brokers and Degiro.

[Module 5: Deployment and Automation](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp/tree/main/05-deployment-and-automation)

- Moving from Colab notebooks to Python files that run from the command line.
- Persistent storage: files versus a simple database.
- Scheduling the workflow with cron jobs, GitHub Actions, or a workflow tool.
- Generating predictions systematically and monitoring the result, including email or chat notifications.

[Project](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp/tree/main/projects)

- Two weeks of work on your own project, then one week of peer review.

## Outside the scope

Some topics are deliberately left out:

- High-frequency and real-time trading. Real-time data is a paid product, and the course is designed to be free to complete.
- Connecting to a broker API to place trades automatically. The workflow produces a list of tickers you act on yourself.
- Market microstructure, personal finance management, and portfolio or risk management as standalone topics.

## Homework and project

Each module has a homework assignment. Most questions have a numeric or multiple-choice answer, with a few open-ended ones. Homework is scored and shown on the leaderboard, but it is not required for the certificate. To earn the certificate you complete the project and review three peers' projects during a live cohort. See [Project]({{ '/courses/stock-markets-analytics-zoomcamp/project/' | relative_url }}).

Each homework submission accepts up to 3 learning-in-public links, one point each. See [Learning in Public]({{ '/courses/zoomcamp-logistics/learning-in-public/' | relative_url }}).

---

## File: courses/stock-markets-analytics-zoomcamp/environment-setup.md

---
title: "Environment Setup"
layout: default
nav_order: 4
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Environment Setup

The course is designed to be completed for free, and a browser is enough for the first four modules.

## Where you write code

You have two environments during the course:

- Google Colab for Modules 1 to 4. All notebooks are shared so you can copy one, run it under your own account, and change parameters or markets.
- A local editor such as VS Code for Module 5, when notebooks become Python files.

## Python libraries

The stack is the standard analyst toolkit:

- numpy and pandas for the data work.
- matplotlib, seaborn, and Plotly Express for charts.
- TA-Lib for technical indicators.
- scikit-learn and similar libraries for the models.

## Data sources

The course does not provide a dataset. You download the data yourself, which is part of the point.

- yfinance is the default. It is a free, unofficial Yahoo Finance library with data on thousands of tickers across many exchanges. It occasionally goes down, and its data is delayed by 15 to 20 minutes, which is fine for weekly or monthly predictions.
- Alpha Vantage is a paid source with a free tier of 25 API calls. It is worth it for fundamental data over long histories, which is close to impossible to scrape.
- polygon.io has a free tier and a paid one, and is used for news data.

Paid data starts to make sense at around 10 to 50 dollars per month if you are actually trading. If you are only learning, the free sources are enough.

Real-time streaming data is not used in the course. It costs money everywhere, and the course is meant to be free to complete.

## Automation and deployment

Later cohorts moved away from cloud and Docker so the focus stays on analysis and simulation.

A no-cloud setup that costs nothing:

- GitHub Actions for scheduled workflows.
- A local or hosted database for storing the data.
- Streamlit for the dashboard.

Cron jobs on your own machine and a simple SQLite database also work. The two prep workshops linked from [Resources]({{ '/courses/stock-markets-analytics-zoomcamp/resources/' | relative_url }}) walk through this setup end to end.

## Brokerage account

Optional. You do not need one to complete the course or the project. If you want to place the trades your model suggests, you need an account with a broker; the course shows interfaces from Interactive Brokers, Degiro, and Trade Republic. Banking apps that offer stock trading usually cover only a limited set of tickers.

---

## File: courses/stock-markets-analytics-zoomcamp/getting-started.md

---
title: "Getting Started"
layout: default
nav_order: 2
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Getting Started

For the cross-course onboarding, read [Joining a Cohort]({{ '/courses/zoomcamp-logistics/joining/' | relative_url }}) first. It covers registration, account setup, calendar, and newsletter updates.

This page covers the Stock Market Analytics Zoomcamp specifics.

## Star the GitHub repository

[github.com/DataTalksClub/stock-markets-analytics-zoomcamp](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp)

All course materials are here. Each module has its own folder (for example `01-intro-and-data-sources`, `03-modeling`), and cohort-specific homework and deadlines are under the `cohorts` folder. Starring the repo helps other people find the course.

## Register

Registration happens on the [PythonInvest course page](https://pythoninvest.com/course). It is optional and free, and it is how you get cohort announcements by email.

## Join the Slack channel

After joining the [DataTalks.Club Slack workspace](https://datatalks.club/slack), find the `#course-stocks-analytics-zoomcamp` channel. This is where questions, announcements, and discussion happen. Before asking, read [Asking Questions]({{ '/courses/zoomcamp-logistics/asking-questions/' | relative_url }}).

## Follow the announcements

So you don't miss anything:

- Join the [course Telegram channel](https://t.me/stockanalyticszoomcamp).
- Subscribe to the [PythonInvest YouTube channel](https://www.youtube.com/@pythoninvest), where the lectures for this course are published, and turn on notifications so you do not miss a stream.

## How to work through the course

Use this order:

1. Watch the launch and Q&A session for the cohort to see how the course is organized.
2. Read the README in each module folder for an overview and video links.
3. Watch the lectures and do the homework. Aim for at least one or two questions from every homework even when you are short on time.
4. Start thinking about the project early. Many participants build it as they go through the modules rather than waiting for the submission window.
5. Submit the project, then review three peers' projects.

See [Environment Setup]({{ '/courses/stock-markets-analytics-zoomcamp/environment-setup/' | relative_url }}) for the tools and data sources you will use.

## Starting before a cohort

Materials change little between cohorts, so working through the previous cohort's modules is a good way to prepare. It also tells you whether your Python and pandas are strong enough, with time to catch up before the start.

---

## File: courses/stock-markets-analytics-zoomcamp/index.md

---
title: "Stock Market Analytics Zoomcamp"
layout: default
nav_order: 7
parent: Courses
has_children: true
---

# Stock Market Analytics Zoomcamp

Welcome to the Stock Market Analytics Zoomcamp. It is a completely free, hands-on course that takes you from financial data sources to a predictive model, a trading strategy, and an automated workflow that runs on its own.

The course is run together with [PythonInvest](https://pythoninvest.com/course). Ivan Brigida, a business intelligence analyst and retail investor, is the instructor.

## Disclaimer

This course is educational. Nothing in it is investment advice, and there is no guarantee of profitability. The instructors are not professional market participants and are not liable for any losses. If you trade with your own money, you make those decisions yourself.

## Docs order

Read in this order:

1. [Community Guidelines]({{ '/general/guidelines/' | relative_url }}) - code of conduct, how to ask questions, how to use Slack channels.
2. [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}) - how DataTalks.Club zoomcamps work in general (joining, live sessions, homework, project, peer review, certification). Most of your logistical questions are answered there.
3. The pages in this section - what is specific to the Stock Market Analytics Zoomcamp (curriculum, data sources, project, resources).
4. The [Stock Market Analytics Zoomcamp FAQ](https://datatalks.club/faq/stock-markets-analytics-zoomcamp.html) - module-specific and technical questions from previous cohorts.

For platform mechanics (where to click on the submission form, how the leaderboard appears), see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

## Current status

Two cohorts have run so far: the first in April 2024 and the second in May 2025. Between cohorts all materials stay available for self-paced study in the [GitHub repository](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp). [Register on the PythonInvest course page](https://pythoninvest.com/course) to be notified about the next cohort.

---

## File: courses/stock-markets-analytics-zoomcamp/prerequisites.md

---
title: "Prerequisites"
layout: default
nav_order: 1
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Prerequisites

This is not a beginner course. It assumes you can already program and analyze data, and it teaches you how to apply those skills to financial markets. Trading experience is not required.

For general expectations about zoomcamp time commitment, see [Before You Start]({{ '/courses/zoomcamp-logistics/before-you-start/' | relative_url }}).

## Required skills

You need these basics:

- Python programming at an intermediate level. All course code is Python, and every homework requires writing code.
- Data analysis with pandas. The course uses time series operations that go beyond the basics.
- An experimental and creative mindset. There is no single path to a good model or a profitable strategy, so you need to be comfortable forming a hypothesis and testing it quickly.
- Interest in financial markets and investing.

The coding is not complicated: no object-oriented programming and no advanced data structures. If you have a few years of experience in any language, you will manage.

## You do not need

You do not need these before starting:

- Trading experience. Most participants in previous cohorts had never placed a trade.
- A brokerage account. You can complete the whole course without ever placing a trade, though opening an account makes the material sink in faster.
- A finance or economics background. Economic concepts are explained as they come up.
- Deep statistics. Some distributions and statistical models appear, but without deriving what happens under the hood.
- Time series experience. It helps, but the [Predicting Financial Time-Series workshop](https://www.youtube.com/watch?v=PxAh08Pcmj4) covers what you need.

## Time commitment

Plan for 10 to 15 hours per week. In previous cohorts participants reported roughly 4 hours on lectures and 5 or more hours on homework per module, with the first modules being the most intense.

The project takes around 20 hours for most people. Taking this course in parallel with another zoomcamp is possible but demanding.

## If you are a beginner

You can still finish, but expect it to cost you much more time. One participant in the 2024 cohort came from a non-technical background and spent about 100 hours on the project, compared to about 20 hours for most others.

If you want to prepare, take a short course on Python and pandas first, and work through the previous cohort's materials in the [GitHub repository](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp) to check whether the level suits you.

---

## File: courses/stock-markets-analytics-zoomcamp/project.md

---
title: "Project"
layout: default
nav_order: 6
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Project

For the cross-course logistics, see [Final Project (Zoomcamp Logistics)]({{ '/courses/zoomcamp-logistics/project/' | relative_url }}). That page covers attempts, deadlines, peer review, and certification mechanics.

This page covers what is specific to the Stock Market Analytics Zoomcamp.

## Goal

Build your own analytics and prediction system for a financial market. You pick the data, generate features, train a model, define a trading strategy on top of the predictions, and simulate the results. Ideally you also automate the workflow so it runs without you.

The project is the only requirement for the certificate. You can skip every homework and still graduate, though homework earns leaderboard points and is good preparation.

## Choosing a market

The course uses large US stocks, but the approach transfers:

- Any stock exchange works. Yahoo Finance covers thousands of tickers, including Indian, European, and other markets. You may need to convert positions to a single currency if you mix markets.
- ETFs, crypto, forex, and commodities work too. For crypto, expect to rely on technical indicators, since the macroeconomic and fundamental data used for stocks does not apply.
- Futures, options, and other derivatives are harder: good historical data is expensive and the modeling needs extra features.

Building a project about your local market is genuinely interesting, since most public analysis covers the same handful of big American companies.

## What fits and what does not

Good fits:

- Predictive modeling on time series price data.
- Quantitative trading strategies and backtesting or simulation.
- An automated workflow that refreshes predictions on a schedule.

Not what this course prepares you for:

- Personal finance management, expense tracking, or portfolio and risk management as the main topic.
- High-frequency trading and market microstructure.
- Sentiment analysis as the core idea. It is allowed, but long histories of news data are paid, and you may need to settle for two to five years of data rather than the 25 years available for prices.

## Practical advice

A few things that make the project go better:

- Start early. Many participants build the project as they work through the modules, and submissions appear the moment the form opens.
- Most people spend around 20 hours on it. Those coming from a non-technical background have spent considerably more.
- Projects are solo. You can discuss ideas, form study groups, and hold each other accountable, but the code you submit must be your own.
- Use GitHub for the project. Colab links are acceptable for homework, but the project should be a public repository a reviewer can read and run.
- Reviewing three peers' projects is required. Looking at previous cohorts' projects in the repository is also the fastest way to understand what a good submission looks like.

## Disclaimer

There is no expectation of a profitable strategy, and no guarantee of one. The project is graded on the analysis and the engineering, not on returns. Nothing you build here is investment advice, and if you trade with your own money you do so at your own risk.

## Certificate

Completing the project and reviewing three peers' projects during a live cohort earns the certificate, signed by the instructors. See [Certification]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}) for how it is issued and how to add it to LinkedIn.

---

## File: courses/stock-markets-analytics-zoomcamp/qa.md

---
title: "Q&A"
layout: default
nav_order: 8
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Questions and Answers

Questions about the scope and philosophy of this course, collected from the cohort launch sessions. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}). For module-specific and technical issues, check the [Stock Market Analytics Zoomcamp FAQ](https://datatalks.club/faq/stock-markets-analytics-zoomcamp.html).

## Automated trading bots

The course does not build a bot that places trades on its own. It ends at a workflow that produces a list of tickers to buy or sell, which you then act on manually. Connecting to a broker API and automating execution would take roughly as many lectures again as the course already has.

Keeping a human in the loop is also good practice: check the predictions against the previous week's output before money moves.

## Real-time and high-frequency trading

Not covered. Real-time data costs money everywhere, and the course is designed to be completable for free. Predictions in the course are made once per day, with a prediction horizon of a week or a month.

Everything you learn does apply to faster setups, but you would be paying for the data. And with high trade frequency, broker fees quickly eat the returns.

## Trading fees

Fees matter more than most people expect. In the instructor's own experience of a 40 percent return over two months, roughly a third of the return went to commissions. Fees are the first thing to consider when designing an algorithmic strategy: trade only on the predictions you are most confident in, or limit the number of trades.

## Crypto, forex, and non-US markets

All of them work. Any stock exchange available through Yahoo Finance is fair game, including Indian and European markets; you may need to convert positions to a common currency if you mix them.

Crypto works too, with one caveat. The macroeconomic and fundamental data sources used for stocks do not apply, so you would use technical indicators instead. ETFs, futures, and commodities are also possible, though derivatives need historical data that is expensive to get.

## News and sentiment analysis

Covered only in passing. The instructor wrote articles on it and did not find a strategy that worked. News histories long enough to model are paid, coverage is biased toward big companies, and articles usually appear after the move has already happened.

You can still use sentiment as a project feature. Expect to work with two to five years of data rather than the 25 years available for prices.

## Quant jobs

This course does not prepare you for one directly. Quant hiring runs through multi-stage competitions that test math and problem-solving speed rather than the analysis skills taught here.

Real experience does help: if you build something you run with your own money, that is credible in a way a portfolio project is not.

## Brokerage account

Not needed. No homework or project requires one. It does change how you engage with the material, though, because betting real money makes you think much harder about what your model actually claims.

## AI tools

Allowed, for homework and for the project. AI-assisted coding removes barriers when you do not know a library, and it gets you to a working baseline quickly. It is much weaker at the parts that matter here: optimizing models, improving prediction quality, and connecting the pieces into something that works end to end. Use it, but check the output. See [Using AI Tools]({{ '/courses/zoomcamp-logistics/ai-usage/' | relative_url }}).

## Taking two zoomcamps in parallel

Possible, but demanding. Each course is 10 to 15 hours per week, so two of them mean 20 to 30 hours on top of a job. Doable if your schedule genuinely has the room.

## Solo versus group work

Projects are solo, as in all DataTalks.Club zoomcamps. It scales better and peer review is much easier. You are encouraged to discuss ideas in Slack, form study groups, and hold each other accountable, but the code you submit must be your own.

## Finishing early

You can work through the modules and even build the project as fast as you like. The project can only be submitted once the window opens, though, and peer review happens for everyone in the same week, so the certificate does not come earlier. See [Certification]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}).

## Value of the certificate

The certificate is a PDF with your name and the instructors' signatures, plus a unique URL you can add to LinkedIn. It does not replace a university degree. The project behind it does the convincing: it is public, and any analyst or trader can look at it.

## Profitability

There are no guarantees. The course teaches how to do the analysis, not what to buy or when. Losses are possible, the instructors are not professional market participants or licensed advisers, and nothing in the course is investment advice.

---

## File: courses/stock-markets-analytics-zoomcamp/resources.md

---
title: "Resources"
layout: default
nav_order: 7
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Resources

Course-specific links for the Stock Market Analytics Zoomcamp. For general zoomcamp logistics, see [Zoomcamp Logistics]({{ '/courses/zoomcamp-logistics/' | relative_url }}).

## GitHub repository

[github.com/DataTalksClub/stock-markets-analytics-zoomcamp](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp)

Each module has its own folder with a README, video links, and homework. Cohort-specific homework, deadlines, and past materials are under the `cohorts` folder.

## Video lectures

Lectures for this course are published on the [PythonInvest YouTube channel](https://www.youtube.com/@pythoninvest), not the DataTalks.Club channel.

- [2025 cohort playlist](https://www.youtube.com/playlist?list=PLSWnIAnueyu8KBcwhE48ASp20nZMg2qtt)
- [2024 cohort playlist](https://www.youtube.com/playlist?list=PLSWnIAnueyu8auG0v3VXfUkVJpLoeCJYF)

Launch and Q&A sessions, a good place to start:

- [2025 pre-launch and Q&A](https://www.youtube.com/watch?v=1N1jIwa1uag)
- [2024 launch and Q&A](https://www.youtube.com/watch?v=oswTLnjkRUg)

## Prep workshops

Two recorded workshops show what a good capstone or automation project looks like:

- [Economics and Automation: Building a Data Pipeline for Economic Insights](https://www.youtube.com/watch?v=MeDUe75WQaQ)
- [Predicting Financial Time-Series](https://www.youtube.com/watch?v=PxAh08Pcmj4)

Watch both before the course starts, then fork the code and run it.

## FAQ

The [Stock Market Analytics Zoomcamp FAQ](https://datatalks.club/faq/stock-markets-analytics-zoomcamp.html) collects module-specific and technical questions from previous cohorts.

## Slack

Questions and discussion happen in the `#course-stocks-analytics-zoomcamp` channel on [DataTalks.Club Slack](https://datatalks.club/slack.html). Read [Asking Questions]({{ '/courses/zoomcamp-logistics/asking-questions/' | relative_url }}) first.

## PythonInvest

The instructor writes long-read analytical articles on stock market analytics:

- [PythonInvest blog](https://pythoninvest.com/blog)
- [Financial news feed](https://pythoninvest.com/)
- [Course page and registration](https://pythoninvest.com/course)

## Tools and data sources used in the course

- [Google Colab](https://colab.research.google.com/) - where most of the course code runs.
- [yfinance](https://pypi.org/project/yfinance/) - free price data across many exchanges.
- [Alpha Vantage](https://www.alphavantage.co/) and [polygon.io](https://polygon.io/) - fundamental data and news, with free tiers.
- [TA-Lib](https://ta-lib.org/) - technical indicators.
- pandas, numpy, matplotlib, seaborn, and [Plotly Express](https://plotly.com/python/plotly-express/).
- [Streamlit](https://streamlit.io/) and GitHub Actions - dashboards and scheduled workflows.

## Suggested reading

These sources help you pick a project idea:

- [Simply Wall St Market Insights](https://simplywall.st/markets/insights)
- [Investing on CNBC](https://www.cnbc.com/investing/)
- [Unhedged](https://unhedged.ft.com/)
- [Yahoo Finance](https://finance.yahoo.com/)

Books recommended in the repository:

- The Trading Game: A Confession, by Gary Stevenson
- Unknown Market Wizards, by Jack Schwager
- The Man Who Solved the Market, by Gregory Zuckerman
- The Tao of Trading, by Simon Ree
- The Unlucky Investor's Guide to Options Trading, by Julia Spina

---

## File: courses/stock-markets-analytics-zoomcamp/whats-new.md

---
title: "What's New"
layout: default
nav_order: 5
parent: Stock Market Analytics Zoomcamp
has_children: false
---

# Changes

Notable points about the current state of the course.

## Cohorts

Two cohorts have run so far:

- 2024: the first cohort, started 15 April 2024.
- 2025: the second cohort, started 19 May 2025.

Between cohorts the course is available for self-paced study, and all materials stay in the GitHub repository. Materials from previous cohorts are preserved under the `cohorts` folder, including recordings, slides, homework, and past projects.

## Changes in the 2025 cohort

The core content stayed the same as in 2024.

These were the differences:

- A streamlined path. Research-style, open-ended homework questions were reduced so the course is doable with less time.
- New features in the data, such as tariffs and the performance of European or Chinese markets, to reflect the current economic environment.
- Less cloud and Docker in the automation module, in favor of GitHub Actions, a database, and Streamlit.
- More AI-assisted coding in the lectures.
- Two recorded prep workshops released before the cohort. See [Resources]({{ '/courses/stock-markets-analytics-zoomcamp/resources/' | relative_url }}).

Trading strategies also shifted with the market: after the 2025 market decline, market-neutral strategies with both long and short positions got more attention than single-stock long strategies.

## Where to check for the latest

Follow the module READMEs in the [GitHub repository](https://github.com/DataTalksClub/stock-markets-analytics-zoomcamp), plus the announcements in Slack and Telegram. Cohort dates appear on the [PythonInvest course page](https://pythoninvest.com/course).

---

## File: courses/zoomcamp-logistics/ai-usage.md

---
title: "AI Usage Policy"
layout: default
nav_order: 4
parent: Course Work
grand_parent: Zoomcamp Logistics
---

# AI Usage Policy

You can use AI tools for homework, projects, and peer reviews.

Common tools include:

- ChatGPT
- Claude
- Gemini
- Cursor
- GitHub Copilot

Follow these rules to use AI productively.

## The policy

Use AI freely, but understand what you submit.

The expectation is not that you avoid AI - it is that you stay engaged with the work. If an AI generates code, read the code. If an AI suggests an architecture, understand why. If you submit something you cannot explain, you have wasted the learning opportunity.

## In homework

AI is allowed for homework. Most homework asks for a numerical answer or a small piece of code. There is no enforcement against using AI to solve homework, and we do not check.

If you do use AI:

- Make sure you understand the answer. Homework is your check that you absorbed the module.
- Try the question yourself first. AI is most useful for getting unstuck, not for skipping the work.

## In the project

AI is allowed for the project too. Many participants use Cursor, Claude, or similar coding assistants to speed up development.

What we ask:

- Understand every decision. If a peer reviewer asks why you chose a particular orchestrator or schema, you should be able to explain it.
- Document your AI usage in the README if AI shaped major decisions. This is good practice and helps reviewers.
- The project should reflect your understanding, not just AI output. A project where everything was clearly generated without engagement is unlikely to teach you anything and will not strengthen your portfolio.

We cannot enforce this. Some people will still ask AI to implement everything end to end. The "vibe coding" approach is technically possible.

The cost is yours. You do not get the learning benefit. You end up with a portfolio piece you cannot defend in an interview.

## In peer review

AI is allowed for drafting reviews. But do not let the LLM do the whole thing without looking at the project. Reading other people's code is one of the best learning opportunities in the course.

If you suspect a project was AI-generated end to end, do not feel obligated to reproduce everything. Score against the rubric and move on. You do not have to grade harder because you suspect AI use. Review what is in front of you.

## Disclosing AI usage

You are not required to disclose AI usage. There is no special form or honor code to sign. We trust participants to use AI in a way that helps them learn.

If your project README mentions "I used Cursor and Claude during development", that is helpful for reviewers but not required.

## Helpful AI usage

Helpful AI usage includes:

- Asking AI to explain a concept you found confusing in the lecture.
- Using a coding assistant to write boilerplate (Dockerfiles, Terraform stubs, dbt model skeletons).
- Asking AI to debug an error message before posting in Slack.
- Using AI to draft your README and then editing it.
- Asking AI to suggest improvements to your project, then evaluating which suggestions to apply.

## Counterproductive AI usage

Counterproductive AI usage includes:

- Asking AI to do the project end to end, then submitting without reading the code.
- Asking AI to write your peer review without looking at the project.
- Asking AI to write your learning-in-public post about a module you have not actually engaged with - the post will be generic and will not earn you the engagement those posts are meant to build.

---

## File: courses/zoomcamp-logistics/asking-questions.md

---
title: "Asking Questions"
layout: default
nav_order: 5
parent: Communication
grand_parent: Zoomcamp Logistics
---

# Asking Questions

If you have a course question, ask it in the course-specific Slack channel. Use the course FAQ first, then post in Slack if you still need help. Do not ask technical questions in Telegram. Telegram is for announcements.

Course channels and FAQs:

- Data Engineering Zoomcamp: [`#course-data-engineering`](https://app.slack.com/client/T01ATQK62F8/C01FABYF2RG), [FAQ](https://datatalks.club/faq/data-engineering-zoomcamp.html).
- Machine Learning Zoomcamp: [`#course-ml-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C0288NJ5XSA), [FAQ](https://datatalks.club/faq/machine-learning-zoomcamp.html).
- MLOps Zoomcamp: [`#course-mlops-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C02R98X7DS9), [FAQ](https://datatalks.club/faq/mlops-zoomcamp.html).
- LLM Zoomcamp: [`#course-llm-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C06TEGTGM3J), [FAQ](https://datatalks.club/faq/llm-zoomcamp.html).
- AI Dev Tools Zoomcamp: [`#course-ai-dev-tools-zoomcamp`](https://app.slack.com/client/T01ATQK62F8/C09HWT76L95).
- Stock Market Analytics Zoomcamp: [`#course-stocks-analytics-zoomcamp`](https://datatalks-club.slack.com/archives/C06L1RTF10F).

For Slack norms that apply across all DataTalks.Club channels, see [Community Guidelines]({{ '/general/guidelines/' | relative_url }}) and [Slack channels]({{ '/general/slack/' | relative_url }}). For which channel to use for what, see [Communication Channels]({{ '/courses/zoomcamp-logistics/communication/' | relative_url }}).

## Before Asking

Try to narrow the problem first. You do not need to solve it alone. A few minutes of investigation makes it much easier for others to help.

1. Read the error message carefully. Check whether it names a file, line number, missing dependency, missing environment variable, port conflict, or permission problem.
2. Check the course FAQ and the module README.
3. Search Slack for the exact error message.
4. Search the web using the tool name and the core error text.
5. Check the documentation for the tool you are using.
6. Restart the application, notebook kernel, Docker container, or terminal session if the problem looks state-related.
7. If the setup may be broken, try reinstalling or recreating the environment, then record what changed.

It is normal for technical problems to take time. If you are stuck after trying the steps above, ask in Slack.

## If You Cannot Find the Problem

Sometimes the hard part is not fixing the problem. The hard part is figuring out where it starts. In that case, write down what you know:

- The last step that worked.
- The first step that failed.
- What you expected to happen.
- What actually happened.
- What changed since it last worked: code, data, dependency versions, environment variables, Docker image, notebook kernel, cloud resource, or operating system.

Then try to make the problem smaller:

1. Run the command again from a clean terminal and copy the full output.
2. Remove unrelated code or steps until you have the smallest example that still fails.
3. Check whether the problem happens in the course example code or only in your own code.
4. Check whether the problem happens after restarting the service, container, notebook kernel, or machine.
5. Compare your command, file path, environment variables, and versions with the lesson instructions.

If you still cannot identify the cause, say that in your question. "I do not know where the problem is yet, but this is the last step that worked and this is the first failing command" is a useful starting point.

## Asking in Slack

Start a new message in the course channel with a short problem summary. Then put details in a thread so the main channel stays readable.

Include:

- What you are trying to do.
- The module, lesson, homework, or project step you are working on.
- The exact command you ran.
- The full error message as text.
- Your operating system.
- Your Python version, Docker version, or tool version when relevant.
- What you already tried.
- A link to your GitHub repository if the problem depends on your code.

Use triple backticks for code, commands, and error output:

````
paste the error here
````

## What to Avoid

- Do not post screenshots of code or error messages when text is available.
- Do not take photos of your screen with a phone.
- Do not tag instructors for ordinary troubleshooting questions.
- Do not create multiple posts for the same issue.
- Do not delete the question after it is solved. Other students may need the same answer later.

Screenshots are useful only when the visual state matters, such as a browser UI, dashboard, form, or chart. Even then, also include the relevant text and context.

## Threads

Use the same thread for the whole conversation. If the error output is long, put it in the thread rather than the main channel message.

If the issue reappears later, you can start a new post. Explain what changed since the previous issue: new module, new machine, different command, updated dependency, recreated environment, or different data.

## After You Get an Answer

Reply with what fixed the problem. If the answer is useful and missing from the FAQ, contribute it back:

- For public DataTalks.Club FAQ pages, use the [FAQ proposal form](https://github.com/DataTalksClub/faq/issues/new?template=faq-proposal.yml).
- For course-specific Google Docs FAQs, add the answer there if the course team allows edits, or post the suggested FAQ entry in Slack.

This keeps future students from getting stuck on the same issue.

---

## File: courses/zoomcamp-logistics/before-you-start.md

---
title: "Before You Start"
layout: default
nav_order: 1
parent: Start Here
grand_parent: Zoomcamp Logistics
---

# Before You Start

DataTalks.Club zoomcamps are free, multi-week, cohort-based online courses. Each cohort follows a fixed schedule with weekly modules, homework deadlines, and a final project. After a cohort ends, materials remain available for self-paced study.

## Cost

Free to take, free to receive the certificate. Optional registration for course updates is also free.

You may incur small third-party costs if a course uses a paid cloud service. Most cloud providers offer free tiers or trial credits that cover the course material. See the course-specific environment-setup pages.

Before using any paid cloud, API, or AI tool:

- Check whether the course has a recommended free tier, trial credit, or low-cost setup.
- Set a budget alert if the provider supports it.
- Stop or delete cloud resources when you are done working for the day.
- Remove unused disks, databases, buckets, clusters, and API keys after a module or project is finished.
- Ask in Slack before spending money if you are unsure whether a paid resource is required.

The exact tools differ by course.

For example:

- Data Engineering Zoomcamp uses GCP in the main flow.
- Machine Learning Zoomcamp uses AWS in later modules.
- LLM Zoomcamp may use a few dollars of LLM API credits.

Always check the course-specific environment setup page.

## Cohort schedule

Each course runs once a year as a live cohort.

Approximate windows:

- Data Engineering Zoomcamp: starts in mid-January.
- Machine Learning Zoomcamp: starts in mid-September.
- MLOps Zoomcamp: discontinued for now.
- LLM Zoomcamp: starts in June.
- AI Dev Tools Zoomcamp: dates announced separately.
- Stock Market Analytics Zoomcamp: dates announced separately.

For the exact start date, check the course GitHub page. Register there if you want to receive cohort announcements by email.

## Format

A live cohort runs for 7 to 10 weeks, depending on the course.

The structure is:

- Weekly modules with pre-recorded lectures, reading material, and a homework assignment per module.
- Occasional live sessions, streamed on YouTube and recorded.
- A final project at the end (some courses also have a midterm project).
- Optional workshops between modules.

Between cohorts you can watch all the videos and work through the materials self-paced. Homework forms close after each deadline, and the leaderboard is tied to the live cohort. Certificates are only issued during the live project window.

## Time commitment

Plan for:

- 10 to 15 hours per week during the cohort.
- 2 to 3 weeks of focused work for the final project.

## Prerequisites

Most courses assume:

- Comfort with the command line.
- Basic Python (or willingness to pick it up).
- Basic SQL.
- Basic Git.

The Data Engineering and Machine Learning Zoomcamps are designed for beginners in their respective fields. They still assume general programming literacy. The course-specific prerequisites pages have the exact list.

## Certification

The certificate is project-based, not exam-based. Rules vary per course.

In all cases, you must:

- Submit the project (or projects) by the deadline.
- Complete peer reviews of other students' projects.

Both are required. Skipping the peer reviews means no certificate, even if your project passed.

For details, see [Certification]({{ '/courses/zoomcamp-logistics/certification/' | relative_url }}) and the course-specific project page.

## Self-paced before a cohort

You can watch past videos and work through the materials before the next live cohort starts. When the next cohort begins, your homework can earn leaderboard points and your project can earn the certificate.

If a cohort is already in progress and you missed the start, see [Joining Mid-Cohort]({{ '/courses/zoomcamp-logistics/joining-mid-cohort/' | relative_url }}).

---

## File: courses/zoomcamp-logistics/certification.md

---
title: "Certification"
layout: default
nav_order: 3
parent: Project and Certificate
grand_parent: Zoomcamp Logistics
---

# Certification

Cross-cutting logistics for getting your certificate. Exact passing criteria differ per course - see the certification or project page on the individual course.

## Requirements

In every DataTalks.Club zoomcamp:

- Submit the project (or required projects) by the deadline.
- Complete the required peer reviews on time.
- Reach the course-specific minimum project score.

What is not required:

- Submitting all (or any) homework.
- Attending live sessions.
- Earning leaderboard points beyond the project.

## Course differences

Project rules vary by course:

- Data Engineering Zoomcamp: one project, must reach the passing score, complete required peer reviews.
- Machine Learning Zoomcamp: 2 of 3 projects (midterm + capstone, or capstone + second capstone), each with a deployed model.
- LLM Zoomcamp: a single project meeting the rubric.

See the course-specific certification or project page.

## Minimum passing score

Project rubrics are scored out of a course-specific maximum (typically 25 to 40 points). The passing threshold also varies. Look at the project rubric on the course page for the exact numbers.

## Certificate timing

Certificates are issued after:

- The final project deadline has passed.
- All peer reviews are completed.
- The cohort lead has finalized scores.

Typically 2 to 4 weeks after the project deadline. The exact date is announced in Slack and Telegram.

You cannot get the certificate early, even if you finish the project ahead of time. The certificate ceremony covers everyone in the cohort at once.

## Certificate location

The certificate is delivered through the course platform. Once issued, a "Get certificate" button appears on your dashboard. The certificate is a PDF with a unique URL.

## Adding to LinkedIn

LinkedIn has a "Licenses and Certifications" section in your profile.

Add a new entry with:

- Name: the course title (for example, "Data Engineering Zoomcamp").
- Issuing organization: DataTalks.Club.
- Issue date: the date you received the certificate.
- Credential URL: the unique URL from the certificate.

Many graduates also write a LinkedIn post about completing the course. It is a good place to share what you learned, link to your project, and tag DataTalks.Club.

## Joined late

You can still get the certificate if you can submit the project by the project deadline. See [Joining Mid-Cohort]({{ '/courses/zoomcamp-logistics/joining-mid-cohort/' | relative_url }}).

If the project deadline is too close, work through the materials self-paced now. Submit the project during the next live cohort.

## Project did not pass

Most courses offer multiple submission attempts (attempt 1, attempt 2, sometimes a final last-attempt window). If you did not pass attempt 1, submit again in the next attempt.

If all attempts have closed for the cohort, submit during the next live cohort. Save your work. You do not need to start over.

## Skipped peer reviews

Some courses tie your project's final score to whether you did peer reviews.

If you skipped reviews:

- Check with the cohort lead in Slack. There is sometimes flexibility for one-off cases.
- Plan to do peer reviews in the next attempt or next cohort.

Doing peer reviews is one of the easiest parts of the course. Build it into your weekly schedule once submissions close.

## After the course

Common next steps:

- Take another zoomcamp. See [datatalks.club](https://datatalks.club) for the schedule of upcoming zoomcamps.
- Polish your project and add it to your portfolio.
- Write a LinkedIn post about what you learned.
- Help next cohort's students by answering questions in Slack.
- Contribute to the public [FAQ](https://datatalks.club/faq/).

---

## File: courses/zoomcamp-logistics/communication.md

---
title: "Communication"
layout: default
nav_order: 2
parent: Zoomcamp Logistics
has_children: true
---

# Communication

Zoomcamps use several channels, and each one has a different purpose.

The short version:

- Slack is for questions, discussion, help, and peer support.
- Telegram is for announcements. Do not use Telegram for questions.
- YouTube is for live streams and recordings.
- Email and the newsletter are for cohort reminders and broader community updates.

---

## File: courses/zoomcamp-logistics/course-work.md

---
title: "Course Work"
layout: default
nav_order: 3
parent: Zoomcamp Logistics
has_children: true
---

# Course Work

These pages cover the weekly cadence of a live cohort:

---

## File: courses/zoomcamp-logistics/email.md

---
title: "Email and Newsletter"
layout: default
nav_order: 3
parent: Communication
grand_parent: Zoomcamp Logistics
---

# Email and Newsletter

Course registration is optional. Register only if you want email updates for a cohort.

If you register, you may receive:

- A kickoff email near the cohort start.
- Links to the course platform, repository, Slack, and announcements.
- Important deadline or project reminders.

The [DataTalks.Club newsletter](https://datatalks.club/newsletter.html) goes out weekly with course and community updates. If you stop receiving it, you may have unsubscribed before. Re-subscribe from the newsletter page.

## Homework submission confirmations

When you submit homework on the course platform, you receive a confirmation email from `courses@dtcdev.click` summarizing what you submitted:



These confirmation emails often land in **Spam**. After submitting, check your spam folder, and if you find one there, mark it as **Not Spam** so future confirmations reach your inbox. Getting the confirmation is a quick way to verify your submission went through.

---

## File: courses/zoomcamp-logistics/homework.md

---
title: "Homework"
layout: default
nav_order: 2
parent: Course Work
grand_parent: Zoomcamp Logistics
---

# Homework

When homework opens, when it closes, what to do with it. For the platform UI (where to click on the submission page), see [Course Management Platform: Homework]({{ '/courses/course-management-platform/homework/' | relative_url }}).

## Optional, but recommended

In every DataTalks.Club zoomcamp, homework is optional for certification. Only the project (or projects) is required.

Homework is still worth doing:

- Checks your understanding of the module.
- Earns leaderboard points.
- Builds material for your portfolio.
- Good preparation for the project.

## Release

The course team adds homework when it opens each module. You find it in the course's GitHub repo at `cohorts/<year>/<module>/homework.md` (path varies slightly per course).

The submission form on the [course platform](https://courses.datatalks.club/) opens when the homework is officially released. Until then, even if you can read the questions in the repo, the form is not yet active.

## Deadlines

Deadlines work like this:

- Strict deadlines, announced on the course platform, Slack, and Telegram.
- Typically one week to ten days after release.
- Exact deadline (with time and time zone) is on the course platform.
- Most platform deadlines are shown in your local time zone.

## After the deadline

After the deadline:

- The course team closes the submission form. Submitting is no longer possible after that.
- You can no longer submit for leaderboard points.
- Existing submissions stay.
- You can still do the homework on your own and push it to your repo.

There are no individual extensions. In rare cases, the cohort lead may extend the deadline for everyone. This can happen after a server outage or a bug in the questions. The extension is announced in Slack.

## Submission

The form on the course platform asks for:

- Your answer to each question (multiple choice, numbers, or short answers).
- A link to your public GitHub repository for the homework code.
- Optionally a link to your social media post (earns learning-in-public points).

For the platform UI, see [Course Management Platform: Homework]({{ '/courses/course-management-platform/homework/' | relative_url }}).

## Repository contents

The form mostly checks your answers, not your code.

Your repo should:

- Be public so peer reviewers and graders can see it.
- Contain the code or queries you used to arrive at your answers.
- Have a README that explains how to run it.
- Use meaningful file names (`week_3_data_warehouse/` rather than `hw3/`).

Whether to include screenshots, SQL queries, or notebooks depends on the question. Generally include enough that someone can follow what you did.

You can use a single repository for all homework (one folder per module) or one repository per module. Either works.

## Answer mismatch

If your numerical answer is close to one of the options, pick the closest.

Small differences usually come from:

- Slightly different filtering (inclusive vs exclusive date boundaries).
- Different versions of the dataset.
- Floating-point or rounding differences.

If your answer is far from any option, double-check the question and the dataset version. Homework questions often specify a precise filter. Ask in the course Slack thread if you are stuck. Other students often have the same issue, and the cohort lead may clarify.

## Solutions

Solutions are usually published in the course repository after the deadline closes, under `cohorts/<year>/<module>/`. If you do not see them, ask in Slack. They may not be published yet, or community contributions to the FAQ may have the breakdown.

## Quizzes vs free-form answers

Homework format varies:

- Multiple-choice quizzes in some courses.
- Free-form answers in others.
- Some mix the two.

The format is described in each module's homework page in the repo. All formats use the same submission flow on the course platform.

## Homework code location

Create a separate personal repo for your homework code. Do not work directly inside the course repository.

- Browse course materials on GitHub (the web UI lets you read each file or download just the ones you need).
- Keep your homework solutions in your own public repo so peer reviewers and graders can see them.

---

## File: courses/zoomcamp-logistics/index.md

---
title: "Zoomcamp Logistics"
layout: default
nav_order: 1
parent: Courses
has_children: true
---

# Zoomcamp Logistics

How DataTalks.Club zoomcamps work end to end. The mechanics described here are shared across all our zoomcamps.

If you are looking for a specific answer, see [Quick Lookup]({{ '/courses/zoomcamp-logistics/quick-lookup/' | relative_url }}).

## Sections

Use these sections to find the right logistics page:

- [Start Here]({{ '/courses/zoomcamp-logistics/start-here/' | relative_url }}) - cost, schedule, registration, and joining mid-cohort.
- [Communication]({{ '/courses/zoomcamp-logistics/communication/' | relative_url }}) - Slack, Telegram, YouTube, email, live sessions, and asking questions.
- [Course Work]({{ '/courses/zoomcamp-logistics/course-work/' | relative_url }}) - modules, homework, workshops, and AI usage.
- [Progress and Recognition]({{ '/courses/zoomcamp-logistics/progress-recognition/' | relative_url }}) - learning in public and leaderboard points.
- [Project and Certificate]({{ '/courses/zoomcamp-logistics/project-certificate/' | relative_url }}) - final projects, peer review, and certificates.
- [Quick Lookup]({{ '/courses/zoomcamp-logistics/quick-lookup/' | relative_url }}) - one-page map for common questions.

---

## File: courses/zoomcamp-logistics/joining-mid-cohort.md

---
title: "Joining Mid-Cohort"
layout: default
nav_order: 3
parent: Start Here
grand_parent: Zoomcamp Logistics
---

# Joining Mid-Cohort

Discovering a zoomcamp after the cohort has already started is common.

You can still:

- Join the cohort.
- Get the certificate.
- Work through missed modules.

The main thing you may lose is leaderboard points for past homework.

## You can still join

These rules apply if you join late:

- Optional registration for course updates usually stays open the whole cohort.
- Past homework deadlines are missed (no individual extensions).
- The project window is at the end of the cohort - that determines the certificate.
- Homework is not required for certification.

## Catch-up steps

Use this order:

1. Open the course on the [course management platform](https://courses.datatalks.club/) - it has the current schedule and deadlines.
2. Open the course's GitHub repo and find the `cohorts/<year>/` folder - it has the homework files and cohort-specific materials.
3. Register for email updates if you want them (see [Joining a Cohort]({{ '/courses/zoomcamp-logistics/joining/' | relative_url }})).
4. Watch the videos for the modules you missed.
5. Catch up on the homework even if a deadline has passed. It solidifies the material and you can include it in your portfolio.

## Catch-up window

A typical cohort runs for 9 to 10 weeks.

Rough guide:

- First 2 weeks: easy catch-up. Plan an extra 5 to 10 hours in your first week.
- Weeks 3 to 5: doable with the recommended 10 to 15 hours per week plus extra catch-up time.
- Second half: focus on understanding the material and completing the project. Some homework deadlines will be missed. That is fine.
- After all module deadlines: you can still submit the project if it is open. Otherwise, take it self-paced and submit during the next live cohort.

## Self-paced or wait for the next cohort

If a cohort is more than halfway through, you have two reasonable options.

Choose one:

- Join now, work through materials self-paced, submit the project during the next live cohort.
- Wait for the next cohort and start fresh.

Materials do not change drastically between cohorts, so anything you study now will still be valid.

## After deadlines pass

The submission form on the course platform closes when the deadline passes.

After that:

- You can no longer submit the homework for leaderboard points.
- Your existing submissions stay.
- You can still do the homework on your own and push it to your repo.

For the homework deadline mechanics, see [Homework]({{ '/courses/zoomcamp-logistics/homework/' | relative_url }}).

## The kickoff session

The kickoff is recorded and uploaded to YouTube the same day or next day. Look in the course's YouTube playlist for the cohort year. The kickoff usually covers the schedule, expectations, and how the course works.

---

## File: courses/zoomcamp-logistics/joining.md

---
title: "Joining a Cohort"
layout: default
nav_order: 2
parent: Start Here
grand_parent: Zoomcamp Logistics
---

# Joining a Cohort

The same steps apply regardless of which course you take. Each course's getting-started page has the course-specific repo, channels, playlist, and environment setup.

## Registration

Registration works like this:

- Registration is optional. You only need it if you want to receive email updates about the course.
- The registration link is on the course GitHub page. It is free and usually stays open for the whole cohort.
- Registration does not create your platform account.
- If you register, you receive an email with the cohort schedule when the cohort kicks off. Far-away cohorts: the email arrives closer to the start date.
- If you do not want email updates, you do not need to register. Just show up when the course starts and be ready to work through the materials.

## Course platform account

The [course management platform](https://courses.datatalks.club/) is the only course account you need. Use it to submit homework, track your score, see deadlines, and submit your project. Sign up with any email - it does not have to match the email you used for optional cohort updates.

For the platform UI, see [Course Management Platform]({{ '/courses/course-management-platform/' | relative_url }}).

## Course materials

Use the course repository and platform together:

- All course materials live in a public GitHub repository (one per course).
- Star the repo so you can find it later.
- Module folders contain the lectures, code, and reading.
- The `cohorts/<year>/` folder holds the active cohort's homework and cohort-specific materials.
- The course management platform shows the current schedule and deadlines.
- Pre-recorded lectures live on the [DataTalks.Club YouTube channel](https://www.youtube.com/@DataTalksClub) - one playlist per course.

## Communication channels

Join the course communication channels early:

- Slack for questions, discussion, and help.
- Telegram for announcements.
- YouTube for live streams and recordings.
- Email and the newsletter for cohort reminders.

For details, see [Communication Channels]({{ '/courses/zoomcamp-logistics/communication/' | relative_url }}).

## Next step

For the course-specific bootstrap, see your course's getting-started page:

- [Data Engineering Zoomcamp: Getting Started]({{ '/courses/data-engineering-zoomcamp/getting-started/' | relative_url }})
- [Machine Learning Zoomcamp: Getting Started]({{ '/courses/ml-zoomcamp/getting-started/' | relative_url }})
- [LLM Zoomcamp: Getting Started]({{ '/courses/llm-zoomcamp/getting-started/' | relative_url }})

If the cohort has already started, see [Joining Mid-Cohort]({{ '/courses/zoomcamp-logistics/joining-mid-cohort/' | relative_url }}). You do not need to attend live sessions to be in the live cohort. Submitting homework on time is what matters.

---

## File: courses/zoomcamp-logistics/leaderboard.md

---
title: "Leaderboard"
layout: default
nav_order: 2
parent: Progress and Recognition
grand_parent: Zoomcamp Logistics
---

# Leaderboard

The leaderboard is a per-cohort scoreboard that ranks participants by total points. Optional, does not affect certification - it exists for motivation and recognition.

For platform UI (where to view the leaderboard, how submissions appear), see [Course Management Platform: Leaderboard]({{ '/courses/course-management-platform/leaderboard/' | relative_url }}).

For learning in public specifically, see [Learning in Public]({{ '/courses/zoomcamp-logistics/learning-in-public/' | relative_url }}).

## Point categories

Exact values vary slightly per course, but the categories are the same:

- Homework: a point for each homework submitted on time, plus often a small bonus for full marks.
- Learning in public: a point for each accepted social media post.
- FAQ contributions: a point for each accepted entry to the public FAQ.
- Project: variable, based on peer-review scoring.
- Project peer reviews: points for completing your assigned reviews on time.

See your course's leaderboard page on the course platform for the exact point breakdown.

## Point timing

Points usually appear this way:

- Homework: immediately after submission, after the form auto-grades.
- Learning in public: usually within a day of submission, after moderation.
- FAQ contributions: after the entry is accepted into the FAQ repo.
- Project: after the peer-review window closes and scores are aggregated.
- Peer reviews: as you complete each one.

## Missing points

Common reasons:

- The homework was not actually submitted. Check your submission history on the course platform.
- A learning-in-public link did not pass moderation (most common: link is not your own post, or not about the course).

If you believe your points are wrong, post in the course Slack channel. Include the homework or link details so the cohort lead can check.

## Anonymous by default

Your leaderboard entry uses an auto-generated name by default.

To make yourself visible:

- Use your real name.
- Add links to LinkedIn, GitHub, or your personal site.
- Write a short bio.

People at the top of the leaderboard get noticed by recruiters and the community. Update your enrollment profile on the course platform to switch from anonymous to visible.

## Certification is independent

The certificate depends only on completing the project (or required projects) and peer reviews. Leaderboard points do not affect certification - they exist for motivation and recognition.

---

## File: courses/zoomcamp-logistics/learning-in-public.md

---
title: "Learning in Public"
layout: default
nav_order: 1
parent: Progress and Recognition
grand_parent: Zoomcamp Logistics
---

# Learning in Public

Sharing your progress publicly is a deliberate part of every DataTalks.Club zoomcamp. Posts you share earn leaderboard points and help build your portfolio.

For platform mechanics (link submission UI, link limits per submission type, misuse policy), see [Course Management Platform: Learning in Public]({{ '/courses/course-management-platform/learning-in-public/' | relative_url }}).

For where learning-in-public points fit on the leaderboard, see [Leaderboard]({{ '/courses/zoomcamp-logistics/leaderboard/' | relative_url }}).

## Benefits

Sharing publicly helps you in several ways:

- Reinforcement: explaining to others helps you internalize the material.
- Accountability: public commitment keeps you consistent.
- Feedback: others can correct your misunderstandings.
- Networking: connect with like-minded people.
- Portfolio: build a visible track record.
- Opportunities: jobs and collaborations can find you.

Past graduates have used learning in public to land roles at major companies and to negotiate raises. One Data Engineering Zoomcamp participant shared homework on LinkedIn for learning-in-public credit and later got an 11% raise.

## Process

After completing a unit, module, homework, or project:

1. Write a short post about what you learned.
2. Include the course hashtag (`#dezoomcamp`, `#mlzoomcamp`, `#mlopszoomcamp`, `#llmzoomcamp`, etc.).
3. Tag DataTalks.Club and the lead instructor.
4. Submit the post link through the course platform when submitting your homework, project, or peer review.

Each accepted link earns 1 leaderboard point.

## Post ideas

Good post topics include:

- Your project work: architecture, dashboard, deployed model, screenshots.
- Insights from each module: what you learned, how it changed your thinking.
- Challenges you faced and how you solved them. Failure stories often resonate more than success stories.
- Time spent vs results achieved.

## Writing a good post

Templates are a starting point. The most engaging posts are personal.

Tell a story:

- Why you are taking this course.
- A specific challenge you overcame.
- How this skill connects to your career.

Add your perspective:

- What surprised you, what you found difficult.
- A concept explained in your own words.
- Your debugging process.

Show, don't tell:

- Screenshots of your work (pipelines, dashboards, code, deployed services).
- A short screen recording of your project running.

Tools for capturing screens:

- Windows: Snipping Tool.
- Mac: Cmd + Shift + 5 for screen recording.
- Linux: SimpleScreenRecorder.

A 30-second video is often more engaging than a long text post.

## Templates

Each course's homework folder includes example posts you can use as starting templates. See your course's resources page or homework README for direct links to current cohort templates.

## Real examples

These examples are from an Agents Crash Course. It is a different course, but the same approach.

Example posts:

- Day 1: [LinkedIn](https://www.linkedin.com/feed/update/urn:li:activity:7376554326648995840/) and [X](https://x.com/Al_Grigor/status/1970790075064570049)
- Day 2: [LinkedIn](https://www.linkedin.com/feed/update/urn:li:activity:7376956251169247232/) and [X](https://x.com/Al_Grigor/status/1971136756071399871)
- Day 3: [LinkedIn](https://www.linkedin.com/posts/agrigorev_agents-crash-course-day-3-out-of-7-completed-activity-7377329488285556736-NI60/) and [X](https://x.com/Al_Grigor/status/1971565023723159765)
- Day 4: [LinkedIn](https://www.linkedin.com/feed/update/urn:li:activity:7377673382181629953/) and [X](https://x.com/Al_Grigor/status/1971825975253213309)

---

## File: courses/zoomcamp-logistics/live-sessions.md

---
title: "Live Sessions and Recordings"
layout: default
nav_order: 4
parent: Communication
grand_parent: Zoomcamp Logistics
---

# Live Sessions and Recordings

All DataTalks.Club zoomcamps are built around pre-recorded lectures with occasional live sessions. The cadence and number of live sessions vary per cohort and per course. The exact schedule for the current cohort is on the [course management platform](https://courses.datatalks.club/).

Two kinds of live sessions happen during a cohort:

- Office hours: the cohort lead and instructors answer questions about recent modules.
- Workshops: deep-dives on a specific tool or topic, often delivered by a guest instructor or partner. See [Workshops]({{ '/courses/zoomcamp-logistics/workshops/' | relative_url }}).

## Location

Live sessions use YouTube:

- Stream on the [DataTalks.Club YouTube channel](https://www.youtube.com/@DataTalksClub).
- Recordings are added to the cohort-specific YouTube playlist as they happen.
- The link to each live stream is announced shortly before in the course Slack channel and on the course Telegram channel.
- No Zoom link, no separate webinar tool, no signup. Just open YouTube at the scheduled time.

For how the channels fit together, see [Communication Channels]({{ '/courses/zoomcamp-logistics/communication/' | relative_url }}).

## Time zones

Typical times:

- Most live sessions are at 17:00 Berlin time (CET / CEST). Some sessions are at 12:00 noon Berlin time.
- US time zones: typically morning. Asia-Pacific: typically evening or night.

## Asking questions live

Two formats are common:

- YouTube live chat: type questions. The host or co-host reads them out.
- Slido or similar Q+A tool, with the link announced at the start of the session.

If your question is not answered live, post it in the course Slack channel after the session. Use a thread under the relevant topic.

## Recordings

Recordings work like this:

- Available immediately after the stream ends. YouTube keeps the live broadcast as a regular video on the channel.
- Added to the cohort's YouTube playlist.

You do not need to attend live to be in the live cohort. Watching the recording later does not change your cohort status.

---

## File: courses/zoomcamp-logistics/modules.md

---
title: "Working Through the Modules"
layout: default
nav_order: 1
parent: Course Work
grand_parent: Zoomcamp Logistics
---

# Working Through the Modules

Use this page to understand how modules are released during a live cohort. It also covers where to find videos and how much pacing flexibility you have. See the course-specific pages for technical material.

## Module cadence

Modules are released on a fixed schedule, typically one per week during a live cohort.

Each module includes:

- Pre-recorded lecture videos in the course's YouTube playlist.
- Reading material and code in the course's GitHub repository.
- A homework assignment due at the end of the module's window.
- For some courses, a live session that walks through the module or answers questions.

## Cohort videos

Two sources to be aware of:

- Main course playlist: pre-recorded module videos. Reused across cohorts unless a module was rewritten.
- Cohort-specific playlist (for example, "Data Engineering Zoomcamp 2026"): live session recordings and any new videos released during the current cohort.

If the cohort-specific playlist only has a few videos at the start, that is expected. New live recordings are added each week. The pre-recorded module material is in the main playlist.

The course's GitHub repository has the canonical link to the right playlist for each module. Check the README in each module folder.

## Previous-cohort videos

Most modules use the same video set across cohorts.

Differences between cohorts:

- The cohort folder under `cohorts/<year>/` has the homework and any cohort-specific changes.
- The course management platform has the current schedule and deadlines.
- Tools are sometimes swapped (in the Data Engineering Zoomcamp, Mage replaced Prefect, then Kestra replaced Mage).

When in doubt, follow the current cohort folder and the current README. If a video references an old tool or path, check the current cohort folder for the updated version.

## Working ahead

You can. Materials are all available from day one.

Caveats:

- Homework forms only open when the homework is officially released, even if the questions are visible in the repo.
- Workshop content is sometimes not finalized until close to its scheduled week.
- You cannot ask the cohort for help on a topic the cohort has not yet reached.

## Working behind

You can. The only constraint: homework deadlines are fixed. Being behind on homework does not block certification - that is project-based.

For catching up after joining late, see [Joining Mid-Cohort]({{ '/courses/zoomcamp-logistics/joining-mid-cohort/' | relative_url }}).

## Tracking the cohort's pace

Use these channels to track the current cohort:

- Course platform: shows the active module and upcoming deadlines.
- Slack and Telegram: the course team announces each module there.

## Modules vs project

For certification, the requirements are simple:

- Required: project (or required projects) and peer reviews.
- Optional: homework. Recommended for understanding the material.

The project draws on material from many modules, so skipping modules makes the project harder. Treat the modules as your preparation for the project.

## Self-paced after the cohort

Materials remain available.

What changes:

- Homework submission forms close. You can do the homework but cannot submit for points.
- The leaderboard freezes for that cohort.
- The Slack channel becomes quieter.
- You cannot earn a certificate until the next live cohort runs.

If you want a certificate, time your project submission to coincide with a live cohort.

---

## File: courses/zoomcamp-logistics/peer-review.md

---
title: "Peer Review"
layout: default
nav_order: 2
parent: Project and Certificate
grand_parent: Zoomcamp Logistics
---

# Peer Review

Project scoring is done by peer review. Every participant who submits a project also reviews other participants' projects. For platform UI, see [Course Management Platform: Peer Review]({{ '/courses/course-management-platform/peer-review/' | relative_url }}).

## Reasons for peer review

Peer review serves several purposes:

- It scales. Cohorts have hundreds of participants. The cohort lead alone cannot grade all projects.
- It is a learning experience. Reading other projects' code teaches you patterns you would not see otherwise.
- It mirrors real work. Code review is a core engineering skill.

## How it works

After the project submission deadline:

1. Each project is randomly assigned to several reviewers (typically 3 reviewers per project).
2. Each participant who submitted is assigned several projects to review (typically 3).
3. Reviewers score each project against the course's rubric.
4. The final project score is aggregated from the reviewer scores.
5. Reviewers earn points for completing reviews on time.

## Number of reviews

Typically 3 projects per submission attempt. The exact number is shown on the course platform when you are assigned reviews.

If you submit in attempt 1 and again in attempt 2, you get a fresh set of projects to review.

## Assignment timing

Assignments do not appear automatically after the submission form closes. The cohort lead opens peer review separately. Once it is open, the announcement goes to Slack and Telegram. After the announcement, your assigned projects appear on your course platform dashboard.

If the announcement has already gone out and you do not see assignments, post in the course Slack channel.

## Deadline for reviews

Typically one week from when reviews are assigned. The exact deadline is on the course platform.

If you do not complete your reviews by the deadline:

- You lose the points for those reviews.
- Your project still receives scores from the reviewers it was assigned to, but it fails the project regardless of those scores.
- A failed project means no certificate.

Skipping peer reviews is the most common reason participants who submitted a passing-quality project still do not receive a certificate.

## Missing project repo

Some submitted repos go private or get deleted between submission and review.

If a repo you are assigned is unavailable:

- Wait a day. Sometimes it is a temporary issue.
- If still unavailable, mark the project with a zero score and note in the review that the repo was unreachable.
- Do not skip the review. You still need to submit it for credit.

The cohort lead handles repeat issues. If you see a pattern (multiple bad repos), flag it in Slack.

## Unfamiliar tech stack

Some students use stacks the course did not teach.

Examples include AWS instead of GCP, or Airflow instead of Mage.

When reviewing such a project:

- Read the README carefully. The participant should explain their choices.
- Use the rubric criteria, which are mostly stack-agnostic ("is there a documented pipeline?", "is the data warehouse used correctly?").
- If something is genuinely unclear, give partial credit and note it in the comments rather than zero.

If you cannot evaluate something, that is fair feedback. The participant did not document well enough.

## Writing a good review

Good reviews follow these rules:

- Be honest. Inflated scores devalue the certificate.
- Be constructive. Point out what could be improved, not just what is missing.
- Be specific. "The README is unclear" is less useful than "the README does not explain how to set the GCP credentials."
- Be reasonable. Most projects have rough edges. Do not penalize a good project for cosmetic issues.

## Beyond your assignment

You can voluntarily review additional projects. This usually does not earn extra points, but it is useful learning and helps the community.

## Fairness

Peer-review scores are aggregated across multiple reviewers. This smooths out individual harshness or generosity. If one reviewer gave a low score with no justification, post in Slack.

## AI-generated reviews

Using LLMs to draft reviews is fine. But do not let the LLM do the whole thing without looking at the project. Reading other people's code is a major learning opportunity.

## Score timing

After the peer-review window closes, the cohort lead aggregates scores. Final scores typically appear on the course platform 1 to 2 weeks after the review deadline.

If you do not see your score after that window, post in Slack.

---

## File: courses/zoomcamp-logistics/progress-recognition.md

---
title: "Progress and Recognition"
layout: default
nav_order: 4
parent: Zoomcamp Logistics
has_children: true
---

# Progress and Recognition

These pages cover optional ways to make your progress visible:

1. [Learning in Public]({{ '/courses/zoomcamp-logistics/learning-in-public/' | relative_url }}) - sharing progress publicly and earning points.
2. [Leaderboard]({{ '/courses/zoomcamp-logistics/leaderboard/' | relative_url }}) - points, ranking, missing points, and visibility.

---

## File: courses/zoomcamp-logistics/project-certificate.md

---
title: "Project and Certificate"
layout: default
nav_order: 5
parent: Zoomcamp Logistics
has_children: true
---

# Project and Certificate

These pages cover the end of the cohort: