GitHub: Your Cloud Backup

You’ll push your first project to GitHub and have a cloud backup you can access from anywhere.

Why This Matters

GitHub is three things at once:

1. Your backup. If your laptop dies, your code is safe in the cloud.
2. Your portfolio. Employers and collaborators check GitHub profiles. Every project you push is a signal that you build things.
3. Your collaboration hub. When you work with others — or even with yourself across multiple machines — GitHub is how code moves between them.

Most professional developers use GitHub or a similar Git hosting platform (GitLab, Bitbucket, Azure DevOps). Setting it up now means every project you build from here forward is automatically backed up and shareable.

The Mental Model: Google Drive for Code

You already use Google Drive or OneDrive to back up documents. GitHub does the same thing for code — but better. Instead of just storing the latest version, GitHub stores the complete history of every change you’ve ever made. You can go back to any point in time, see who changed what, and restore old versions instantly.

Prerequisites

Before starting this lesson, make sure you have:

• Git installed and configured (Module 7, Lesson 1) — run git --version to verify
• A local repository with at least one commit (Module 7, Lessons 2-3) — run git log --oneline to verify

If either of those fails, go back and complete the earlier lessons first.

Step 1: Create a GitHub Account

If you already have a GitHub account, skip to Step 2.

1. Go to github.com and click Sign up
2. Choose a username — this will be part of your profile URL (github.com/your-username), so pick something professional
3. Enter your email and create a password
4. Verify your email address
5. Choose the Free tier — it’s all you need for this course (and for most professional work)

Step 2: Install the GitHub CLI

The GitHub CLI (gh) lets you create repos, manage authentication, and interact with GitHub entirely from your terminal — no browser clicking required.

macOS:

brew install gh

Windows (native, via PowerShell):

winget install --id GitHub.cli

Windows (WSL) / Ubuntu / Debian:

sudo apt install gh

If apt has an older version, use the official install:

curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
sudo apt update
sudo apt install gh

Fedora / RHEL:

sudo dnf install gh

Verify the install:

gh --version

Authenticate with GitHub

Before you can push code, you need to log in:

gh auth login

This starts an interactive walkthrough. Choose these options:

1. Where do you use GitHub? → GitHub.com
2. Preferred protocol? → HTTPS (simpler for beginners; SSH works too)
3. Authenticate Git with your GitHub credentials? → Yes
4. How would you like to authenticate? → Login with a web browser

It will give you a one-time code, open your browser, and ask you to paste it. Once done, you’re authenticated.

Verify that authentication worked:

gh auth status

You should see your username and the scopes you’ve granted.

.gitignore Essentials

Not everything belongs on GitHub. Some files are generated, some are enormous, and some contain secrets that should never be shared. The .gitignore file tells git which files to skip. Set this up before your first push.

The starter template

Create a .gitignore file in your project root with this content:

# Dependencies (downloaded, not created by you)
node_modules/
__pycache__/
venv/

# Build output (generated, not source code)
dist/
build/
.output/

# Environment variables (secrets!)
.env
.env.local
.env.production

# OS files (junk your operating system creates)
.DS_Store
Thumbs.db

# Editor and tool files (personal settings)
.vscode/
.idea/
.claude/

# Logs
*.log

The rule of thumb

Commit things you created. Skip things that are generated or downloaded.

Step 3: Create Your First Remote Repository

Make sure you’re inside your local git project (the one with commits from previous lessons):

cd ~/my-project    # Replace with the actual path to YOUR project folder
git branch -M main # Ensure your branch is named "main" (the modern convention)
gh repo create my-first-project --public --source=. --remote=origin --push

That single command does everything. Here’s what each flag means:

After it runs, you’ll see a URL like https://github.com/your-username/my-first-project. Open it in your browser — your code is on GitHub.

The manual way (without gh CLI)

If you prefer or if gh isn’t available:

1. Go to github.com and click + then New repository
2. Name it, choose Public or Private, and do not add a README or .gitignore (you already have files)
3. Click Create repository
4. Copy the commands GitHub shows you and run them:

git remote add origin https://github.com/YOUR-USERNAME/my-first-project.git
git branch -M main
git push -u origin main

Both methods get you to the same place. The gh CLI just does it in one step.

Step 4: The Daily Push Workflow

Now that your repo is connected, pushing new work is simple:

git add .
git commit -m "Add feature description"
git push

Three commands. Your changes are staged, committed, and backed up to GitHub. This is the workflow you’ll use every time you finish a chunk of work.

Pre-Push Checklist

Before your first push to GitHub (and as a habit for every new project), verify these items:

1. .gitignore is in place and includes generated/downloaded folders (e.g., node_modules/, venv/, __pycache__/), .env, and build output (dist/)
2. No API keys or passwords in any committed file — search your code for strings like sk-, AKIA, or password =
3. The project builds and runs locally — run your project’s start command (npm run dev, python app.py, or your equivalent) and verify it works
4. Commits have meaningful messages — not “stuff” or “asdf”
5. Project config has a reasonable name — package.json, pyproject.toml, or equivalent will be public if the repo is public

Key Takeaways

• GitHub is your cloud backup and portfolio. Every project you push is safe from hardware failure and visible to collaborators (or employers).
• Push after every meaningful change. Don’t wait until the project is “done.” Frequent pushes mean frequent backups.
• .gitignore protects your secrets. Always set it up before your first commit. Never push .env files, node_modules/, or build output.
• The gh CLI simplifies everything. One command to create a repo and push — no browser required.
• The daily rhythm is simple: git add ., git commit -m "message", git push. Three commands, ten seconds, complete backup.