big_query.sql Documentation

Official TypeScript developer resources and documentation for DataTalksClub/big_query.sql. Verified technical context for AI.

0 stars TypeScript TypeScript 1 file · ~63,169 tokens
RAW Doc

1. Project Overview & Quickstart (DataTalksClub/big_query.sql)

big_query.sql

Open-source repository DataTalksClub/big_query.sql

Repository Details

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 16 weeks September 15, 2025 ML engineering with deployment focus covering regression, classification, deep learning, and practical projects Register
AI Dev Tools Zoomcamp 6 weeks November 18, 2025 Modern AI development tools and workflows for building, testing, and deploying AI applications Register
Data Engineering Zoomcamp 9 weeks January 2026 Complete data engineering bootcamp covering Docker, SQL, Terraform, GCP, Kafka, and Spark Register
MLOps Zoomcamp 12 weeks – Production ML systems & best practices including experiment tracking, model deployment, and monitoring Register
LLM Zoomcamp 10 weeks June 2026 Large Language Models course covering fine-tuning, RAG systems, and LLM application development Register
Stock Market Analytics Zoomcamp 8 weeks April 2026 Financial data analysis and algorithmic trading strategies using Python and modern analytics tools Register

Running Locally

This site is built with Rustkyll. To run it locally:

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. 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.

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

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"

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 (

path: "/assets/js/mermaid.min.js"

Note: copy both `mermaid.esm.min.mjs` (v10+) or `mermaid.min.js` (

Enable or disable heading anchors

heading_anchors: false

aux_links:
"DataTalks.Club":
- "https://datatalks.club/"

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

nav_sort: case_sensitive # Capital letters sorted before lowercase

nav_external_links:

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: false
back_to_top_text: "Back to top"

footer_content: ''

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.

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

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
---

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

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

How it works

To take part:

  • Join the #book-of-the-week 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 [email protected] or contact the DataTalks.Club team in Slack.

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.

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

All events are published on our YouTube channel. Subscribe to our events on Luma or add our Google calendar 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.

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.

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:

Examples where font could be larger:

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.

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

Taking part

To take part:

  • Join the #project-of-the-week 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

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.

Suggest other ideas in the #project-of-the-week 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

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.

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.

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.

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:

Examples where font could be larger:

File: assets/js/zzzz-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: '

' -%}
{%- assign title = titleAndContent[0] | replace_first: '>', '

' | split: '

' -%}
{%- 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: '//homework.md` (path varies slightly per course).

The submission form on the course platform 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 - 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 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 - 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:

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.

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.
  • 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:

Explore Related Technologies & Topics

View All 9,111+ Repositories →

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

⚡ MCP Servers Model Context Protocol → 🧠 Agent Skills Prompt & rule files → 🔌 OpenAPI Specs REST & Swagger schemas →