Skip to main content

Guide · resume

How to List Side Projects on a CS Resume (With Examples)

Treat each side project like a one-line product launch: name, one-line description, stack, link, and one bullet of measurable impact or scope. Two strong projects beat five hobby repos every time.

By , Founder, InterviewChamp.AI · Last updated

TL;DR: List two to four side projects, never every repo. Give each one a single-line header (name, one-sentence description, stack, working link) and one bullet that shows either real usage or real technical depth. Put the closest match to the job first, check every link while logged out, and be ready to walk through each project out loud.

How do you list side projects on a CS resume?#

Treat each side project like a small product launch. It gets a name, a one-sentence description, the stack, a link that works, and one bullet naming either measurable impact or notable technical scope. Two to four of them is the right count.

A side project here is anything you built outside coursework or a job. On a new-grad resume the Projects section often carries more weight than the job history, so it should hold the work most likely to get you a phone screen, not the work you happened to finish most recently.

Why does this section matter so much? Employers screening Class of 2026 applicants told NACE they look for proof of teamwork, problem-solving and communication, with technical skills and analytical skills close behind (NACE Job Outlook 2026 Spring Update, April 2026). A project entry is one of the few places a new grad can show that.

The fix is almost never more repos. It's making the two or three projects you already have readable as results.

There's a second payoff, too. The one-liner you write here is the same project you'll walk an interviewer through out loud, so a clean Projects section helps twice on the way to the offer that ends the search. Say it out loud once before the call. A free practice round on the project you just listed will show you where the story stalls.

The one-line project header#

The one-line project header is the name, a one-sentence description, the stack and the link, all on a single line. Think of it as the launch tweet for the project. Here's the shape:

Project Name · One-sentence description · Stack · Live link · GitHub link

Some headers that work:

  • PipeNote · Markdown notes app with end-to-end encryption and offline sync · TypeScript, Rust, SQLite · Live link · GitHub link
  • Raft-in-Go · From-scratch implementation of the Raft consensus algorithm with deterministic-simulation tests · Go, fuzzing harness · GitHub link
  • Latency Dashboard · Real-time API performance dashboard used by 200+ developers · Python, React, FastAPI, ClickHouse · Live link

And a few habits to drop:

  • A cute project name with no description. "Wormhole" sounds fun, but what is it?
  • Using the technologies as the whole description, as in "React, Node.js, MongoDB project".
  • A heading with no link at all. Recruiters lose trust in projects they can't check, and they lose it fast.

The supporting bullet: impact or technical scope#

The supporting bullet is the one line under the header that turns a project from a name into a signal. It carries a usage metric or a depth indicator, and you pick whichever one your project can honestly back up.

Pattern A, impact-led. Use it when the project has users or measurable usage:

Used by 800+ developers per month; cut median onboarding time from 30 minutes to 4 by automating the OAuth handshake.

Pattern B, technical-depth-led. Use it when nobody is using the thing yet:

Built fuzzing harness that found two edge-case bugs over 2 million simulated network partitions; published a 12-page writeup of the design decisions.

Either pattern works. Hiding both is the mistake.

A line like "Built X using Y, Z, and Q" with no result and no scope is just filler. A project with a usage metric or a depth indicator (algorithmic complexity, dataset size, test coverage) says far more than one listed only by its name and stack.

How to pick which projects to list#

Most CS candidates list too many. Pick two to four, and give each one a different job to do on the page.

Project 1, the closest match to the target role. Applying to a backend infrastructure role? The queue system you built goes first. For a front-end role, the offline-first PWA leads instead.

Project 2, the most technically deep. This is the one you could talk about for thirty minutes without running out of detail, the kind of project a system design conversation can grow out of. Often it's the same as project 1. When it isn't, list it second.

Project 3 (optional), the one with real users. Even a small user count (50-200 users) sends a strong signal that you can ship something people use, not just something that compiles.

Project 4 (optional), the one that shows breadth. Pick something in a different stack or domain than the others, so the page shows range.

Cut everything else. A recruiter skimming the page gives each entry a few seconds, and a fifth small repo takes those seconds away from the project you most want discussed. Depth beats volume in the screen.

Group projects and hackathons: claim your part#

Plenty of good projects were built with other people. That's fine to list, but the reader needs to know what you did, not what the team did.

Name your piece in the header or the bullet. "Built the sync engine and conflict resolution" is honest and specific. "Worked on a team app" tells the recruiter nothing, and it sets you up for an awkward moment when an interviewer asks which part was yours.

A simple test: if you couldn't explain the design choices in your part for a few minutes without your teammates in the room, the bullet is claiming too much. Shrink it to what you owned.

Where the Projects section goes on the page#

Placement depends on how much work history you have.

For new grads and candidates with under two years of work experience, Projects sits above Experience or right alongside it. For candidates with two-plus years of substantial work experience, Projects moves below and gets trimmed to two entries, which leaves room for the work history.

Two layouts work cleanly:

  1. Single section, two to four entries. "Projects" as its own heading, two to four projects, each with a header and one bullet.
  2. Split between Projects and Open-Source Contributions. If you have merged pull requests in libraries people know, list those apart from your own projects. That signals real participation in the ecosystem.

What to leave out#

Three project types tend to hurt more than they help on a CS resume:

  • The portfolio template. Cloning a portfolio template and putting your name on it isn't a project.
  • The Twitter clone or TodoMVC. Every CS candidate has built one. Unless you took it somewhere unusual (real-time presence, novel storage, deployed at scale), leave it off.
  • The unfinished SaaS. A landing page with a "join the waitlist" button isn't a project until something is built behind it.

When in doubt, list one fewer project and let the ones you keep carry more detail each. I'd rather read two projects I believe than six I have to squint at.

Which side projects help vs hurt

The line between a project that earns a screen and one that quietly costs you credibility usually comes down to evidence. A working link and a number you can defend sit on one side. A name with nothing behind it sits on the other.

| Project type | Helps your resume when... | Hurts your resume when... | |---|---|---| | Deployed app with users | It has a live link and a usage number (50-200+ users is plenty for a new grad) | It's "in progress," the link is dead, or the repo is private | | Systems / algorithms build | It shows depth, like a from-scratch Raft or a fuzzing harness with a real result | It's a half-finished homework extension with no writeup | | Open-source contribution | It's a merged PR to a known library, named with the project and the change | It's a one-line typo fix dressed up as "open-source experience" | | Tutorial clone (TodoMVC, Twitter) | You took it somewhere unusual, like real-time presence, novel storage, or scale | It's the stock tutorial output every applicant submits | | Portfolio / landing page | It's the vehicle showing other real projects | It's a cloned template with your name on it, listed as the project |

If your strongest evidence lives in your commit history rather than a deployed URL, how to build a CS GitHub portfolio for recruiters covers how to make the repo itself the proof.

How to list side projects on a CS resume, step by step#

Want a checklist to run against your resume tonight? Here's the method in order.

  1. Shortlist two to four projects. Pick for real users, technical depth, or closeness to the target role. A focused list shows judgment, while a dump of every repo suggests you can't tell your best work from your filler.
  2. Write a one-line header for each. Name, one-sentence description, stack and working link, on a single line. Recruiters search their applicant tracking system for skills, and in Greenhouse's Talent Filtering a keyword "must exactly match the keyword in the application" (Greenhouse support). So spell each technology the way the job posting does.
  3. Add one impact-or-depth bullet. Use Pattern A or Pattern B from the supporting-bullet section above, whichever your project can back up.
  4. Order by relevance to the role. Lead with the closest match to the job, then the deepest project, then the one with real users, then the one that shows breadth. Your first entry should answer whatever the recruiter is screening for.
  5. Check every link from a logged-out browser. A dead link or an accidentally private repo costs trust faster than a missing project does. If the live site is down, deploy a static demo before you submit. Then pin the same projects on your GitHub profile, which holds up to six pinned repositories and gists (GitHub Docs), so a recruiter who clicks through sees them first.

For the bullet wording itself, how to quantify CS project bullets breaks down the verb-result-number pattern. For the keyword side of getting past the filter, CS new-grad resume tactics for ATS goes deeper on building an ATS-friendly resume.

Key terms#

Side project: software you built outside coursework or a job, such as a deployed app, a systems build or an open-source contribution. School work only counts here if you kept building past the deadline.

One-line project header: the single line that names the project, describes it in a sentence, lists the stack and links the work. It's the resume version of a product launch: name, description, stack, Live link, GitHub link.

Supporting bullet: the one line under the header that carries the evidence. That's either a usage metric (users, requests, adoption) or a technical-depth indicator (algorithm complexity, test coverage, dataset size). Hiding both turns the entry into filler.

Impact-led vs depth-led framing: two ways to write the supporting bullet. Impact-led leads with usage and works best when the project has real users. Depth-led leads with technical scope and works best when it has none yet.

Applicant tracking system (ATS): the software, such as Workday or Greenhouse, that stores applications and lets recruiters search them by keyword. The stack line on each project is what makes you show up in that search, and the link and the number are what convince the human afterward.

Getting ready to talk about it#

As of 2026, a tight Projects section and a candidate who can walk through those projects out loud are two halves of the same offer. You can practice the project walkthrough before the real screen, or see the plans for unlimited reps through the 2026 hiring season.

The goal isn't a longer resume. It's walking in able to say the answer in your own voice, and landing the offer that finally ends the search.


About the author: Sam K. is the founder of InterviewChamp.AI and writes about the modern tech interview from the inside: what changed, what works for new grads, and where the old playbook fails.

Originally published on InterviewChamp.AI

Frequently asked questions

How many side projects should a CS resume include?
Two to four. Pick the ones with the most real users, the most technical depth, or the closest match to the target role; never list everything you've ever pushed to GitHub. A focused list signals judgment; a long list signals dilution.
Do school projects count as side projects?
Only if you went beyond the assignment: kept building after the course ended, deployed it publicly, or extended it past the rubric. A class project that ended at the deadline belongs in the Coursework or Education section, not in Projects.
Should I link to GitHub or a live demo?
Both when possible. Live demo first (one click, no clone-and-run friction), GitHub second. A live demo that proves the project works converts more recruiter scans than a private repo or a dead link.
What if my side project never reached real users?
List the technical scope instead of usage. 'Built a from-scratch implementation of Raft consensus in Go, including a fuzzing harness that found two edge-case bugs over 2 million simulated runs.' Technical depth beats vanity user counts.
How recent does a side project need to be to belong on the resume?
Within roughly the last 18-24 months for most new-grad and early-career resumes. Older projects need to be exceptional (real users, real revenue, or a paper-worthy result) to earn their spot.
What's a good side project bullet point example for a CS resume?
Lead with a result-led format: project name, one-line description, stack, link, then one bullet. Example: 'Latency Dashboard · Real-time API performance monitor used by 200+ developers · React, FastAPI, ClickHouse · Live. Cut median dashboard load from 4s to 600ms by precomputing rollups.' Name a number or a depth indicator, never just the stack.
Do side projects help your resume get past an applicant tracking system (ATS)?
Indirectly. Recruiters search their applicant tracking system for skills, and Greenhouse's Talent Filtering only returns a resume when the keyword exactly matches the text in the application. Naming the real technologies in each project's stack line, spelled the way the job posting spells them, makes you findable. The bigger win comes after a human opens the resume: a working link and one quantified bullet turn a project from a name into a signal worth a phone screen.