Git & GitHub: Beginner to Advanced
A comprehensive, industry-relevant curriculum designed for learners from absolute non-IT backgrounds to experienced software engineers. Master terminal version control, branching strategies, merge conflicts, pull request reviews, CI/CD automation, and repository security.
Level 1 — Foundations
What version control is, terminal basics, Git vs GitHub, first configuration, and your first commit.
What is Version Control & Why Every Developer Needs It
Imagine writing a long book. If you accidentally delete chapter 3, or want to compare how your story sounded last Tuesday compared to today, you need a time machine. Version control is that time machine for code.
Centralized vs. Distributed Version Control (CVCS vs. DVCS)
In old centralized systems, there was only one master library in the cloud. If the library's internet went down, nobody could read or save work. In Git, every developer has the entire library in their pocket.
Problems Solved by Git in Modern Engineering Teams
Before Git, sharing code meant emailing zip files, manually merging changed lines, and guessing who broke the login screen. Git automates tracking and integrity checking.
Git vs. GitHub: Demystifying the Confusion
Git is the engine in your car. GitHub is the global highway network, parking garage, and car enthusiast community where you share your journeys.
Installing Git on Windows, macOS, and Linux
To speak Git, your computer's terminal needs to have the Git dictionary installed. We install the official binary package for your operating system.
Terminal Basics & Navigating Folders for Non-IT Learners
The terminal is simply a text-based File Explorer. Instead of double-clicking folders with a mouse, you tell the computer where to go with short keyboard words.
First-Time Git Configuration (`user.name`, `user.email`, `init.defaultBranch`)
Every time you save a snapshot in Git, Git writes your name and email on it. You must tell Git who you are once, so your team knows who wrote each feature.
Git Line Ending Configuration (`core.autocrlf` for Cross-Platform Teams)
Windows and Mac/Linux hit 'Enter' differently. If unconfigured, opening a file on Windows makes Git think every single line in the entire file changed, creating huge fake diffs.
Creating a Project Folder & Initializing a Repository (`git init`)
Running `git init` wakes up Git and creates a secret management office (the `.git` folder) inside your project. From that moment on, Git watches the folder.
The Three Trees Architecture: Working Directory, Staging Area & Repository
Think of your project like a package shipment. Working Directory is your messy desk. The Staging Area is the cardboard shipping box where you place only what you want to send. The Repository is the sealed, stamped shipment stored in the archive.
Inspecting Repository State with `git status`
`git status` is your project dashboard. Whenever you sit down at your desk or wonder 'what was I doing?', run `git status` first.
Staging Changes with `git add` and Pathspecs
`git add` lets you choose exactly which pieces of work are ready to be saved into the next milestone snapshot.
Creating Snapshots with `git commit` & Writing Meaningful Commit Messages
A commit is a permanent milestone snapshot. Once committed, you can always travel back in time to this exact second in your project's history.
Configuring `.gitignore` & Protecting Secrets from Version Control
Some files never belong in Git: private database passwords, temporary test logs, or massive 500MB dependency folders. `.gitignore` tells Git: 'Ignore these completely.'
Level 2 — Essential Git Commands
Inspecting history, diffs, safe file recovery, tracked file management, reset, and revert.
Viewing Differences with `git diff` (Working Tree vs Staging vs HEAD)
`git diff` shows the exact words you changed before you save them. It highlights what you added in green and what you removed in red.
Inspecting Commit History with `git log` and Formatting Flags
`git log` is your project diary. It lists every save milestone that was ever created, who made it, and when.
Deep Inspection with `git show` (Analyzing Commits, Trees, and Blobs)
`git log` lists all commits like a chapter list in a book. `git show` opens one specific chapter and lets you read every word that was edited in it.
Safe File Recovery with `git restore` (Working Tree vs Staged Restoration)
Made a typo or broke something that used to work? `git restore` resets the file back to your last saved milestone, wiping away messy unsaved experiments.
Removing Tracked Files with `git rm` (Disk Removal vs Cached Untracking)
If you just delete a file with your mouse, Git notices it is missing. `git rm` tells Git: 'I deliberately deleted this file, please stage the deletion for the next commit.'
Renaming & Moving Files with `git mv` & Git's Heuristic Rename Tracking
When you rename a file using `git mv old.js new.js`, Git understands that the file simply changed names, so your commit history follows along with it.
Understanding `git reset` (Soft vs Mixed vs Hard: The Critical Differences)
`git reset` moves your project's time machine backwards. `--soft` undoes the commit but keeps your code staged. `--mixed` keeps your code in your editor. `--hard` throws your changes in the trash.
Undoing Safely on Shared Branches with `git revert`
Instead of erasing history from the past, `git revert` adds a brand new commit that does the exact opposite of the bad commit. Like depositing $100 to fix an accidental $100 withdrawal.
Understanding HEAD, Commit References, and Caret/Tilde Ancestry Syntax
HEAD is Git's 'You Are Here' pin on the map. As you switch branches or make commits, the pin moves along with you.
Amending the Latest Commit with `git commit --amend`
Forgot to include one file, or made a spelling mistake in your commit message? `--amend` lets you slip changes into your last commit as if you did it right the first time.
Lightweight and Annotated Tags with `git tag` & Semantic Versioning
Tags are permanent bookmarks for important milestones in your project, like releasing 'Version 1.0.0'. Unlike branch pointers, tags never move when new commits are added.
Working with Multiple Files & Staging Logical Change Sets
Don't dump a whole week's work into one giant commit. Group your files into logical stories: one commit for database models, one for API routes, and one for UI styling.
Discarding Changes vs Creating New History: Safety Decision Matrix
Some Git commands build new safety nets, while others erase files from existence. Always ask: 'Have I pushed this yet, and do I have uncommitted work?' before running reset or clean.
Git Clean: Safely Removing Untracked Files and Build Artifacts (`git clean -fd`)
When your folder fills up with temporary test files, compiled junk, or downloads that Git doesn't track, `git clean` wipes the slate clean.
Level 3 — Branching and Merging
Fast-forward vs 3-way merges, merge conflict anatomy and resolution, rebasing, stash, and cherry-pick.
What Branches Are and Why They Are Virtually Free in Git
A branch in Git isn't a duplicate copy of your entire hard drive. It's just a tiny sticky note with a commit hash written on it. Creating a branch takes less than 1 millisecond.
Modern Branch Switching with `git switch` vs Legacy `git checkout`
Before Git 2.23, `git checkout` was used for everything: switching branches, making branches, and discarding files. `git switch` is the clear, dedicated command just for branches.
Creating and Managing Branches (`git branch`, List, Rename, Delete)
Branches are cheap, but after you finish a feature and merge it, clean up your old branches so your list doesn't become cluttered.
Branch Naming Conventions in Professional Teams
Naming your branch `my-stuff` tells nobody what you are working on. Naming it `feature/104-user-profile` lets everyone on the team know immediately.
Integrating Changes with `git merge` (Understanding Fast-Forward Merges)
When you finish work on your feature branch and `main` hasn't had any new commits while you were working, Git simply fast-forwards the `main` pointer forward. No conflicts, no hassle.
Three-Way Merges & The Merge Base Commit
When both you and your teammate made new commits at the same time, Git looks back to find the last point in time where you both agreed (the Common Ancestor), and intelligently weaves the changes together.
Merge Conflicts Explained: Anatomy of Conflict Markers
A merge conflict isn't an error or a crash. It's simply Git raising its hand and saying: 'Two people edited the exact same line in two different ways. I don't know who is right, so you decide!'
Resolving Merge Conflicts Step-by-Step with Verification
To fix a conflict: 1. Open the file. 2. Choose the correct code. 3. Delete the marker lines. 4. Run `git add <file>`. 5. Run `git commit`.
Aborting Merges Safely with `git merge --abort`
If a merge conflict looks terrifying, confusing, or touches files you don't understand, don't guess! Run `git merge --abort` and Git rewinds time as if you never attempted the merge.
Deleting Merged vs. Unmerged Branches & Remote Pruning (`git fetch --prune`)
When a teammate deletes a feature branch on GitHub after merging their PR, your local Git still remembers the old branch name until you run `git fetch --prune` to sweep away the ghost branches.
Rebasing Fundamentals: Moving the Branch Base Point
Imagine you started writing a chapter based on version 1 of a book. While you were writing, the author published version 2. Rebasing picks up your chapter and rewrites it as if you started from version 2 all along.
Merge vs. Rebase: The Great Debate & Team Strategy Guidelines
`merge` preserves the exact messy truth of what happened and when. `rebase` tells a clean, beautiful story. Use rebase on your own private laptop work; use merge once you share work with teammates.
Interactive Rebase (`git rebase -i`): Squashing, Rewording, and Reordering
While building a feature, you might make 10 messy commits ('fixed typo', 'test again', 'finally works'). Interactive rebase lets you squash all 10 into 1 beautiful, professional commit before your boss reviews it.
Cherry-Picking Commits with `git cherry-pick`
Imagine you are at an ice cream shop with 30 flavors. Instead of ordering the whole shop, you point to just one scoop of strawberry. Cherry-pick grabs just ONE specific commit from another branch without merging anything else.
Stashing Unfinished Work with `git stash` & Restoring with `pop`/`apply`
You're in the middle of writing code when your boss says 'Quick, check this bug on main!'. You don't want to make an ugly unfinished commit. `git stash` puts your work in a drawer so your desk is clean, and you can take it back out later.
Level 4 — GitHub Fundamentals
Remote repositories, SSH authentication, pushing, pulling, forks, markdown READMEs, and GitHub Pages.
What GitHub Provides Beyond Git (Ecosystem Overview)
Git is your local engine. GitHub is the global airport: with air traffic control (Pull Requests), passenger manifests (Issue trackers), automated maintenance hangars (GitHub Actions), and passport security (Dependabot & Secret Scanning).
Creating a GitHub Account, Organizations, and Profiles
Your GitHub profile is your modern software engineering resume. Recruiters, tech leads, and open-source contributors look at your GitHub profile to see your code, contributions, and project documentation.
Public vs. Private Repositories & Open Source Licenses (MIT, Apache, GPL)
Public means anyone on earth can read your code. Private means only people you invite can see it. A license tells people legally what they are allowed to do with your code (commercial use, modifications, redistribution).
Modern GitHub Authentication: SSH Keys vs. Personal Access Tokens (PATs)
You cannot type your regular website password into Git anymore. Instead, you create a digital key (SSH key) on your laptop and give GitHub the matching lock, or use a secure token.
Connecting a Local Repository to GitHub with `git remote add`
You built a project on your laptop. Now you tell Git: 'Whenever I say upload, send my code to this specific web address on GitHub.' We name this address 'origin'.
Uploading Changes with `git push` & Setting Upstream Tracking (`-u`)
Committing only saves code on your laptop. `git push` uploads those saved commits over the internet to GitHub so the world (or your team) can see them.
Downloading Remote Changes: `git fetch` vs. `git pull` in Depth
`git fetch` looks at GitHub and asks: 'Did anyone do new work?' and downloads the changes into a preview room without touching your files. `git pull` downloads AND immediately merges them into your active files.
Cloning Remote Repositories with `git clone` & Shallow Clones (`--depth 1`)
`git clone` downloads an entire project from GitHub onto your computer, including every single past commit, branch, and file since day one.
Forking Repositories on GitHub & The Open-Source Contribution Model
You cannot directly change code in Google's or Microsoft's repositories. Forking makes an exact copy of their project inside YOUR GitHub account. You make your improvements in your copy, and then send a Pull Request asking them to adopt your changes.
Writing Professional README Files with GitHub-Flavored Markdown (GFM)
A project without a README is like a product in a blank cardboard box with no manual. A great README tells visitors what your project does, how to install it, and why it's awesome within 30 seconds.
GitHub Issues, Labels, Milestones & Project Boards (Kanban)
Issues are your project's to-do list and bug report tracking center. Project boards let you drag and drop issue cards across columns like sticky notes on a whiteboard.
The Pull Request Lifecycle: From Creation to Review and Merge
A Pull Request says: 'Hey team, I finished this feature in my branch. Please review my code, test it, and pull it into main if you approve.'
Conducting Code Reviews & Leaving Actionable Line-by-Line Suggestions
Code review isn't about criticizing your teammates; it's about making the code stronger together. You can even suggest the exact fix right inside the comment so they can accept it with one click.
Mastering GitHub Flow: The Industry-Standard Branching Strategy
GitHub Flow is simple: 1. `main` is always working and deployable. 2. When you want to build something, branch off `main`. 3. Make commits. 4. Open a PR. 5. Once approved and tested, merge into `main` and deploy.
Publishing Static Websites for Free with GitHub Pages
GitHub gives every developer free web hosting. You put your HTML, CSS, and images in a repository, flip a switch in Settings, and GitHub gives you a live public URL (e.g., `username.github.io/my-site`).
Level 5 — Collaboration and Real Projects
Contributing workflows, branch protection rules, CODEOWNERS, conventional commits, and team governance.
Contributing to an Existing Repository: The Professional Workflow
Joining a team codebase is like visiting a new friend's house. You don't rearrange their furniture without asking. You read their rules (`CONTRIBUTING.md`), wipe your shoes (run tests), and ask before making big changes.
Managing Remote Upstreams & Keeping Local Branches in Sync
While you're working on your feature for three days, your teammates have already merged 20 other features into the main project. Syncing upstream keeps your laptop up to date so there are no surprises.
Configuring GitHub Branch Protection Rules (Require PRs, Passing CI, Linear History)
Branch protection is a digital bouncer at the door of your `main` branch. It physically disables the merge button unless all tests pass and a senior developer signs off.
Code Owners (`CODEOWNERS`): Automatically Assigning Specialized Reviewers
If someone changes the database or billing code, you want the billing specialist to review it automatically. `CODEOWNERS` is a rulebook that says: 'If you touch this folder, ask this person for approval.'
Conventional Commits in Team Workflows (`feat`, `fix`, `docs`, `chore`, `refactor`)
Instead of writing whatever comes to mind, teams use a shared grammar: `feat:` for new features, `fix:` for bug fixes, `docs:` for documentation. Computers can read this and automatically write release notes!
Creating Pull Request Templates (`.github/pull_request_template.md`)
When someone opens a new Pull Request, GitHub automatically fills their text box with your template questions: 'What did you change? Did you run tests? Did you include screenshots?'
Creating Structured Issue Templates (`.github/ISSUE_TEMPLATE/*.yml`)
Instead of letting users submit a blank issue saying 'Broken', Issue Forms give them neat text fields, dropdown menus, and checkboxes so you get the exact information needed to fix bugs.
Writing Constructive, Empathetic Code Review Comments
A great code reviewer critiques the code, never the person. Instead of 'You wrote bad code', say: 'Could we handle the empty list case here to avoid an unhandled error? Here is an idea: ...'
Multi-Contributor Conflict Resolution & Handling Divergent Pushes
When two developers work on the same file at the same time, Git will flag a conflict. The key to resolving it is talking to your teammate to agree on how both features should fit together.
Fixing Rejected Pushes Gracefully with Rebase
When you try to push your work, Git says 'Wait! Your teammate pushed code 5 minutes ago that you don't have yet.' Instead of making an ugly merge bubble, `git pull --rebase` slides your new commits neatly on top.
Recovering from Common Collaboration Failures (Accidental Commits & Wrong Branch)
We've all done it: you spent 2 hours writing code, committed it, and suddenly realized: 'Oh no, I'm on main, not on my feature branch!'. You can move those commits to a feature branch in 3 easy commands.
Managing Large Teams: Permissions, Roles, and Repository Governance
In a company with 100 people, not everyone should have the power to delete repositories or change billing. Junior developers get Write access; project managers get Triage access; team leads get Admin access.
Git Hooks Architecture: Client-Side vs. Server-Side Hooks
Git hooks are automated scripts that trigger at key moments. For example, a `pre-commit` hook automatically checks your code for syntax errors before allowing you to commit. If an error is found, Git stops you.
Automating Code Quality with Husky and `lint-staged`
Because default `.git/hooks` aren't shared when teammates clone a repo, Husky puts your hooks inside the project. Every time you commit, it automatically formats your code with Prettier and checks for linter errors in 1 second.
Designing a Production-Ready Team Git & GitHub Release Workflow
A professional engineering workflow connects everything you learned: developer branches off main, opens a PR with templates, passes CI tests, gets peer reviews, merges with Squash, and triggers automatic deployment to customers.
Level 6 — GitHub Actions and Automation
CI/CD concepts, YAML workflows, events, runners, dependency caching, secrets, and matrix testing.
What CI/CD Means: Continuous Integration & Continuous Deployment
CI/CD is a robot assistant for your team. Every time you push code, the robot wakes up on a clean computer, downloads your code, runs your tests, and if everything passes, publishes your website to users automatically.
Understanding GitHub Actions Architecture: Workflows, Events, Jobs, Steps & Runners
An Event (like opening a PR) triggers a Workflow (recipe). The workflow starts Jobs (tasks), which run on Runners (virtual computers in the cloud). Inside each job are Steps (individual commands).
Anatomy of a Workflow YAML File (`.github/workflows/*.yml`)
A workflow file is written in YAML, a clean text format that looks like an outline with indentation. You give it a name, tell it when to run, pick a computer type, and list your terminal commands.
Triggering Workflows on Push, Pull Request, Schedule, and Manual Dispatch
You don't want tests running when someone only edits a typo in the README. Event filters let you run tests only when files in `src/` change, or run security scans every Sunday night at midnight.
Hosted Runners (`ubuntu-latest`, `windows`, `macos`) vs. Self-Hosted Runners
GitHub provides free cloud computers for your workflows: Ubuntu (Linux), Windows, and macOS. They are wiped clean after every run, so tests always run in a fresh, identical environment.
Setting Up Node.js & Running Automated Tests (`actions/setup-node`)
To test your React or Next.js app in the cloud, the runner needs Node.js installed. `actions/setup-node` installs the exact version you need and caches your dependencies in seconds.
Setting Up Python & Running Automated Tests (`actions/setup-python`, `pytest`)
For Python, Django, or Flask projects, `actions/setup-python` sets up Python on the cloud runner, installs your libraries, and runs `pytest` to make sure your backend logic is bulletproof.
Caching Dependencies (`actions/cache`) to Slash Execution Time
Downloading `node_modules` from scratch on every push takes 2 minutes. Caching saves your downloaded files in a cloud locker. If your lockfile didn't change, the runner grabs the locker in 3 seconds.
Uploading & Downloading Workflow Artifacts (`actions/upload-artifact`)
Because runners are destroyed after each job ends, any compiled files disappear. Artifacts are zipped packages saved to GitHub's storage that you can download or pass to another job.
Managing Environment Variables & Encrypted Secrets (`${{ secrets.API_KEY }}`)
Never, ever hardcode passwords in your code or workflow files. Save them in GitHub's encrypted vault (Settings -> Secrets). In your workflow, you call them by nickname, and GitHub hides their values with `***` in all logs.
Permissions & The Principle of Least Privilege in Workflows (`permissions:` Block)
Every workflow gets an automatic digital badge (`GITHUB_TOKEN`). If you don't restrict it, a malicious third-party script could use that badge to alter your code. Setting strict permissions ensures the badge can only do what's strictly necessary.
Matrix Builds: Testing Across Multiple OS & Language Versions Simultaneously
Instead of writing 9 separate workflows to test on Windows, Mac, and Linux across Node 18, 20, and 22, a Matrix Build lets you define the combinations in 3 lines and runs all 9 tests simultaneously in parallel.
Debugging Failed Workflows, Re-Running Jobs & Viewing Live Runner Logs
When a red X appears on your PR, don't guess! Click on the red X, open the failed step, and read the exact error message. You can even click 'Re-run failed jobs' once you push a fix.
Level 7 — Advanced Git and Security
Git internals (objects, trees, blobs), reflog disaster recovery, submodules, LFS, GPG signatures, and security.
Git Internals Deep Dive: Objects, Blobs, Trees, and Commits
Under the hood, Git is really just a simple key-value database! Files are stored as Blobs, folders are stored as Trees, and snapshots are stored as Commits. The key is the SHA-1 hash, and the value is the compressed content.
The Directed Acyclic Graph (DAG) & Cryptographic Hashing
A DAG means Git history moves forward in one direction with no time loops. Every commit points backwards to its parent. Changing even a single comma in a file from 3 years ago changes every single hash all the way up to today.
Git Plumbing vs. Porcelain Commands (`cat-file`, `hash-object`, `ls-tree`)
Porcelain is the shiny user interface you touch every day: `commit`, `checkout`, `merge`. Plumbing is the internal pipes, valves, and gears underneath: `hash-object`, `cat-file`, `ls-tree`.
Resolving & Troubleshooting Detached HEAD States Safely
Usually, HEAD points to a branch name, which points to a commit. When you checkout a hash directly, HEAD points directly to the commit, bypassing the branch. It's safe to look around, but to save new work, give it a branch name!
Disaster Recovery: Finding & Restoring Lost Commits with `git reflog`
`git reflog` is Git's ultimate black-box flight recorder. Even if you run `git reset --hard` and think you deleted everything, reflog records every single step you took for the past 90 days. Almost nothing is ever truly lost.
Advanced Merge Strategies in Depth: `ort`, `recursive`, `ours`, `theirs`, `octopus`
Git has different brain algorithms for merging. The standard algorithm (`ort`) is lightning-fast. You can also give it hints like: 'If there's any conflict, always prefer my version' (`-X ours`).
Submodules vs. Monorepos: Managing Multi-Repository Codebases
Submodules let you keep a Git repository as a subfolder inside another Git repository. It's pinned to an exact commit, so external updates don't unexpectedly break your app.
Managing Large Files & Media Assets with Git LFS (Large File Storage)
Standard Git saves every version of every file forever. If you change a 1GB video 5 times, your repo becomes 5GB to download! Git LFS replaces the heavy file with a tiny 100-byte text ticket, storing the actual video in high-speed cloud storage.
Digitally Signing Commits & Tags with GPG and SSH Keys (Verified Badge)
Did you know anyone can set their Git email to `elonmusk@tesla.com` and make it look like someone else made a commit? Cryptographic signing attaches a mathematical wax seal proving the commit genuinely came from your private key.
Secrets Prevention & Credential Hygiene: git-secrets, Gitleaks, and TruffleHog
Automated scanner bots scan every single public commit on GitHub within 2 seconds of being pushed. If you commit an AWS key, bots will hijack your account and rack up $10,000 in bills in minutes. Prevention is critical.
Emergency Secret Remediation: Cleaning Git History with `git-filter-repo`
If a secret was committed 6 months ago, you need a heavy industrial shredder that goes through all 500 past commits and cuts out that file from every past snapshot.
GitHub Advanced Security: Dependabot, Secret Scanning & CodeQL SAST
GitHub has automated security guards watching your repository 24/7. Dependabot opens PRs when your npm libraries have security flaws. Secret Scanning stops you if you accidentally paste a password. CodeQL scans your code for SQL injection bugs.
Diagnosing & Optimizing Repository Performance (`git gc`, `git prune`, Packfiles)
Over time, creating thousands of commits creates lots of loose files. `git gc` is like defragmenting your hard drive: it compresses loose objects into compact packfiles, making Git operations 10x faster.
Final Capstone: Designing a Scalable Enterprise Git & GitHub Ecosystem
Congratulations on reaching Unit 100! You have traveled from understanding what a version is to mastering cryptographic DAG internals, team collaboration, CI/CD automation, and enterprise security. You are now fully prepared for the final 50-mark assessment and certification!
Official Git & GitHub Learning Resources
Techmiya curates and cross-references official documentation and interactive platforms so learners can continue independent study with verified authorities.
Learn Git Branching
- ✓Visualize Git branching and commit trees interactively
- ✓Master branch switching, fast-forward merges, and three-way merges
GitHub Skills Interactive Courses
- ✓Learn Git and GitHub through hands-on repository challenges
- ✓Practice GitHub Flow in real repositories
VS Code Source Control (Git Integration)
- ✓Use Git visually directly inside Visual Studio Code
- ✓Stage, commit, and push changes using VS Code UI
Pro Git Book (2nd Edition)
- ✓Comprehensive deep dive into Git architecture and commands
- ✓Understand Git internals: blobs, trees, commits, and refs
Official Git Documentation & Reference
- ✓Authoritative reference for all Git CLI commands and flags
- ✓Understand command syntax, flags, and return codes
GitHub Flow Guide
- ✓Master branch-based development workflow
- ✓Learn team collaboration rules: branch, commit, pull request, discuss, merge, deploy
GitHub Official Documentation
- ✓Complete guide to repositories, issues, PRs, wikis, and projects
- ✓Configure branch protection rules, code owners, and repository security
Microsoft Learn: GitHub Learning Paths
- ✓Enterprise GitHub fundamentals and DevOps integration
- ✓Manage repository security and secret scanning with GitHub Advanced Security
GitHub Skills: Review Pull Requests
- ✓Learn the art of reviewing teammate pull requests
- ✓Leave actionable line-by-line comments, suggestions, and approvals
GitHub Skills: Introduction to GitHub
- ✓Create your first GitHub repository from scratch
- ✓Communicate with markdown and manage issues
GitHub Skills: Hello GitHub Actions
- ✓Understand CI/CD automation concepts with GitHub Actions
- ✓Write your first workflow YAML file (.github/workflows)
GitHub Skills: Test with Actions
- ✓Run automated unit and integration tests on every pull request
- ✓Set up continuous integration pipelines for Python and Node.js
GitHub Actions Official Documentation
- ✓Master workflow syntax, matrix builds, job concurrency, and runners
- ✓Manage encrypted repository secrets and environment variables securely
GitHub Skills: Publish Packages
- ✓Automate software releases and tag generation
- ✓Publish artifacts to GitHub Packages registry (npm, PyPI, Docker)
Grade Boundaries & Certification Policy
Certification is strictly earned based on verified course completion and passing the 50-mark final assessment. Passing score is 31 marks (62%).
| Score (out of 50) | Grade | Status | Certificate |
|---|---|---|---|
| 46 – 50 | A+ | Excellent | Eligible ✓ |
| 41 – 45 | A | Very Good | Eligible ✓ |
| 36 – 40 | B | Good | Eligible ✓ |
| 31 – 35 | B+ | Pass | Eligible ✓ |
| 0 – 30 | Not Passed | Retake required | Unavailable |
Certification Eligibility Rules:
- 1100 Curriculum Units: Every single lesson ID in the course must be completed.
- 215 Practical Labs: All designated interactive lab scenarios must be completed.
- 350-Mark Assessment: Submit the 30-question final exam and score at least 31 marks.
- 4Downloadable PDF: Client-side high-resolution verified PDF with unique certificate ID.