Every change you make in this course travels the same path: you edit a file on your own computer, you record and send that change to GitHub, and then the live site served by GitHub Pages reflects what you sent. Those three stages — local editing, committing and pushing, and live publication — form the local-to-live pipeline. Learning to see them as distinct steps makes it much easier to diagnose problems later: a file saved but not committed, a commit made but not pushed, and a push that hasn't finished rebuilding the site all look different once you know what to check.
This workflow matters here because it is the pattern you will repeat for the rest of the term. Rather than uploading files by hand, you will keep a local copy of your project, use Git to track changes, and let GitHub Pages serve the result at a public URL. The same habits also transfer directly to professional web development, where version control is the normal way teams edit, review, and deploy code.
As you watch the videos below, focus on three things: what a commit actually is (a recorded snapshot, not a save), the difference between committing locally and pushing to a remote repository on GitHub, and where each step happens — in your editor, in your local repository, or on GitHub's servers. Don't worry about memorizing commands on the first pass; aim to build a mental map of the pipeline so the hands-on steps later in the module feel like confirmation rather than guesswork.
A short, animated overview of how Git works under the hood, from ByteByteGo. Based on its title and description, it should explain the core Git concepts behind the workflow — the working directory, staging, commits as snapshots, and how a local repository relates to a remote one such as GitHub.
At roughly four minutes it gives you the conceptual model first, which is exactly what you need to distinguish the three stages of the local-to-live pipeline before you start typing commands.
The official Visual Studio Code beginner tutorial for using Git inside the editor. Its chapter list indicates it walks through initializing a repository, renaming a branch, and working with Git through VS Code's interface, so you should see the edit-then-commit cycle demonstrated in the same kind of editor you will likely use.
It comes straight from the VS Code team and shows the local editing and committing stages in a graphical workflow, which is the most common way students will actually perform these steps.
A beginner-oriented tour of essential Git commands, produced by GitHub. Based on the title and description, it starts with configuring Git and then works through the commands you use repeatedly, which typically include staging changes, committing them, and pushing to a remote repository.
Coming from GitHub itself, it is an authoritative reference for the commit and push portion of the pipeline, and it is the video to return to when you need the exact command for a step.
Together these videos build the conceptual and practical foundation for the module's workflow outcomes. The ByteByteGo explainer supports MO5 by making the stages of the local-to-live pipeline distinguishable, and it indirectly supports MO4 by clarifying what a push actually sends to GitHub so you can reason about when Pages rebuilds. The VS Code tutorial and GitHub's command walkthrough support MO3 by demonstrating the commit and push steps you will execute to publish an HTML file, and they reinforce the repository habits behind MO1. None of the videos teach HTML structure (MO2) or GitHub Pages setup directly — those come from the module's other materials and your hands-on work — but the workflow shown here is the vehicle you will use to get that HTML file onto your live site and verify it there.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.