Git and GitHub for System Administrators: A Practical Guide

Git is version control software that tracks changes in files over time. System administrators use it to manage PowerShell scripts, configuration files, infrastructure documentation, and runbooks — anything that changes and needs a history. Without version control, you rely on file copies, timestamps, and memory to understand what changed and when.

GitHub is a cloud platform that stores Git repositories remotely. It adds backup, access from multiple machines, and a foundation for collaboration. This guide walks through Git and GitHub from first setup to everyday workflows. All examples use Windows 10/11 and PowerShell, with C:\Projects\AdminScripts as the working directory throughout.

Requirements

Before starting, make sure the following are in place.

• Git for Windows — download and install from git-scm.com/download/win. Use default installer options. Git will be available in PowerShell after installation.
• GitHub account — register at github.com. A free account covers everything in this guide.
• PowerShell 5.1 or later — built into Windows 10/11. PowerShell 7+ also works.
• No administrator rights required for most steps.

After installing Git, verify it is available:

git --version

Expected output:

git version 2.x.x.windows.x

Set your identity. Git requires this before you can make your first commit:

git config --global user.name "Your Name"
git config --global user.email "your@email.com"
git config --global init.defaultBranch main

Project Setup

Create the working directory and initialize a Git repository inside it:

New-Item -ItemType Directory -Path "C:\Projects\AdminScripts"
Set-Location "C:\Projects\AdminScripts"
git init

Expected output:

Initialized empty Git repository in C:/Projects/AdminScripts/.git/

[Screenshot placeholder — PowerShell window showing git init output]

Your First Commit

A commit is a saved snapshot of your project at a specific point in time. It records what changed, when, and who made the change. You can return to any commit at any point.

Create a sample PowerShell script in your project folder:

@'
# Get-ServerInfo.ps1
# Returns basic system information for the local machine

$info = [PSCustomObject]@{
    Hostname   = $env:COMPUTERNAME
    OS         = (Get-CimInstance Win32_OperatingSystem).Caption
    Uptime     = (Get-Date) - (Get-CimInstance Win32_OperatingSystem).LastBootUpTime
    PowerShell = $PSVersionTable.PSVersion.ToString()
}

$info | Format-List
'@ | Set-Content "Get-ServerInfo.ps1"

Check what Git sees in your working directory:

git status

Git will list Get-ServerInfo.ps1 as an untracked file. This means Git sees it but is not yet recording changes to it. Stage the file to prepare it for the commit:

git add Get-ServerInfo.ps1

To stage all changed files at once:

git add .

Commit the staged file:

git commit -m "Add Get-ServerInfo script"

Write commit messages in the imperative form. Describe what the commit does, not what you did. Good: Add Get-ServerInfo script. Bad: added stuff, update, fix.

View the commit history:

git log --oneline

[Screenshot placeholder — git log --oneline output showing first commit hash and message]

Common git commit flags:

Tracking Changes

Once files are committed, Git tracks every subsequent change. Before committing again, you can inspect exactly what changed.

Modify the script to add a comment:

Add-Content "Get-ServerInfo.ps1" "`n# Last modified: $(Get-Date -Format 'yyyy-MM-dd')"

See what changed before staging:

git diff

Run git status again — the file now shows as modified. Stage and commit the change:

git add Get-ServerInfo.ps1
git commit -m "Add modification date comment to Get-ServerInfo"

Common git diff flags:

Connecting to GitHub

Create a repository on GitHub

Log into GitHub and create a new repository. Set the name to AdminScripts and the visibility to Private — recommended for any repository containing scripts with environment-specific details. Do not initialize with a README, since you already have a local repository with commits.

[Screenshot placeholder — GitHub new repository creation page with Private selected]

SSH vs HTTPS

Git connects to GitHub using two protocols. Choose one before adding the remote.

SSH is recommended for regular use. Once configured, you authenticate silently on every push and pull.

Set up SSH on Windows

Generate an SSH key pair:

ssh-keygen -t ed25519 -C "your@email.com"

Accept the default file location. Set a passphrase or leave blank.

Start the SSH agent and add your key:

Get-Service ssh-agent | Set-Service -StartupType Automatic
Start-Service ssh-agent
ssh-add "$env:USERPROFILE\.ssh\id_ed25519"

Copy your public key to the clipboard:

Get-Content "$env:USERPROFILE\.ssh\id_ed25519.pub" | Set-Clipboard

Go to GitHub → Settings → SSH and GPG keys → New SSH key. Paste the key and save.

Test the connection:

ssh -T git@github.com

Expected output:

Hi [your-username]! You've successfully authenticated, but GitHub does not provide shell access.

Connect your local repository to GitHub

git remote add origin git@github.com:[your-username]/AdminScripts.git

Push your commits to GitHub:

git push -u origin main

Common git push flags:

Working with Branches

A branch is an independent line of development. It lets you work on a change — a script rewrite, a new feature, a config update — without touching the stable version until you are ready to merge.

Practical scenario: You want to extend Get-ServerInfo.ps1 with disk usage reporting, but the current version is already in use on a server. Create a branch, develop and test there, then merge only when it works.

List existing branches:

git branch

Create a new branch and switch to it:

git checkout -b feature/add-disk-info

Make changes and commit on the branch:

# Add disk information to the script
Add-Content "Get-ServerInfo.ps1" @'

# Disk usage for all fixed drives
Get-PSDrive -PSProvider FileSystem | Where-Object { $_.Used -gt 0 } |
    Select-Object Name,
        @{N="Used_GB"; E={[math]::Round($_.Used/1GB,2)}},
        @{N="Free_GB"; E={[math]::Round($_.Free/1GB,2)}} |
    Format-Table -AutoSize
'@

git add Get-ServerInfo.ps1
git commit -m "Add disk usage section to Get-ServerInfo"

Switch back to main and merge the branch:

git checkout main
git merge feature/add-disk-info

Delete the branch after merging — it has served its purpose:

git branch -d feature/add-disk-info

Common git branch flags:

Common git checkout flags:

Pulling and Staying in Sync

When working across multiple machines or with colleagues, your local repository will fall behind the remote. Keeping in sync is a core Git habit.

Fetch remote changes without applying them:

git fetch

Pull remote changes and apply them immediately:

git pull

git pull is shorthand for git fetch followed by git merge. It downloads and immediately applies changes to your current branch.

Check upstream tracking status for all branches:

git branch -vv

This shows each local branch alongside its remote tracking branch and whether you are ahead, behind, or in sync with the remote.

Common git pull flags:

Useful Everyday Commands

git log

git log --oneline --graph

Shows a compact history with branch topology. Useful for understanding what happened and when. Add --all to include remote branches in the graph.

[Screenshot placeholder — git log --oneline --graph output with branch merges visible]

git stash

# Save uncommitted changes temporarily
git stash

# Restore them when ready
git stash pop

.gitignore

A .gitignore file tells Git which files and folders to never track. Create one in your project root:

@'
# Log and temporary files
*.log
*.tmp

# Output and export folders
output\
exports\

# Editor and OS metadata
.vscode\
Thumbs.db
desktop.ini

# Sensitive files - never commit these
*.key
*.pfx
secrets.ps1
credentials.ps1
'@ | Set-Content ".gitignore"

git add .gitignore
git commit -m "Add .gitignore for logs, exports, and sensitive files"

Quick reference

Tips for Sysadmins

Add PowerShell aliases for the commands you use most. Add these to your PowerShell profile ($PROFILE):

# Git shortcuts - add to $PROFILE
function gs { git status }
function ga { git add . }
function gp { git push }
function gl { git log --oneline --graph }

Store only text files. Git is designed for text. Store scripts, configs, YAML, JSON, and Markdown. Do not store compiled binaries, installers, or large files — they bloat the repository history permanently and cannot be undone without rewriting history.

Run git status constantly. Make it a habit before and after every operation. It costs nothing and prevents most common mistakes.

Commit early, commit often. Small commits are easier to understand, review, and revert. A commit that does one thing is better than a commit that does ten.

Use branches for anything non-trivial. Even for solo work. A branch costs nothing and gives you a safe space to experiment without touching a working version.

Official documentation

• Git documentation
• GitHub documentation

On this site

• Git and GitHub cheat sheet
• PowerShell scripting for sysadmins