Build Your Open-Source Portfolio in Under a Minute

hasithasandun

You’ve contributed to open-source projects, merged pull requests, fixed bugs, improved documentation,...

You’ve contributed to open-source projects, merged pull requests, fixed bugs, improved documentation, reviewed code, and collaborated with developers around the world.

But when someone visits your portfolio, how do you present those contributions clearly and meaningfully?

This was a question I started asking myself after becoming more involved in open-source communities.

GitHub provides contribution graphs, pull request histories, and repository activity. However, presenting those contributions professionally on a personal website was not as straightforward as I expected.

That is what led me to build OpenSource Showcase.

The Problem

Developers often invest significant time contributing to open-source projects.

These contributions may include:

Pull requests
Bug fixes
Documentation improvements
Feature implementations
Code reviews
Community support

However, these contributions are usually distributed across multiple repositories and organizations.

When applying for internships, software engineering roles, open-source programs, or maintainer opportunities, it can be difficult to demonstrate the impact of this work quickly.

GitHub contains the information, but visitors often need to move between repositories, pull requests, organization pages, and developer profiles to understand what someone has contributed.

I wanted a simpler way to present that work.

The Idea

The idea started with a simple question:

What if developers could showcase their open-source contributions in the same way they showcase their personal projects?

Developers should not need to manually maintain lists of pull requests or build custom portfolio sections every time they make a new contribution.

Instead, there should be a tool that can retrieve real GitHub contributions, allow developers to select the work they want to highlight, and generate a professional portfolio automatically.

That idea became OpenSource Showcase.

What Is OpenSource Showcase?

OpenSource Showcase is a command-line tool that helps developers curate their merged GitHub pull requests and generate a dedicated open-source portfolio.

The tool creates a .opensource GitHub repository containing:

A portfolio website
A formatted README
Machine-readable contribution data

The main objectives are to:

Make open-source contribution data easier to showcase
Reduce repetitive portfolio maintenance
Help developers document their open-source journey
Generate a dedicated website for their contributions
Make contribution information easier for recruiters and maintainers to understand

How It Works

Getting started requires a single command:

npx opensource-showcase

The CLI then:

Authenticates with GitHub
Retrieves your merged pull requests
Allows you to select repositories and contributions
Generates a dedicated .opensource repository

Inside that repository, OpenSource Showcase creates the following files:

.opensource/
├── index.html
├── README.md
└── contributions.json

`index.html`

This file contains the generated portfolio website.

It presents your selected open-source contributions in a format that can be viewed and shared as a standalone portfolio.

`README.md`

This file contains a formatted summary of your contributions.

It makes the repository itself useful as a GitHub-based open-source profile.

`contributions.json`

This file stores structured, machine-readable contribution data.

It can be used for future integrations, custom portfolio implementations, analytics, or other tools that need access to contribution information.

The generated website is also prepared for GitHub Pages deployment, allowing developers to publish a dedicated website for their open-source work.

Instead of manually copying contribution links into a portfolio, the showcase is generated directly from actual GitHub pull requests.

Keeping the Portfolio Updated

A portfolio becomes less useful when it is outdated.

One of my main requirements was to make the generated showcase maintainable without forcing developers to rerun the entire setup process after every new contribution.

After creating the showcase, you can run:

npx opensource-showcase setup-bot

This installs a GitHub Actions workflow inside the .opensource repository.

Once the workflow is configured, the showcase can be managed through GitHub issue comments.

Add a contribution

/showcase add https://github.com/org/repo/pull/123

Remove a contribution

/showcase remove https://github.com/org/repo/pull/123

Refresh contribution data

/showcase refresh

When you merge a new pull request, you can add it to the portfolio with a comment.

When you no longer want to display a contribution, you can remove it.

When repository metadata or contribution details change, you can refresh the generated data.

This approach does not require:

An additional server
A custom backend
A dedicated GitHub App
Manual portfolio editing

GitHub Actions handles the automation inside the generated repository.

As your open-source journey grows, your showcase can continue evolving with it.

Why a Dedicated `.opensource` Repository?

I wanted the portfolio to be independent from any individual project repository.

A dedicated .opensource repository provides a central location for:

The generated website
Contribution records
Portfolio configuration
Automation workflows
GitHub Pages deployment

It also separates open-source contribution history from personal project repositories.

The repository becomes a portable representation of the developer’s open-source work.

Why Not Just Use a GitHub Profile?

GitHub is excellent for hosting code and tracking development activity.

However, a GitHub profile and an open-source portfolio serve different purposes.

A GitHub profile contains the evidence of your activity.

A portfolio provides context and presentation.

A portfolio should help visitors understand:

Which projects you contributed to
What type of work you completed
Which pull requests were merged
What technologies or ecosystems you worked with
How your open-source experience developed over time

OpenSource Showcase does not replace GitHub.

It creates a clearer presentation layer using contribution information already available on GitHub.

Why I Built It

My interest in open source has grown significantly over the past few years.

By contributing to different projects, I had opportunities to:

Learn from experienced maintainers
Receive valuable code-review feedback
Understand unfamiliar codebases
Improve technical communication
Collaborate with developers from different backgrounds
Participate in real software development workflows

As I updated my portfolio and professional profiles, I realized there was no simple way to present all those contributions in one place.

Most developer portfolio templates focus heavily on personal projects.

They often provide sections for:

Personal applications
Technology stacks
Work experience
Education
Blog posts

However, they provide limited support for presenting open-source involvement.

I could have built a custom portfolio section, but I would then need to update it manually whenever I completed another contribution.

Instead of solving that problem only for myself, I decided to build a reusable tool for other contributors.

Who Is It For?

OpenSource Showcase may be useful for:

Students building their first developer portfolio
Developers applying for internships or jobs
Open-source contributors
Google Summer of Code applicants
Freelancers
Maintainers
Developers building in public
Anyone who wants to document their open-source journey

It may be especially valuable for developers whose strongest experience comes from contributions made across several external repositories.

Installation

You do not need to install the package globally.

Run it directly using npx:

npx opensource-showcase

To configure the automation workflow afterward, run:

npx opensource-showcase setup-bot

You can find the package on npm:

https://www.npmjs.com/package/opensource-showcase

Looking Ahead

This is only the beginning of the project.

Some improvements I am considering include:

Enhanced contribution analytics
Better contribution visualizations
Additional customization options
Modern portfolio themes
Animations
Public contributor profile generation
Contribution categorization
Improved filtering
More export formats
Better support for non-code contributions
Custom contribution descriptions

Community feedback will play an important role in deciding which features should be prioritized.

Feedback I’m Looking For

I would especially appreciate feedback on the following areas:

Does the generated portfolio explain contributions clearly?
Is the CLI workflow easy to understand?
What information should be shown for each pull request?
Should developers be able to add custom descriptions to contributions?
What portfolio customization options would be valuable?
What additional GitHub automation commands would be useful?
How should documentation, design, testing, and community contributions be presented?
What contribution analytics would you find useful?
Did you encounter any installation or authentication issues?

Bug reports, feature suggestions, design feedback, and contributions are welcome.

Final Thoughts

Open source is about more than writing code.

It is also about collaboration, learning, sharing knowledge, reviewing work, improving documentation, supporting communities, and helping projects grow.

Those contributions represent real engineering experience, but they are not always easy to present professionally.

If you are contributing to open source, your work deserves to be visible and understandable.

OpenSource Showcase started as an attempt to solve a problem I personally experienced. I hope it can also help other developers present their contributions and document their open-source journeys.

You can try it here: