Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

Contributor Resources

Level up your open-source journey. Explore our curated guides packed with real-life examples from successful past contributors.

Contributor Lifecycle

The 6-step path every open-source contributor takes from zero to a merged PR.

Roadmap · 6 Steps
STEP 01

Lurk & Explore

Inspecting commit velocity, reviewing recent PR activity, and reading CONTRIBUTING.md to understand the workflow and community expectations.

Commit VelocityCONTRIBUTING.mdIssue Triage
STEP 02

Fork & Setup

Forking repo, setting upstream remote, installing dependencies, and running test suites locally to ensure a stable baseline.

Fork Repogit remote add upstreamLocal Setup
STEP 03

Reproduce & Discuss

Confirming the bug or proposing approach on the issue discussion before writing code. Wait for official assignment before starting.

Reproduce BugDiscuss ApproachWait for Assignment
STEP 04

Branch & Implement

Creating a feature branch from main and writing atomic code with tests, adhering strictly to codebase conventions and standards.

Feature BranchAtomic CommitsType Safety
STEP 05

Open PR & Pass CI

Submitting structured description referencing the issue, providing reproduction proof, and watching CI turns green.

Structured PRFixes #issuePass CI
STEP 06

Review & Merge

Iterating constructively on maintainer review feedback, rebasing or squashing commits, and celebrating the merged milestone.

Address FeedbackRebase / SquashMerged Milestone 🎉
  • Guides
  • All resources
  • PR Lab
  • Glossary

Showing 11 of 11 resources

Resources to level up

How to write proposals

Mentorship Application
Intermediate5 min read

Learn how to formulate and present winning project proposals for GSoC, Outreachy, LFX, and ESoC.

Key Takeaways

  • •Focus heavily on the technical implementation breakdown, not just marketing speak.
  • •Include realistic, week-by-week timelines with clear deliverable milestones.
  • •Show evidence of preliminary research (e.g. referencing specific functions or files).

Real Excerpt from an Accepted GSoC Proposal Timeline

Week 1-2: Set up API routes in `src/app/api/matcher/route.ts`. Implement the MongoDB `$text` search index schema migration. Write initial unit tests using Jest.

Week 3-4: Build the `ResultsGrid.tsx` React component. Hook the frontend state to the new API endpoint. Ensure loading skeletons are implemented for UX.

Week 5 (Midterm): Polish the UI, resolve any TypeScript strict-mode warnings, and deploy to the staging branch for mentor review.

Why this worked: It names specific files, frameworks, and milestones rather than just saying “I will write code.”

Finding Good First Issues

Discovery
Beginner3 min read

Struggling to find where to start? Use our curated paths to discover beginner issues.

Key Takeaways

  • •Use advanced GitHub search filters to narrow down issues.
  • •Look for repositories that actively merge community PRs.
  • •Don't just claim an issue; state exactly how you plan to fix it.

Effective GitHub Search Query

Instead of manually browsing, use this exact query in the GitHub global search bar to find issues that are open, beginner-friendly, and not yet assigned or linked to a PR:

is:issue is:open label:"good first issue" no:assignee -linked:pr language:typescript
Real Interaction Example:

“Hi! I see this issue is open. I'd like to fix the contrast bug by updating the `text-gray-900` class to `text-primary` in `Footer.tsx`. May I open a PR for this?”

What is Open Source & Why Does It Matter?

Foundations
Beginner4 min read

Understand the difference between building solo tutorial clones and collaborating on real production software used by thousands of people.

Key Takeaways

  • •Open source means the code is public, so anyone can read it, use it, and propose improvements.
  • •Real projects have users, tests, CI, and maintainers, so your code must hold up outside your laptop.
  • •Every merged contribution is public proof of your skills that you can link on a resume.

Real Scenario: Tutorial Clone vs. Real Contribution

Solo Tutorial Clone

You follow a video and build a todo app.
• No one reviews your code.
• Nothing breaks, because nobody uses it.
• You never learn why decisions were made.

Real Collaboration

You fix a bug in a repo used by thousands.
• A maintainer questions your approach.
• CI runs tests on every change you push.
• You learn code style, communication, and shipping.

Demystifying Pull Requests

Collaboration
Beginner5 min read

Learn why it is called a pull request and how every PR adds real engineering and business value to a project.

Key Takeaways

  • •You are asking the maintainer to pull your changes into their repository, which is why it is a pull request.
  • •Review catches bugs before users see them, and CI proves the change works.
  • •A PR leaves a permanent record of what changed and why, which helps future developers.

Real Scenario: A Small PR with Real Value

This tiny change stops the app from showing “Invalid Date” to users:

@@ -1,3 +1,5 @@
export function formatDate(input: string) {
- return new Date(input).toLocaleDateString();
+ const date = new Date(input);
+ if (Number.isNaN(date.getTime())) return 'Unknown date';
+ return date.toLocaleDateString();
}
Engineering value: a bug is fixed and a reviewer double-checked it.
Business value: fewer broken pages, fewer support complaints, happier users.

All resources

Git Guide

Version Control
Intermediate4 min read

Master the git workflows, branches, commits, forks, and rebase conventions used in open source.

Key Takeaways

  • •Never commit directly to the `main` branch of your fork.
  • •Write descriptive commit messages explaining the 'why', not just the 'what'.
  • •Learn how to squash commits to keep the project history clean.

Real Scenario: Squashing Commits for a Clean PR

# You made 3 messy commits while debugging:

1. “fix bug”

2. “oops typo”

3. “actually fix it this time”

# A maintainer asks you to squash them. You run:

git rebase -i HEAD~3

# You change the final commit message to:

“fix(auth): resolve null pointer exception in login flow”

GitHub Guide

Developer Platform
Beginner4 min read

Find your way around repositories, issues, discussions, projects, and pull requests.

Key Takeaways

  • •Always fork the repository and clone your fork locally.
  • •Keep your fork synced with the upstream repository.
  • •Use GitHub Draft PRs if you want early feedback on incomplete code.

The Perfect Pull Request Description

Fix Mobile Navigation Overflow (Fixes #204)

What changes did you make?
Replaced the fixed width `w-64` on the sidebar with a responsive `w-full md:w-64` class to prevent horizontal scrolling on mobile devices.

How to test:
1. Run the app locally on a screen smaller than 768px.
2. Open the navigation menu.
3. Verify the screen no longer scrolls horizontally.

Screenshots:
*(Attached Before & After images)*

Resume Tips

Career Support
Beginner3 min read

Optimize your resume to highlight open-source contributions and grab reviewer attention.

Key Takeaways

  • •Quantify your impact (e.g., 'Merged 5 PRs', 'Decreased load time by 10%').
  • •Link directly to your merged PRs or GitHub profile.
  • •List open source under 'Experience', not just 'Hobbies'.

Resume Snippet: Before vs After

Before (Too Vague)

Open Source Contributor
Contributed to React ecosystem projects. Fixed bugs and added features.

After (High Impact)

Open Source Contributor — VLC Media Player
• Merged 4 Pull Requests into the core C++ codebase.
• Refactored the audio buffering module, resolving a critical memory leak (Issue #4012).
• Collaborated with 3 core maintainers over a 2-month period.

Interview Tips

Career Support
Advanced5 min read

Nail behavioral screening and technical walkthrough interviews for premium fellowships.

Key Takeaways

  • •Prepare to walk through code you have previously written.
  • •Admit when you don't know something, but explain how you would find out.
  • •Ask the interviewers thoughtful questions about the community.

Handling the 'Code Walkthrough' Question

Interviewer: “In this PR you submitted, why did you choose to use a Hash Map instead of an Array to store the connected users?”

Excellent Response:

“I initially considered an Array, but realized that checking if a user is online requires an `O(n)` lookup. Since this websocket server handles thousands of concurrent connections, I switched to a Hash Map using the User ID as the key, which reduces the lookup time to `O(1)`. It uses slightly more memory, but the performance trade-off for a real-time system is worth it.”

Why this worked: It demonstrates knowledge of Big O notation and explains the architectural trade-offs behind the code.

Mastering Issues & Bug Reports

Collaboration
Beginner4 min read

Most project momentum starts in the issue tracker, before any code is written. Learn to write issues that get fixed.

Key Takeaways

  • •Search existing issues first so you do not file a duplicate.
  • •Give steps to reproduce, expected result, actual result, and your environment.
  • •A clear issue lets maintainers decide, assign, and plan work without a back-and-forth.

Real Scenario: Bad vs. Good Bug Report

Bad Report

Title: Login broken
Body: It does not work. Please fix.

Good Report

Title: Login returns 500 when email contains "+" Steps: 1. Open /login 2. Enter a+test@mail.com 3. Click Sign in Expected: user is logged in Actual: 500 error Env: Chrome 130, Windows 11

Code Review Etiquette

Collaboration
Intermediate5 min read

Learn how to read maintainer feedback and survive a Request Changes review without taking it personally.

Key Takeaways

  • •Request Changes is a normal step in review, not a rejection of you.
  • •Reply to every comment, even if it is only a short confirmation after the fix.
  • •Ask a clarifying question if feedback is unclear, and push fixes as new commits.

Real Scenario: Responding to Request Changes

Maintainer: “This fetches users inside a loop, which makes one request per user. Could we batch it? Please also add a test.”

Weak reply:

“It works on my machine.”

Strong reply:

“Good catch, thanks! I batched the calls and added a test. Please let me know if the naming works.”

- for (const id of ids) {
- users.push(await getUser(id));
- }
+ const users = await getUsersByIds(ids);

Security Hygiene & Licensing

Best Practices
Intermediate6 min read

Know the difference between permissive and copyleft licenses, and keep secrets like .env credentials out of your commits.

Key Takeaways

  • •MIT is permissive: reuse is easy, and you keep the copyright notice.
  • •GPL is copyleft: distributed derivative work must stay open under the same license.
  • •Never commit .env files. If a secret leaks, rotate it immediately, because deleting the file is not enough.

Real Scenario: Keeping Secrets Out of Git

Ignore real secrets and commit only a safe template:

# .gitignore
+.env
+.env.local
node_modules/
# .env.example (safe to commit)
+DATABASE_URL=
+JWT_SECRET=

If you already committed a secret: rotate the key first, then run git rm --cached .env and push a new commit.

MIT (permissive)Use, modify, and redistribute freely, even in closed-source products.
GPL (copyleft)Distributed modifications must also be released as GPL with source code.
Interactive Lab

PR & Issue Inspector

Explore what makes pull requests get approved, how maintainers triage bug reports, and why quality contributions power open source ecosystems.

Interactive Simulator: Click any highlighted section below to inspect maintainer expectations.
Opensubhranshudash13:main ← contributor:feat/matcher-skill-filter
2. Automatic Issue Linking & Description

Closes #89 · Fixes #142

Replaces quadratic array scans in the skill matching algorithm with a case-insensitive Set lookup. Prevents UI lag when typing multi-word tags.

✓ Unit tests included·✓ TypeScript strict verified
3. Code Diff (src/lib/matcher/filter.ts)
@@ -18,6 +18,14 @@ export function matchSkills(candidate, required) {
- return candidate.skills.filter(s => required.includes(s));
+ if (!candidate?.skills?.length || !required?.length) return [];
+ const requiredSet = new Set(required.map(s => s.toLowerCase()));
+ return candidate.skills.filter(s => requiredSet.has(s.toLowerCase()));
}
4. Threaded Review Comments
Resolved
subhranshudash13 (Maintainer)2 hours ago

Great catch optimizing with Set! Does this handle edge cases where tag casing is inconsistent like “TypeScript” vs “typescript”?

contributor (Author)1 hour ago

Good point! Updated in commit 4b2a9e with case-insensitive normalization and added 2 unit tests to cover it.

All checks have passed
4 successful checks
build-and-test / node-20
1m 24s
lint / eslint src/app/resources
34s
typecheck / tsc --noEmit
28s
security / CodeQL & audit
52s
Conventional Commits

Conventional & Semantic PR Titles

Why Maintainers Care

Maintainers manage dozens of PRs simultaneously. A structured title like feat(scope): message instantly tells the team what layer of the application is affected, what kind of change it is, and feeds automated CHANGELOG and semantic release tooling.

Maintainer Golden Rule

Use the format: <type>(<scope>): <imperative summary> (e.g., feat(matcher): add real-time tag filtering). Keep it lowercase, under 72 characters, and describe what the commit does, not what you did.

Common Pitfall

Vague titles like "fixed bug", "updated files", "WIP", or "changes for issue" force maintainers to dig through diffs to understand the core intent.

Part 1 of 5

Open source glossary

Confused by PR, rebase or LGTM? Search the terms you keep running into.

12 terms found

PR

Pull Request: a proposal to merge your changes into a project.

MR

Merge Request: GitLab's name for a Pull Request.

Fork

Your own copy of someone else's repository on GitHub.

Upstream

The original repository your fork was created from.

Origin

The default name Git gives to the remote you cloned from.

Rebase

Re-apply your commits on top of a newer base branch.

Squash

Combine several commits into one.

LGTM

Looks Good To Me: a reviewer approves your change.

RFC

Request For Comments: a written proposal discussed before building a large change.

Stalebot

A bot that labels and closes inactive issues and PRs.

SemVer

Semantic Versioning: versions written as MAJOR.MINOR.PATCH.

CLA

Contributor License Agreement: a legal agreement you sign before contributing.