Build a Developer Portfolio with GitHub

Create a GitHub portfolio repo using branches, commits, and pull requests.

Introduction

30 Second Summary

Every developer needs a way to show their work and prove they can collaborate on code. GitHub is where that happens.

In this project, you will create a developer portfolio repository on GitHub and build it using the same professional branching workflow that development teams rely on every day.

What You'll Build

Picture sending someone a link to your GitHub repo and watching them scroll through a polished profile page, click into your Pull Request history, and see exactly how you proposed, reviewed, and merged code like a professional developer.

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

  • A formatted developer profile page written in Markdown that GitHub renders on your repo's homepage with headings, bullet lists, and sections.
  • A Python script added through the feature branch workflow, complete with a reviewed and merged Pull Request.
  • A clean commit history that shows you know how to work with branches, PRs, and the complete GitHub Flow process.
  • Secret Mission: Practice the full workflow independently by adding a new file through a second feature branch.

Are there any prerequisites?

You need a free GitHub account at github.com. No software installation is required since you'll do everything through GitHub's web interface.

Before We Start

Before We Start...

Before we dive in, let's lock in what you're about to build and why it matters for your development journey.

Create Your GitHub Repository

Before you can add any code or content to your portfolio, you need a place to store it all. On GitHub, that place is called a repository.

In this step, you'll create your first repository and confirm it's set up correctly. This is the foundation everything else in the project builds on.

In this step, get ready to:
  • Create a public repository named dev-portfolio on GitHub.
  • Confirm the repository page shows the correct branch and files.
Create a new repository on GitHub

A repository is like a project folder that lives on GitHub. It tracks every change you make, so you always have a full history of your work.

  • In the upper-right corner of any GitHub page, click the + dropdown menu.
  • Click New repository.
  • In the Repository name field, type dev-portfolio.
  • Under visibility, select Public.
  • Toggle Add README to On.
  • Click Create repository.

GitHub creates your repository and immediately loads its homepage.

What is a repository?

A repository (often shortened to "repo") is a storage space for your project's files and their entire revision history. Every time you save a change, the repository records exactly what changed and when.

Think of it as a project folder with a built-in time machine. You can always go back and see what your project looked like at any earlier point.

Don't see the + menu?

Make sure you are signed in to your GitHub account. The + menu only appears when you are logged in.

help me find the New repository option on GitHub

Confirm your repository is ready

Your repository page should now be loaded. Confirm the following three elements are present on the page:

  • The Code tab is highlighted at the top of the page.
  • The branch dropdown below the tabs shows main.
  • A file called README.md appears in the file list, and its content is rendered below as a heading with your repository name.

What is the main branch?

Every repository starts with a single branch called main. This is the default, "official" version of your project.

Later, you'll create separate branches to work on new features without touching main until you're ready.

What is README.md?

A README.md file is a Markdown document that describes your project. GitHub automatically renders it on your repository's homepage so visitors see formatted text instead of raw code.

Your repository is live and ready. Next up, you'll fill this repo with a developer profile that shows off your skills using Markdown formatting.

Build Your Developer Profile

Your repository is live on GitHub with a default README. Now you need real content to showcase who you are as a developer.

In this step, you'll write a formatted developer profile using Markdown and commit it directly to main. This gives you a visible result fast, but pay attention to what's missing from this workflow.

In this step, get ready to:
  • Edit README.md with a formatted developer profile using Markdown.
  • Commit the change directly to main.
Edit your README with a developer profile

GitHub renders Markdown files with rich formatting. Headings, bullet lists, and bold text all display beautifully when you write them in Markdown syntax.

  • In your repository's file list, click README.md to open it.
  • In the upper right corner of the file view, click the pencil icon button to open the file editor.
  • Select all the default content in the text box and delete it.
  • Replace it with the following Markdown profile:
# Hi, I'm [[YOURNAME="Your Name"]]

## About Me

I'm a beginner developer learning Python and Git. I'm currently exploring how to use GitHub to manage my projects and collaborate with others.

## Skills

- Python (beginner)
- Markdown
- GitHub

## Currently Learning

- Git workflows
- Feature branches
- Pull requests

What does this Markdown do?

Lines starting with # become headings. One # is the largest heading, two ## creates a subheading.

Lines starting with - become bullet points in a list. GitHub automatically renders all of this into a clean, readable page.

  • Above your new content, click Preview to see how your profile will look when rendered.

You should see your name as a large heading, with neatly formatted sections and bullet lists below it.

✔️ Awesome, I've got everything!

Great. Make sure your name replaces the placeholder text in the first heading. The rest of the content can stay exactly as shown.

ⓧ I'd like to double check the full code

Your README.md should contain this exact content (with your name replacing the placeholder):

# Hi, I'm [[YOURNAME="Your Name"]]

## About Me

I'm a beginner developer learning Python and Git. I'm currently exploring how to use GitHub to manage my projects and collaborate with others.

## Skills

- Python (beginner)
- Markdown
- GitHub

## Currently Learning

- Git workflows
- Feature branches
- Pull requests
Commit the change directly to main

A commit is a saved snapshot of your changes. Right now you'll commit directly to the main branch, which means your change goes live the instant you save it.

  • Click Commit changes... above the editor.
  • In the Commit message field, type Add developer profile to README.
  • Make sure Commit directly to the main branch is selected.

Before you click the final button, think about this: what happens to your repository homepage the moment you confirm this commit?

  • Click Commit changes to confirm.

GitHub immediately redirects you to the file view. Your formatted developer profile is already live on the repository homepage.

Did you notice what was missing?

That change went live instantly. There was no review step, no approval process, and no chance for anyone (including you) to catch a mistake before it appeared on main.

For a personal profile this is fine. But imagine a team of developers all committing directly to the same branch. One typo and the whole project could break for everyone. You'll solve this problem in the next step.

  • Click your repository name (dev-portfolio) at the top of the page to return to the homepage.

Your repository homepage now displays a beautifully formatted profile page with headings, bullet lists, and sections rendered from Markdown.

Still seeing the default README?

Make sure you clicked Commit changes in the dialog (not just the first Commit changes... button that opens the dialog). If your profile appears as raw text with # symbols showing, confirm the file is named README.md (not .txt).

Help me debug my README

Your profile is live and looking sharp. Next up, you'll learn why committing directly to main is a habit professional teams avoid, and how feature branches give you a safer way to work.

Create a Feature Branch and Add a Python Script

In the last step, your commit went directly to main and appeared on your repo homepage instantly. There was no review step, no safety check, and no chance to catch a mistake before it went live.

Feature branches solve this problem. A feature branch is a separate copy of your project where you can make changes without touching main. When your work is ready, you merge it back. This is how professional teams ship code safely.

In this step, get ready to:
  • Create a feature branch from main.
  • Add a Python script on the feature branch.
  • Verify the branch keeps your work isolated from main.
Create a feature branch from main

Right now your repository has only one branch: main. You're about to create a second branch where you can work without affecting the main copy.

  • Above the file list on your repository page, click the branch dropdown menu that says main.
  • Type add-hello-script into the text box.
  • Click Create branch: add-hello-script from main.

The branch dropdown now shows add-hello-script instead of main. You're now working on a copy of your project.

What is a feature branch?

A feature branch is a parallel version of your repository. It starts as an exact copy of main at the moment you create it.

Any changes you make on this branch stay here until you explicitly merge them back. This gives you a safe sandbox to experiment, add features, or fix bugs without risking the stable version of your project.

Why the name add-hello-script?

GitHub recommends short, descriptive branch names so collaborators can see what work is happening at a glance. The name tells anyone looking at your repo exactly what this branch is for.

Add a Python script to your branch

You're currently on the add-hello-script branch. Any files you create here will only exist on this branch.

  • Above the file list, click the Add file dropdown menu.
  • Click Create new file.
  • In the file name field at the top, type hello.py.
  • In the file contents text box, type the following Python script:
# My first Python script in this repo

def greet(name):
    return f"Hi! I'm {name}, and this is my developer portfolio."


def list_skills():
    skills = ["Python", "Markdown", "GitHub", "Git workflows"]
    print("My skills:")
    for skill in skills:
        print(f"  - {skill}")


if __name__ == "__main__":
    print(greet("Your Name"))
    list_skills()

What does this script do?

This Python script defines two functions. greet() returns a personalised greeting string. list_skills() prints a formatted list of your developer skills.

The if __name__ == "__main__" block at the bottom runs both functions when the script is executed directly. You won't run this script locally today. It's here to give you a realistic file to practice the branching workflow with.

Now commit this file to your feature branch.

  • Click Commit changes... in the upper right area of the page.
  • In the commit message field, type Add hello script with greeting and skills functions.
  • Make sure the option to commit directly to the add-hello-script branch is selected.
  • Click Commit changes.

GitHub returns you to the repository file list. You should see hello.py listed alongside README.md.

Don't see hello.py in the file list?

  • Check the branch dropdown at the top of the file list. It should say add-hello-script. If it says main, your file won't appear there because it only exists on the feature branch.
  • If you accidentally committed to main, delete the file from main and repeat the steps on the correct branch.

Help me figure out why my file isn't showing up on the right branch.

Verify branch isolation by switching back to main

Here's the key moment. You've created a file on your feature branch. What do you think happens when you switch back to main?

  • Click the branch dropdown that currently says add-hello-script.
  • Select main from the list.

Look at the file list. hello.py is gone. Only README.md exists on main.

Your work is safely isolated on the feature branch. Nothing you did there touched main.

Why does this matter?

On a real team, main is the stable, production-ready version of the code. Feature branches let multiple developers work on different things simultaneously without stepping on each other's changes. Nothing lands on main until it's been reviewed and approved.

✔️ Awesome, I've got everything!

Great. Double check you can see both branches in the dropdown and that hello.py only appears on add-hello-script.

ⓧ I'd like to double check the full code

Here is the complete hello.py that should exist on your add-hello-script branch:

# My first Python script in this repo

def greet(name):
    return f"Hi! I'm {name}, and this is my developer portfolio."


def list_skills():
    skills = ["Python", "Markdown", "GitHub", "Git workflows"]
    print("My skills:")
    for skill in skills:
        print(f"  - {skill}")


if __name__ == "__main__":
    print(greet("Your Name"))
    list_skills()

To check, switch to the add-hello-script branch using the dropdown, click hello.py in the file list, and compare your file contents to the code above.

Your feature branch is ready with a Python script that main knows nothing about. Next up, you'll open a Pull Request to review these changes and merge them into main the professional way.

Open a Pull Request and Merge

Your Python script lives on the add-hello-script branch, but it's not part of your main project yet. Anyone looking at your main branch won't see hello.py.

A Pull Request lets you review the changes, see exactly what's different, and merge only when you're satisfied. It's the bridge between "done on my branch" and "live in the project."

In this step, get ready to:
  • Open a Pull Request comparing your feature branch to main.
  • Review the diff to see your changes highlighted.
  • Merge the Pull Request and delete the feature branch.
Open a new Pull Request

A Pull Request is a proposal to bring changes from one branch into another. You're about to propose merging your add-hello-script work into main.

  • Click the Pull requests tab at the top of your repository page.
  • Click New pull request.
  • Make sure the base dropdown is set to main.
  • Set the compare dropdown to add-hello-script.

You should see a diff appear below the dropdowns. Your entire hello.py file is highlighted in green because it's brand new.

What does the diff show?

A diff shows the differences between the two branches you're comparing. Lines highlighted in green are additions. Lines in red are deletions.

Since hello.py is entirely new, every line shows as green. On a real team, reviewers use this view to check code before it goes live.

Submit the Pull Request

Now that you've reviewed the diff and confirmed your changes look correct, it's time to officially create the Pull Request.

  • Click the green Create pull request button.
  • In the Title field, type Add hello script to portfolio.
  • In the description box below the title, write a short summary of what this PR adds (e.g. "Adds a Python greeting script with a skills list function to the developer portfolio").
  • Click Create pull request to submit.

You should now see your Pull Request page. It shows your title, description, and a timeline of activity.

Why write a description?

On a real team, your teammates read the PR description to understand what changed and why. A clear description makes reviews faster and keeps the project history readable.

Don't see the Create pull request button?

Make sure the base is set to main and the compare is set to add-hello-script. If they're the same branch, GitHub has nothing to compare.

Help me figure out why I can't create my Pull Request.

Merge the Pull Request and clean up

Your Pull Request is open and ready for merging. On a team, a colleague would review it first. Since this is your own project, you can merge it yourself.

  • Scroll to the bottom of the Pull Request page.
  • Click Merge pull request.
  • Click Confirm merge.
  • Click Delete branch to clean up the feature branch.

Why delete the branch?

The branch's job is done. Its changes are now safely on main. Deleting it keeps your repository tidy and prevents confusion about which branches are still active.

Before you check the result, what do you think you'll see on the main branch now? Will hello.py be there?

  • Click the Code tab at the top of your repository.
  • Make sure the branch dropdown says main.

You should now see hello.py in your file list alongside README.md. Your feature branch work is officially part of your main project.

  • Click the Pull requests tab.
  • Click Closed to view merged Pull Requests.

Your Pull Request titled "Add hello script to portfolio" appears with a purple "Merged" icon. This is proof that you followed the professional GitHub Flow workflow: branch, commit, Pull Request, review, merge.

Don't see hello.py on main?

Check that the branch dropdown on the Code tab says main, not another branch. If you still don't see the file, go back to the Pull requests tab and confirm the PR status shows as "Merged" (purple icon). If it still shows as "Open", you may have missed the Confirm merge step.

Help me figure out why my merged file isn't showing on main.

Secret mission

Go Solo with a Second Feature Branch

Real developers repeat this workflow dozens of times a day. Can you complete the full branch, commit, PR, merge cycle on your own with minimal hand-holding?

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely on GitHub's free tier, so there are no ongoing costs. Decide whether to keep your repository public, make it private, or delete it entirely.

Resources you used:

  • GitHub repository dev-portfolio (contains README.md, hello.py, and interests.md).
  • Two merged Pull Requests in your repository history.

Keep everything running

No action needed. Choose this if you want your developer portfolio to stay visible on your GitHub profile.

  • Your dev-portfolio repository remains public and accessible to anyone with the link.
  • Your merged Pull Requests stay in the repository history as proof of your workflow skills.
  • GitHub free accounts have no storage limits for public repositories, so this costs nothing to maintain.

Pause - I'll come back to this later

Make your repository private so others can't see it while you're away. You can make it public again at any time.

  • Open your dev-portfolio repository on GitHub.
  • Click the Settings tab at the top of the repository page.
  • Scroll down to the Danger Zone section.
  • Click Change visibility and select Private.
  • Confirm the change by typing the repository name when prompted.

Delete - I don't want to use this again

Remove the repository entirely. This permanently deletes all files, commits, branches, and Pull Request history.

  • Open your dev-portfolio repository on GitHub.
  • Click the Settings tab at the top of the repository page.
  • Scroll down to the Danger Zone section.
  • Click Delete this repository.
  • Read the warnings, then type the full repository name (your-username/dev-portfolio) to confirm deletion.
  • Click the confirmation button. The repository and all its history are permanently removed.

Nice Work!

Nice Work!

You just built a developer portfolio on GitHub using the same branching workflow that professional teams rely on every day. Your repository now has a formatted profile, a Python script, and a clean history of merged Pull Requests.

Here's what you learned:

  • Built a GitHub repository with a formatted developer profile using Markdown headings, bullet lists, and sections.
  • Created a feature branch to safely develop a Python script without touching main, then opened a Pull Request to review and merge it professionally.
  • Practiced the complete GitHub Flow cycle: branch, commit, PR, review, merge, and delete the branch.
  • Secret Mission: Completed the full GitHub Flow cycle independently by creating a second feature branch, adding a new file, and merging it through a Pull Request.

Ready to quiz yourself?