Full Stack Web Development Version Control, Tooling & DevOps Syllabus

Version Control, Tooling & DevOps syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Version Control, Tooling & DevOps in Full Stack Web Development, not a summary of it.

1. 1

   Git and Version Control

   3 topics

   • Git Fundamentals
     • Repositories, staging and commits
     • git status, add and commit
     • Viewing history and diffs
   • Branching and Merging
     • Creating and switching branches
     • Merging and resolving conflicts
     • Rebasing basics
   • Remote Collaboration with GitHub
     • Push, pull and clone
     • Pull requests and code review
     • Forking and open-source workflow
2. 2

   Development Tooling

   4 topics

   • Package Managers and Bundlers
     • npm and yarn
     • Module bundling with Vite/Webpack
   • Code Quality Tools
     • ESLint and Prettier
     • EditorConfig and formatting
   • Debugging and DevTools
     • Browser DevTools (Network, Console)
     • Node.js debugging
   • Environment Management
     • Environment variables and dotenv
     • Node version management (nvm)
3. 3

   Deployment and Hosting

   4 topics

   • Deploying Front-End Apps
     • Static hosting (Netlify, Vercel)
     • Build and deploy pipelines
   • Deploying Back-End Services
     • Hosting Node apps (Render, Railway)
     • Process managers (PM2)
     • Environment configuration in production
   • CI/CD Pipelines
     • GitHub Actions workflows
     • Automated testing and deployment
   • Domains and HTTPS
     • Custom domains and DNS
     • SSL certificates
4. 4

   Containerization Basics

   3 topics

   • Introduction to Docker
     • Images and containers
     • Dockerfile basics
   • Running Applications in Containers
     • docker build and run
     • Port mapping and volumes
   • Docker Compose Overview
     • Multi-container apps
     • Composing app and database services

Version Control, Tooling & DevOps flashcards for Full Stack Web Development

20 of 59 cards from the Version Control, Tooling & DevOps deck — real questions with worked answers.

1. What is Git, and what category of version control system does it belong to?

   Git is a distributed version control system (DVCS) that tracks changes to files; every developer has a full copy of the repository and its complete history locally.

2. What are the three main states/areas a file can be in within a Git workflow?

   Working directory (modified files), staging area / index (changes marked with git add), and the repository / committed history (snapshots saved with git commit).

3. Which Git command initializes a new repository, and what hidden folder does it create?

   git init creates a new repository by adding a hidden .git directory that stores all version history and metadata.

4. What is the difference between git add and git commit?

   git add stages changes (moves them to the index, marking them for the next snapshot); git commit permanently records the staged snapshot into the repository history with a message.

5. What does a Git commit hash (SHA) uniquely identify?

   A commit's SHA-1 (or SHA-256) hash uniquely identifies the exact snapshot of content, plus its author, message, timestamp, and parent commit(s).

6. What is the purpose of a .gitignore file?

   It lists file patterns that Git should not track or stage (e.g., node_modules, build artifacts, secrets), keeping them out of version control.

7. What does git status show?

   It shows the current branch, which files are staged, modified but unstaged, or untracked, plus how the branch compares to its remote tracking branch.

8. What is the difference between git fetch and git pull?

   git fetch downloads new commits/refs from the remote without changing your working files; git pull does a fetch followed by a merge (or rebase) into your current branch.

9. In Git, what is a branch technically?

   A branch is simply a lightweight, movable pointer (reference) to a specific commit; the default branch is typically named main (or master).

10. What command creates a new branch and switches to it in one step?

    git checkout -b <branch-name> (or the newer git switch -c <branch-name>).

11. What is a fast-forward merge?

    A merge where the target branch has not diverged, so Git simply moves the branch pointer forward to the source commit without creating a new merge commit.

12. What is a three-way (non-fast-forward) merge and what does it create?

    When two branches have diverged, Git combines their changes using the two branch tips and their common ancestor, producing a new merge commit with two parents.

13. What is a merge conflict and when does it occur?

    A conflict occurs when two branches change the same lines of a file (or one edits, one deletes); Git cannot auto-merge and marks the file for manual resolution.

14. How does git rebase differ from git merge?

    Merge preserves history and creates a merge commit; rebase reapplies your commits on top of another branch's tip, producing a linear history but rewriting commit hashes.

15. What is the golden rule of git rebase?

    Never rebase commits that have been pushed and shared publicly, because rebasing rewrites history and breaks others' copies of the branch.

16. What does git cherry-pick do?

    It applies the changes from one specific commit onto the current branch, creating a new commit with the same content but a different hash.

17. What is the difference between git reset and git revert?

    git reset moves the branch pointer (can discard commits, rewriting history); git revert creates a new commit that undoes a previous commit, preserving history safely.

18. What is the difference between a remote and an origin in Git?

    A remote is any bookmarked external repository URL; origin is the conventional default name Git gives to the remote you cloned from.

19. What does git clone do?

    It copies an entire remote repository (all history and branches) to your machine and automatically sets up origin as the remote and a tracking branch.

20. On GitHub, what is a Pull Request (PR)?

    A request to merge changes from one branch (often a fork or feature branch) into another, providing a space for code review, discussion, and CI checks before merging.

See more Version Control, Tooling & DevOps flashcards →

Planning Version Control, Tooling & DevOps for Full Stack Web Development

Version Control, Tooling & DevOps (Full Stack Web Development) FAQ