Curating GitHub Links on Your Resume: Projects, Seniority, and How to Guide

GitHub isn't just the number one platform for software development and version control with Git.

It's not only an open-source community for Computer Science (CS) professionals to manage, track, and make changes to their code.

Describing it as "the leading online environment for developers" is the understatement of the century.

GitHub is an almighty instrument - allowing for an entirely transparent (supposedly) showcase of your coding skills.

That's what gets recruiters: if you've invested the time to structure and organize your GitHub portfolio, you've one foot in the interviewers' doors.

Unlike your one- to two-page resume, GitHub offers 1 GB of free storage to include any code you've ever written.

So, choose your projects wisely, and remember that your portfolio will be assessed by humans (recruiters).

Those HR professionals without technical knowledge may just want to see the end product, rather than the source code.

But let's not get too far ahead of ourselves: here's some food for thought as to why having GitHub on your resume is important.

Some companies use "have GitHub link" as a resume filter. They may even ask for a GitHub profile for professionals with over 10 years of experience.

What is more, in startups and smaller companies your profile would most often be assessed by either the CEO or a technical lead, who will look at the work you've done before anything else.

Including (or not) your GitHub link on your resume is entirely up to you, but we recommend it.

With this guide, we'll obviously try to win you over why it's a good idea to curate your GitHub portfolio on your resume.

So stick around to find out:

• +5 benefits of including your GitHub portfolio on your resume;

• Types of projects you could include: what recruiters expect to see;

• Checklist: how to include GitHub on your resume;

• 6 resume sections to showcase your GitHub;

• GitHub links and cover letters: a good idea or not?

Why your GitHub portfolio and resume go together like coffee and cream

When assessing your IT resume, there are two most common scenarios.

Either, the recruiters would avoid clicking on any external links and skip your GitHub profile.

Or, the hiring managers would glance over your GitHub.

Without drilling too much into your source code, they'd expect to see your end products or projects. Also, if there's something interesting you've been working on.

In that case, your GitHub portfolio can create numerous opportunities during the interview process to stand out.

Here are six of the main reasons why.

1. Your GitHub provides an honest perspective, outside the interview process.

Incorporating your side projects or portfolio adds depth to your application.

Thus, hinting to recruiters at

• the programming languages you're apt at;
• how comfortable you are in using best-industry practices for a wide range of tools;
• the kinds of projects you'd like to work on.

2. Having a well-organized GitHub portfolio shows your competency and the projects you're most proud of.

Think of it as an opportunity to highlight, something that makes you a good candidate, that recruiters need to check out.

This can also sometimes even help you to skip the code sample request stage during the interview process.

3. GitHub is your alibi: to show that programming isn't just a job for you.

Coding is something you look to excel in - you take every single free moment of your day to become better at it.

4. Speaking of, GitHub is your commitment to the CS industry.

Using it, recruiters can easily understand just how engaged you're in the IT community and what your collaboration skills are like.

5. GitHub highlights skills you can't demonstrate otherwise during the application/ interview process.

• Do you have coding experience on real software projects? What was your role in them?
• What are all the programming languages you can use? How comfortable are you using each one?
• Are you able to use other revision control tools, apart from Git?

6. GitHub rockets your resume to the top of recruiters' "approved" checklists.

Don't include your profile just for the sake of it. Make sure that you've updated your GitHub and have taken the time to organize it.

The best filter you can use is: "What is the most impressive thing I've built in the past six months or so?"

What types of projects could you include on your GitHub?

Here are some of the most popular concerns about the types of projects to include on your GitHub portfolio.

How recent should my portfolio of work be?

To start off, recruiters feel that it's nice to see the most recent code you've written. That will ultimately be used to pinpoint your skills and technical capabilities.

Include projects you've done in the past six months to best showcase your breadth of skills.

What if I have just one big project complete on my GitHub?

Even though it may be just one project, recruiters would much rather see something complete from beginning to end (hinting at an array of soft skills you have), instead of many incomplete, sloppy projects.

What matters the most is the code quality and the role you've had in the whole project: how much have you written yourself?

"What types of projects can I include with no experience?"

Entry-level professionals (or those with no experience) could use their class projects as inspiration to build something new on their own.

For example, unit testing and continuous integration (CI) into a pipeline can show recruiters how you're able to handle day-to-day work.

The passion projects vs open-source projects' dilemma: which ones impress recruiters more?

Small side projects show you've related interests outside your job or studies. They serve as excellent talking points during the interviews: with a focus on your ability to narrate your skills.

On the other hand, contributions to open-source projects, widely used by companies, are sometimes better assessed than random, passion projects. For example, if you've fixed an open bug in a popular app - you'd definitely stand out.

In some cases, your minor role in a widely used platform may score better than the elaborate work you've done on a niche project that nobody uses.

What projects do other IT professionals tend to include on their GitHub?

What your GitHub portfolio signifies about your proficiency level

Entry-level roles

Your GitHub is probably the most helpful instrument for landing your first job.

Recruiters, previewing your GitHub, would look at your technical capabilities, but also your abilities to

• collaborate and communicate;
• accept feedback; and
• meet requirements.

Intermediate professionals

Your GitHub could be great to define how you deal with:

• complex problem-solving and decision-making;
• new languages and programming;
• adapting to the sounds of times.

When you're trying to land a role amidst your career, it's important to remind recruiters that you have the wanted skill set, but at the same time - that you're adaptable to new schools of thought and ways of work.

Experience professionals

Your GitHub is your footprint on the whole IT community. Within your profile, you've

• curated expert-level knowledge;

• offered unique perspectives on problem-solving;

• supported the work of rising "stars" on the IT front.

7 Elements that really make a difference to your GitHub profile

We’ve now come to the how-to section of our guide, where we’ll first discuss seven of the most important elements you need to think about while creating your GitHub.

We’ve also included a bonus checklist to help you stay even more focused.

Formatting

Before we get into the other six elements, here's one thing you need to do asap - clean up your GitHub work area.

That means you need to sort and rank your projects in the way you'd like to have them reviewed by recruiters.

Pin to the top of your GitHub profile, your:

• favorite projects
• popular code folders
• best repositories (repos).

Structure

Your GitHub portfolio is your elevator pitch to your potential employers. That's why investing time to make sure it's professional is a definite must.

Say goodbye to your "LoneR@nger*" username and hello to "github.io/Dick Murphy".

An organized GitHub profile also includes codes that are

• well-commented
• easily readable
• clean and
• running.

It's a good idea to include ReadMe notes for different sections of your GitHub portfolio, like your:

• Profile - write something that is similar to your resume summary and briefly outlines your projects. Don't forget to include links to both your LinkedIn profile and resume, if possible.
• Most impressive projects - within the note, describe the nature of the projects: why they exist and how they impact other users. Also, think about the type of testing the project has - whether it’s unit or integration.
• Open-source contributions - be honest about your role in the big picture of things. What did you actually do as part of the whole project?

Code Quality

As mentioned in the previous part of this guide, your code quality is what matters the most to recruiters.

They don't care if you have an infinite amount of repos with half-finished coursework and random, off-script projects.

Your one high-quality project (which took the desirable amount of time and is relatively completed) would help you catch hiring managers’ eyes.

But what if you happen to have one high-quality app and many different projects you think would be impressive?

Think about the role and company you're interviewing for.

Recruiters are always looking for candidates with problem-solving and accountability soft skills. At the same time, organizations want to hire candidates with the same professional interests as the rest of the team.

Community

This one is pretty obvious, but to have a complete GitHub profile, you need to get stars.

Ask developers you've worked with before to give you recommendations.

This in fact would show your wider impact on the GitHub community and how you work within a team environment.

Job alignment

The information on your GitHub portfolio, professional resume, and the role you're applying for should all align.

It's a good idea to include relevant projects at the top of your profile - so that recruiters could easily find them.

As for other side projects, that may showcase extra technical and soft skills, you can create a sub-folder, specially curated for the hiring managers.

Storytelling

If recruiters are to dive deep into your GitHub portfolio, what story would they find?

Use your profile as a storytelling instrument to win them over.

Whether it's to show how far you've come as a professional to land this particular job.

Or, perhaps, your diverse GitHub portfolio hints that you're a jack of all trades with a broad skill set in different types of projects.

Consider the self-narrative you're trying to sell with your application.

Questions

When curating your GitHub portfolio, put yourself in the recruiters' shoes to take into account the types of questions they may have about your work.

Start simple with:

• What was the project scope?
• Why did you build this project the way you did?
• If you could change something about the code right now, what would it be?
• What would you do to make it even better?

If you can find a way to integrate the answers to all or some of these in your GitHub, you'd surely make interviewers' lives way easier. As a bonus, you'd be highlighting even further your presentation skills.

Where on your resume can you include details about your GitHub profile?

Header

This one is the most obvious choice, but make sure you’ve included a link to your GitHub profile within your resume header.

It’s often that recruiters print our resumes and if the formatting is as a hyperlink - it may be lost.

Instead of including the long link, make it simple, yet professional with this format:

“github.io/FirstName-LastName”

Alternatively, you could also use a link shortener.

Projects

The projects section of your resume allows recruiters a more in-depth dive into how you define your professional success.

That's why you should choose projects that:

• have taught you a new technology or skill;

• are cutting-edge or carry weight within the IT industry;

• you are able to explain thoroughly, during the interview stage.

This would definitely save some time for the hiring managers, who are assessing your resume.

Summary

While including a hyperlink within your resume summary might not be the best idea (as some recruiters tend to assess printed resumes) and pasting the full link may hurt your Applicant Tracker Systems (ATS) Score, there is a subtle way of mentioning your GitHub portfolio.

Select one (or two) of your most prominent projects and include a call to action, for those interested in finding out more.

Experience

For 99% of your work projects, you’ve probably signed some form of an NDA - meaning you can’t just copy-paste the code on your GitHub.

What you should do instead is to use the knowledge you’ve attained to build and test something, entirely on your own.

That particular repo could demonstrate even further your hunger for knowledge within the experience section of your resume.

Education

Entry-level professionals - this resume section may be the best shot you have to demonstrate the sort of side projects you’ve done, all thanks to your higher degree and education.

Again, don’t just copy-paste the work you’ve done for your coursework or projects. Rather, use the knowledge you’ve gained as a base to experiment on your own.

Technical skills

Within your dedicated technical skills section, list all the job-specific technologies you’re apt at.

Don’t forget to add your Git/ GitHub skills to it.

GitHub and cover letters: a strategic decision

Cover letters serve to support your application in why you're the best candidate for the role.

So, if you happen to have some pretty impressive projects on your GitHub, why not mention them in your cover letter with a "find out more" call to action?

It is a strategic decision, but incorporating in some form your GitHub work may make a memorable impression.

What is more…

…if you're either telling a succinct, structured narrative or focusing on your best technical qualities and soft skills (specifically for roles in IT) in your cover letter, this would certainly intrigue recruiters.

Key takeaways

• Including your GitHub link on your resume shouldn't be just to complete some random recruiters' checklist, but rather to show the breadth of your skills and experience.

• You should include recent projects (within the past six months or so) that are the most impressive, complete, and well-structured.

• If you don't have much experience, use university projects as a base to develop your own code: the idea here would be to show your unique problem-solving approach.

• Recruiters care about seeing the end product above all; more technical hiring managers may dive into your source code, so always make sure that this is the highest quality of your work.

• Various resume sections allow opportunities to hint at your GitHub capabilities: use the limited space you have to always highlight why you're the best candidate for the role.