Build a Portfolio Page with Git

Track a personal portfolio page with Git and publish it to GitHub.

Introduction

30 Second Summary

Think about how Google Docs lets you see every edit anyone has ever made to a document. Developers have the same power through version control, and it is the first skill interviewers look for.

In this project, you will build a personal portfolio webpage and track every change with Git and GitHub. You will go from an empty folder to a live GitHub repository with real commit history, branches, and a resolved merge conflict.

What You'll Build

Picture opening your GitHub profile and showing someone a repository with a clean commit history, feature branches, and a merge conflict you resolved yourself.

By the end of this project, you'll have:

  • A portfolio page you built and tracked entirely through the command line.
  • A GitHub repository with real commit history, branches, and merges that anyone can view online.
  • A resolved merge conflict that proves you can handle competing changes the way professional teams do.
  • An optional Secret Mission to push your skills even further.

Are there any prerequisites?

You will need VS Code installed and a GitHub account. This project walks you through installing and configuring Git from scratch, so no prior experience is needed.

Before We Start

Before writing a single line of code, let's lock in what you're about to build and why it matters.

Install and Configure Git

Your portfolio page will go through dozens of changes before it is finished. Without a way to track those changes, one bad edit could erase hours of work with no way to undo it.

Git is the tool that solves this problem. It records every change you save, so you can always roll back to a previous version. In this step, you will install Git on your machine and configure it with your identity so every change you record carries your name.

In this step, get ready to:
  • Install Git on Windows.
  • Configure your name, email, and default branch name.
  • Verify Git is installed and configured correctly.
Install Git on your machine

Git needs to be installed before you can use any of its commands. The fastest way to install it on Windows is with winget, a package manager built into modern Windows.

  • Press the Windows key to open your search bar.
  • Type PowerShell and press Enter to open it.
  • Install Git by running this command:
winget install --id Git.Git -e --source winget

What does this command do?

  • winget install tells the Windows package manager to download and install a program.
  • --id Git.Git targets the exact package so you get the official Git for Windows build.
  • -e requires an exact match on the package name, preventing accidental installs of a similarly named package.
  • After the install finishes, close your PowerShell window completely.
  • Open a new PowerShell window the same way (press the Windows key, type PowerShell, press Enter).

Why do I need to reopen the terminal?

The installer adds Git to your system's PATH, which tells the terminal where to find the git command. Your current terminal loaded the old PATH when it first opened. Closing and reopening it forces the terminal to pick up the updated PATH.

  • Confirm Git is installed by running this command:
git --version

✔️ I see a version number

You should see something like git version 2.55.0.windows.1. The exact number may differ slightly, and that is fine. Git is installed and ready to go.

ⓧ Command not found

This usually means the terminal is still using the old PATH. Try these fixes in order:

  • Make sure you closed and reopened your PowerShell window after the install finished.
  • If reopening did not help, try restarting your computer so all PATH changes take effect.
  • If winget was not available or the install failed, download the standalone installer from git-scm.com/download/win and run it with the default options. Then close and reopen your terminal.
Configure your identity

Git stamps your name and email on every change you record. This is how your teammates (and future employers) know who made each change. You also need to set the default branch name to main so it matches GitHub.

  • Set your name, email, and default branch by running these commands (replace the placeholder values with your real name and the email tied to your GitHub account):
git config --global user.name "[[YOUR_NAME="Your Name"]]"
git config --global user.email "[[YOUR_EMAIL="your.email@example.com"]]"

git config --global init.defaultBranch main

What do these commands do?

  • user.name sets the name that appears on every commit you create.
  • user.email sets the email attached to each commit. Use the same email as your GitHub account so GitHub can link your commits to your profile.
  • init.defaultBranch main tells Git to name the first branch main whenever you create a new repository. GitHub also uses main as its default, so this keeps them in sync.
  • --global means these settings apply to every Git project on your machine, not just one folder.
Verify your setup

Before you run the next commands, take a guess. What do you expect Git to print when you ask it for the name and email you just configured?

  • Check your Git version and identity by running these commands one at a time:
git --version
git config --global user.name
git config --global user.email

The first command prints your Git version (e.g. git version 2.55.0.windows.1). The second prints your name. The third prints your email.

Not seeing your name or email?

  • If the command prints nothing, run the git config --global user.name and git config --global user.email commands from the previous substep again. Make sure you included the value in quotes after the key.
  • Double check that you did not accidentally add extra spaces or leave out the closing quote.

Help me figure out why my git config is not showing my name or email.

Git is installed and knows who you are. Next up, you will create your first repository and start tracking your portfolio page with real commits.

Create Your First Repository and Commits

Your Git installation is configured and ready. Now it is time to turn an ordinary folder into a project that Git can track.

In this step, you will create a portfolio page and record each change as a commit. A commit is a snapshot of your project that you can return to at any time.

In this step, get ready to:
  • Create a project folder and initialize it as a Git repository.
  • Build a portfolio page and create your first commit.
  • Edit the page and commit the change, building your first commit history.
Create a project folder and initialize a Git repository

Every Git project starts with a folder and a single command. You will create a folder on your Desktop and turn it into a repository that tracks every change.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder, move into it, and initialize a Git repository by running these commands:
mkdir my-portfolio
cd my-portfolio
git init

You should see a message that says Initialized empty Git repository in .../.git/.

What is a Git repository?

When you run git init, Git creates a hidden .git folder inside your directory. This folder stores your entire project history.

From this point on, Git watches the my-portfolio folder for changes. Any file you add, edit, or delete can be recorded.

Seeing 'mkdir: cannot create directory'?

Make sure you ran cd ~/Desktop first. If your Desktop path is different, navigate to it in File Explorer and check the full path in the address bar.

help me troubleshoot my Git repository setup

Now open VS Code so you can create your portfolio page.

  • Press the Windows key (Windows) or Cmd+Space (macOS) to open your search bar.
  • Type Visual Studio Code and press Enter to open it.
  • In VS Code, click File in the top menu bar.
  • Click Open Folder.
  • Navigate to your Desktop, select the my-portfolio folder, and click Select Folder.

Trust the authors?

VS Code may ask if you trust the authors of the files in this folder. Click Yes, I trust the authors to continue.

  • In VS Code's Explorer sidebar on the left, click the New File icon (the page icon with a plus sign) next to MY-PORTFOLIO.
  • Type index.html and press Enter.
  • Paste the following HTML into index.html:
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>My Portfolio</title>
</head>
<body>
    <h1>Hi, I'm [[YOURNAME="your name"]]</h1>
    <p>Welcome to my portfolio.</p>
    <h2>About Me</h2>
    <p>I'm an aspiring developer.</p>
</body>
</html>

What does this HTML do?

  • The <h1> tag creates your page's main heading with your name.
  • The <p> tag below it holds a short welcome message.
  • The <h2> and second <p> create an About Me section with a brief description.
  • Save index.html by pressing Ctrl+S (Windows) or Cmd+S (macOS).
  • Open the my-portfolio folder on your Desktop in File Explorer (Windows) or Finder (macOS) and double-click index.html to open it in your browser.

You should see a page with your name as a heading, a welcome message, and an About Me section.

Page looks blank or shows raw code?

Check that the file is saved with the .html extension, not .txt. Also confirm that you pasted the code starting from <!DOCTYPE html> on the very first line with no extra characters before it.

help me fix my HTML page not rendering

Stage and commit the file

Your file exists, but Git is not tracking it yet. You need to stage the file (tell Git you want to include it) and then commit it (save a snapshot).

  • Switch back to your terminal and check the status of your repository by running:
git status

You should see index.html listed in red under Untracked files. This means Git sees the file but is not tracking it yet.

  • Stage index.html and create your first commit by running these commands:
git add index.html
git commit -m "Add initial portfolio page with heading and about section"

You should see output confirming the commit, including 1 file changed.

What are staging and committing?

Staging with git add is like placing items on a table before taking a photo. You choose exactly which changes to include. Files you do not stage are left out of the snapshot.

Committing with git commit takes the photo. The -m flag attaches a message describing what changed, so you can understand each snapshot later.

Seeing 'nothing to commit'?

Make sure you saved index.html in VS Code before running git add. An unsaved file has no changes on disk for Git to detect.

help me fix my first Git commit

Make a second change and commit it

A single commit is a start, but the power of Git comes from building a history of changes. You will edit your welcome message and commit the update.

  • In VS Code, open index.html and find this line:
<p>Welcome to my portfolio.</p>
  • Replace that line so it reads:
<p>Welcome to my portfolio. I'm learning web development and version control with Git.</p>
  • Save index.html with Ctrl+S (Windows) or Cmd+S (macOS).
  • Switch to your terminal and see exactly what changed by running:
git diff

What does git diff show?

The git diff command shows the exact lines that changed since your last commit. Lines in red (prefixed with -) are the old version. Lines in green (prefixed with +) are the new version.

  • Stage and commit this change by running:
git add index.html
git commit -m "Update welcome message with learning goals"

You should see another confirmation message with 1 file changed.

Before you run the next command, predict: how many commits do you think will appear in the log?

  • Check your commit history by running:
git log --oneline

You should see two commits, each on its own line, with the messages you wrote. The most recent commit appears at the top.

What does git log show?

Each line in the git log --oneline output shows a short commit ID (a unique hash) followed by your commit message. This is your project's timeline. You can always scroll back through it to see what changed and when.

✔️ Awesome, I've got everything!

Great. Double check you have saved index.html and that your git log --oneline shows both commits.

ⓧ I'd like to double check the full code

Your index.html should look exactly like this:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>My Portfolio</title>
</head>
<body>
    <h1>Hi, I'm [[YOURNAME="your name"]]</h1>
    <p>Welcome to my portfolio. I'm learning web development and version control with Git.</p>
    <h2>About Me</h2>
    <p>I'm an aspiring developer.</p>
</body>
</html>

Only seeing one commit?

Make sure you ran git add index.html and git commit -m "..." after editing the welcome message. Each change needs its own add-and-commit cycle.

help me see both commits in my git log

Your repository has its first real history. Next up, you will push this repository to GitHub so it lives online and anyone can see it.

Push Your Repository to GitHub

Your portfolio page is tracked by two commits, and you can see exactly what changed between each one. Right now, though, your repository only exists on your machine.

In this step, you will push your local repository to GitHub so your work is backed up online and visible to anyone you share the link with.

In this step, get ready to:
  • Create a public repository on GitHub to host your code.
  • Connect your local repository to the GitHub repository.
  • Push your commits so they are visible online.
Create an empty repository on GitHub

Before you can push code, you need a destination for it on GitHub. You will create an empty repository that your local project will connect to.

  • In your browser, navigate to https://github.com/new.
  • Sign in to your GitHub account if prompted.
  • Enter my-portfolio in the Repository name field.
  • Select Public.
  • Leave Add a README file, Add .gitignore, and Choose a license unchecked.
  • Click Create repository.

GitHub displays a Quick Setup page with instructions for connecting a local repository. Keep this page open for the next substep.

Why leave the initialization options unchecked?

Your local repository already has commits and files. If GitHub created its own README or license, the two repositories would have conflicting histories, and your first push would fail.

Starting the GitHub repository empty means your local commits slot in cleanly.

Connect your local repository to GitHub

Your GitHub repository exists, but your local Git repository does not know about it yet. You need to add the GitHub URL as a remote so Git knows where to send your commits.

  • On the Quick Setup page, find the HTTPS URL near the top. It looks like https://github.com/your-username/my-portfolio.git.
  • Switch back to your terminal and add this URL as a remote called origin by running this command:
git remote add origin https://github.com/[[GITHUB_USERNAME="your GitHub username"]]/my-portfolio.git
  • Verify the connection by running:
git remote -v

You should see origin listed twice, once for fetch and once for push, both pointing to your GitHub repository URL.

What is a remote?

A remote is a version of your repository hosted on another server. The name origin is a convention for your primary remote. Think of it as a bookmark that tells Git where to send your code when you push.

Seeing "remote origin already exists"?

This means a remote named origin was already added. You can remove it and try again by running:

git remote remove origin

Then re-run the git remote add origin command with your correct URL.

Still stuck? Help me fix my git remote connection.

Push your commits to GitHub

Your local repository is connected to GitHub, but GitHub's repository is still empty. Pushing sends your commits from your machine to the remote.

  • Push your commits to GitHub by running this command:
git push -u origin main

What does this command do?

This command uploads your local main branch to the remote called origin. The -u flag sets origin main as the default destination. After this, future pushes only need git push with no extra arguments.

A browser window popped up?

The first time you push, Git may open a browser window asking you to sign in to GitHub. This is normal. Follow the prompts to authenticate, and your push will continue automatically.

Before you check your GitHub page, what do you expect to see there now?

  • Refresh your GitHub repository page in the browser.

Both commits appear in the commit history, and index.html is listed in the file browser. Your local work now lives on GitHub.

Push failed or nothing showing up?

  • If you see an authentication error, make sure you completed the sign-in prompt in your browser. Close the terminal, reopen it, navigate back to my-portfolio, and try the push again.
  • If you see "error: src refspec main does not match any", confirm your default branch is named main by running git branch. If it shows master instead, rename it by running:
git branch -M main

Then try the push command again.

Still stuck? Help me push my local repository to GitHub.

Your portfolio is backed up and publicly visible on GitHub. Next up, you will create a feature branch to add a new section to your page, the same way professional teams isolate their work before merging it in.

Work on a Feature Branch

Your portfolio page is on GitHub, backed up and visible to anyone with the link.

Every change so far has gone directly into main. On a professional team, that would be risky because one broken commit affects everyone.

In this step, get ready to:
  • Create a feature branch to isolate your changes from main.
  • Add a Skills section and update the About Me paragraph on the branch.
  • Stage and commit your changes so they are recorded on the branch.
Create and switch to a feature branch

A branch is a separate line of development. Changes you make on a branch do not affect main until you choose to merge them back in.

  • Create a new branch called add-skills and switch to it by running this command:
git checkout -b add-skills

What does this command do?

  • git checkout switches you to a different branch.
  • The -b flag tells Git to create the branch first, then switch to it. Two actions in one command.
  • Confirm you are on the new branch by running:
git branch

You should see two branches listed. The asterisk next to add-skills means that is your current branch.

Don't see the asterisk next to add-skills?

  • If you see an error saying the branch already exists, you may have run the command before. Run git checkout add-skills (without -b) to switch to it.
  • Make sure you are in the my-portfolio folder. Run pwd to check your current directory.

Help me figure out why my branch didn't get created.

Why not just work on main?

Professional teams treat main as the stable, production-ready version of the code. New features get their own branch so that unfinished work never breaks main.

Once the feature is tested and ready, the branch gets merged back in. This workflow is called feature branching, and you will see it in almost every team that uses Git.

Update About Me and add a Skills section

Now that you are on the add-skills branch, any edits you make to index.html stay on this branch. The main branch remains untouched.

  • In index.html in VS Code, find this line inside the About Me section:
    <p>I'm an aspiring developer.</p>
  • Replace that line so it reads:
    <p>I'm an aspiring developer who loves solving problems with code.</p>
  • Below the closing </p> tag of the About Me paragraph you just edited, add this Skills section:
    <h2>Skills</h2>
    <ul>
        <li>HTML</li>
        <li>CSS</li>
        <li>Git</li>
        <li>GitHub</li>
    </ul>

What does this code do?

  • The <h2> tag creates a second-level heading for the new Skills section.
  • The <ul> tag creates an unordered (bulleted) list. Each <li> inside it is one skill.
  • Save index.html.
  • Open the file in your browser by double-clicking index.html in your file explorer, or by right-clicking the file in VS Code and selecting Reveal in File Explorer, then double-clicking it.

You should see the updated About Me paragraph and a new Skills heading with HTML, CSS, Git, and GitHub listed below it.

Don't see the Skills section?

  • Make sure you saved index.html in VS Code. A dot on the file tab means unsaved changes.
  • Check that the Skills HTML is placed after the About Me </p> tag and before the closing </body> tag.
  • Verify you have matching opening and closing tags for <ul> and each <li>.

Help me fix my Skills section in index.html.

✔️ Awesome, I've got everything!

Great. Double check you have saved index.html before moving on.

ⓧ I'd like to double check the full code

Here is what your full index.html should look like at this point.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>My Portfolio</title>
</head>
<body>
    <h1>Hi, I'm [Name]</h1>
    <p>Welcome to my portfolio. I'm learning web development and version control with Git.</p>
    <h2>About Me</h2>
    <p>I'm an aspiring developer who loves solving problems with code.</p>
    <h2>Skills</h2>
    <ul>
        <li>HTML</li>
        <li>CSS</li>
        <li>Git</li>
        <li>GitHub</li>
    </ul>
</body>
</html>
Stage and commit your changes on the branch

Your edits are saved on disk, but Git has not recorded them yet. You need to stage and commit to capture this snapshot.

  • Check which files changed by running:
git status

You should see index.html listed in red as a modified file. The red means it is not staged yet.

  • Stage the file and commit your changes by running these commands:
git add index.html
git commit -m "Add skills section and expand about me description"

What do these commands do?

  • git add index.html moves the file into the staging area, telling Git you want this change in the next commit.
  • git commit -m records the staged snapshot with a message describing what changed. This commit exists only on the add-skills branch.

Before you run the next command, think about what you expect to see. How many commits should exist, and on which branches?

  • View the commit history across all branches by running:
git log --oneline --all

You should see three commits. The add-skills branch is one commit ahead of main. That third commit only exists on your feature branch.

Don't see three commits?

  • If you see only two commits, your git commit may not have run. Scroll up in your terminal and check for errors. Run git status to see if changes are still staged or unstaged.
  • If you see a message about needing to configure your identity, run git config --global user.name to check that your name is set from Step 1.

Help me figure out why my commit did not appear in the log.

Your feature branch has its own commit. Next up, you will merge it back into main and handle what happens when both branches change the same line.

Merge and Resolve a Conflict

In the last step, you created a feature branch and added a Skills section along with an updated About Me paragraph. Now it is time to bring those changes back into main.

But what happens when two branches edit the same line of code? Git cannot decide which version to keep, so it asks a human to resolve the conflict.

In this step, you will set up exactly that situation, then learn to resolve the conflict that follows. This is a daily reality for professional development teams and a common interview topic.

In this step, get ready to:
  • Switch to main and make a competing change to the About Me paragraph.
  • Merge the add-skills branch and encounter a merge conflict.
  • Resolve the conflict, complete the merge, and push the result to GitHub.
Make a competing change on main

The add-skills branch changed the About Me paragraph to mention solving problems with code. To create a realistic conflict, you need to change that same paragraph on main to something different.

  • Switch back to main by running this command:
git checkout main

Look at index.html in VS Code. The Skills section you added on add-skills is gone.

Where did the Skills section go?

Each branch has its own version of the files. When you switch branches, Git updates your working files to match that branch's latest commit.

The Skills section is safe on add-skills. It will come back when you merge.

  • In VS Code, find the About Me paragraph in index.html:
    <p>I'm an aspiring developer.</p>
  • Replace it so the line reads:
    <p>I'm a junior developer focused on building real projects.</p>
  • Save index.html.
  • Stage and commit this change by running these commands:
git add index.html
git commit -m "Update about me description on main"

You should see a confirmation that one file changed with one insertion and one deletion.

Seeing "nothing to commit"?

Make sure you saved index.html in VS Code before running git add. Unsaved changes stay in the editor and Git does not see them.

Why is Git saying nothing to commit?

Merge the feature branch and hit a conflict

Both branches now have a different version of the About Me paragraph. This is exactly how conflicts happen in real team projects.

Before you run the next command, predict: will Git be able to merge both changes automatically, or will it need your help?

  • Merge the add-skills branch into main by running:
git merge add-skills

Git prints a message saying there is a conflict in index.html and the automatic merge has failed. This is expected.

What does the conflict message mean?

Git tells you CONFLICT (content): Merge conflict in index.html followed by Automatic merge failed; fix conflicts and then commit the result..

Git merged everything it could automatically (the Skills section came over cleanly). But the About Me paragraph was changed on both branches, so Git cannot pick a winner.

  • Switch to index.html in VS Code.

You will see conflict markers in the About Me section. They look like this:

<<<<<<< HEAD
    <p>I'm a junior developer focused on building real projects.</p>
=======
    <p>I'm an aspiring developer who loves solving problems with code.</p>
>>>>>>> add-skills

What do these markers mean?

  • <<<<<<< HEAD marks the start of the version on your current branch (main).
  • ======= divides the two competing versions.
  • >>>>>>> add-skills marks the end of the version from the branch you are merging in.
  • Git is asking you: which version do you want to keep, or do you want to combine them into something new?

VS Code highlights conflicts

VS Code highlights the conflict with colors and may show buttons like Accept Current Change, Accept Incoming Change, or Accept Both Changes. In this step you will edit the text manually to learn what is happening under the hood.

Resolve the conflict and complete the merge

Time to play the role of the human decision-maker. You will combine the best of both versions into one paragraph.

  • In index.html, find the conflict markers block (from <<<<<<< HEAD through >>>>>>> add-skills).
  • Delete the entire block and replace it with this single line:
    <p>I'm a junior developer who loves solving problems and building real projects.</p>

Why this particular wording?

You are combining the best of both branches. "Junior developer" comes from the main version. "Loves solving problems and building real projects" blends ideas from both.

In a real team, you would discuss the wording with your teammate. The key skill is removing the markers and producing clean, working code.

  • Make sure all conflict marker lines (<<<<<<<, =======, >>>>>>>) are completely removed.
  • Save index.html.

✔️ Awesome, I've got everything!

Great. Double check you have saved index.html and that no conflict markers remain anywhere in the file.

ⓧ I'd like to double check the full code

Your index.html should now look exactly like this:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>My Portfolio</title>
</head>
<body>
    <h1>Hi, I'm [Name]</h1>
    <p>Welcome to my portfolio. I'm learning web development and version control with Git.</p>
    <h2>About Me</h2>
    <p>I'm a junior developer who loves solving problems and building real projects.</p>
    <h2>Skills</h2>
    <ul>
        <li>HTML</li>
        <li>CSS</li>
        <li>Git</li>
        <li>GitHub</li>
    </ul>
</body>
</html>
  • Complete the merge by staging and committing the resolved file:
git add index.html
git commit -m "Merge add-skills branch and resolve about me conflict"

You should see a confirmation message for your merge commit.

What is a merge commit?

A merge commit ties together the histories of both branches into a single timeline. It has two parent commits instead of one, which is why git log --graph will show lines branching and converging.

Seeing an error about remaining conflicts?

Open index.html and search for <<<<<<< or ======= or >>>>>>>. If any of these markers remain, Git considers the conflict unresolved. Remove them, save, and run git add index.html again before committing.

Help me resolve this merge conflict

  • Clean up by deleting the merged branch:
git branch -d add-skills

You should see a message confirming that the add-skills branch has been deleted.

  • Push the resolved merge to GitHub by running:
git push

Push rejected or authentication failed?

If you see an authentication error, a browser window may need to open for you to sign in to GitHub again. Run git push a second time after signing in.

Help me fix my git push

Before you check the log, predict: how many commits do you expect to see, and what shape will the graph have?

  • Verify the merge by running:
git log --oneline --graph

You should see the merge commit at the top, with lines branching and converging to show where add-skills split off and merged back in.

  • Open index.html in your browser by double-clicking the file in File Explorer (Windows) or Finder (macOS).

The page shows the combined About Me text and the Skills section together. Your merge conflict is fully resolved.

  • Refresh your GitHub repository page in the browser.

Both the merge commit and the updated index.html appear on the repository's main page.

Secret mission

Open a Pull Request on GitHub

You've merged branches from the command line. Now complete the professional workflow by opening a pull request on GitHub. This is the same tool real teams use to review and approve code changes before they go live.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally with a free GitHub repository, so there are no ongoing costs. Decide whether to keep your resources, pause them to come back later, or delete them entirely.

Resources you used:

  • my-portfolio folder on your Desktop.
  • my-portfolio repository on GitHub.
  • Git (installed via winget).

Keep everything running

No action needed. Choose this if you are still actively building or plan to add more content to your portfolio page.

  • Your my-portfolio folder stays on your Desktop, ready for more changes.
  • Your GitHub repository remains live and publicly visible.
  • Git stays installed and configured for your next project.

Pause - I'll come back to this later

This project has no running processes or paid services. Your local files and GitHub repository are already idle and cost nothing.

  • Your my-portfolio folder and GitHub repository will be exactly where you left them when you come back.
  • Your Git configuration (name and email) persists across terminal sessions, so you do not need to reconfigure anything.

Delete - I don't want to use this again

Remove all project resources and start fresh.

  • Delete the local my-portfolio folder by running the command for your operating system:

macOS

rm -rf ~/Desktop/my-portfolio

Windows

Remove-Item ~/Desktop/my-portfolio -Recurse -Force
  • Delete the my-portfolio repository on GitHub:
  • Go to your my-portfolio repository page on GitHub.
  • Click the Settings tab.
  • Scroll down to the Danger Zone section at the bottom of the page.
  • Click Delete this repository and follow the confirmation prompts to complete the deletion.
  • Uninstall Git on Windows by running this command:
winget uninstall --id Git.Git

Nice Work!

Nice Work!

You just built a personal portfolio page tracked entirely with Git and pushed it to GitHub! You now have hands-on experience with the same workflow professional development teams use every day.

You've learned how to:

  • Installed and configured Git on Windows, initialized a repository from scratch, and tracked every change to your portfolio page with meaningful commits.
  • Pushed your repository to GitHub and used the feature branch workflow to isolate changes before merging them back into main.
  • Deliberately created and resolved a merge conflict, proving you can handle one of the most common challenges in team development.
  • Completed an optional Secret Mission to push your skills even further.

Ready to quiz yourself?