출처: Dev.to

30일 만에 GitHub 현상금으로 $500+ 벌기 (실제 데이터)

GitHub는 단순한 코드 호스팅 플랫폼을 넘어선 존재가 되었습니다. 이제는 커리어 도구이자 학습 자원이며, 맞아요—수입원이기도 합니다. 지난 달, 저는 30일 실험을 진행하기로 했습니다: GitHub 현상금을 사이드 프로젝트처럼 다루면 얼마나 벌 수 있을까? 스포일러: $523을 벌었습니다. 하지만 진정한 가치는 생태계에 대해 배운 점, 제 자신의 스킬, 그리고 규모를 확장할 수 있는 시스템을 구축한 데 있었습니다. 여기에는 실제 데이터, 제가 만든 도구들, 그리고 오늘 바로 적용할 수 있는 실천 가능한 전략이 포함됩니다.

약 3개월 전, 저는 인기 오픈소스 프로젝트에서 현상금이 달린 GitHub 이슈를 우연히 발견했습니다. 누군가가 명확히 정의된 버그 수정에 대해 $150을 제안하고 있었습니다. 저는 PR을 제출했고, 머지되었으며, 현상금은 48시간 이내에 지급되었습니다. 그 경험은 저에게 생각하게 만들었습니다: GitHub 현상금을 무작위 행운이 아니라 체계적인 사이드 인컴으로 다루면 어떨까?

30일 실험을 위한 기본 규칙

• 시간 제한: 현상금 작업에 하루 최대 2시간
• 최소 보상: $50 이상인 현상금만 추구
• 스킬 집중: 이미 강점이 있는 분야에 한정 (Python, JavaScript, DevOps)
• 모든 것 기록: 매 시간, 매 제출, 매 결과를 추적

해결책에 들어가기 전에 겪은 어려움

• 혼잡한 시장에서 적절한 기회 찾기 — GitHub에는 수천 개의 이슈가 있지만, 현상금이 붙은 것은 극히 일부
• 시간 투자와 기대 수익의 균형 — 어떤 현상금은 쉬워 보이지만 시간이 많이 들고, 어떤 것은 어려워 보이지만 실제로는 간단함
• 거절 처리 및 피드백에서 학습 — 모든 PR이 받아들여지는 것은 아니며, 모든 유지보수자가 빠르게 응답하는 것도 아님
• 초기 성공 이후 접근 방식 확장 — 수동 검색은 규모를 키우기에 한계가 있음

체계적인 기회 탐색 방법 구축

무작위로 탐색하는 대신, 저는 스킬 매칭을 기준으로 현상금 기회를 필터링하고 순위화하는 Python 도구를 만들었습니다.

import requests
from dataclasses import dataclass
from typing import Optional

@dataclass
class Bounty:
    """Represents a GitHub bounty opportunity."""
    repo: str
    issue_number: int
    title: str
    reward: float
    tags: list[str]
    language: str
    url: str
    difficulty: str  # "easy", "medium", "hard"

class BountyHunter:
    """Automated bounty discovery and ranking system."""

    # Bounty platforms to check
    PLATFORMS = {
        "gitcoin": "https://gitcoin.co/api/v0.1/bounties/",
        "bountysource": "https://api.bountysource.com/issues",
        "github": "https://api.github.com/search/issues",
    }

    def __init__(self, skills: list[str], min_reward: float = 50):
        self.skills = set(s.lower() for s in skills)
        self.min_reward = min_reward
        self.matched: list[Bounty] = []
        self.session = requests.Session()
        self.session.headers.update({
            "Accept": "application/vnd.github.v3+json",
            "User-Agent": "BountyHunter/1.0",
        })

    def search_github_issues(self, query: str = "bounty label:bounty state:open") -> list[dict]:
        """Search GitHub for bounty-labeled issues."""
        params = {
            "q": query,
            "sort": "updated",
            "order": "desc",
            "per_page": 100,
        }
        response = self.session.get(
            "https://api.github.com/search/issues",
            params=params,
        )
        response.raise_for_status()
        return response.json().get("items", [])

    def calculate_match_score(self, bounty_tags: list[str], language: str) -> float:
        """
        Calculate how well a bounty matches our skills.
        Returns a score between 0.0 and 1.0.
        """
        bounty_tags_set = set(t.lower() for t in bounty_tags)

        # Language match (high weight)
        lang_match = 1.0 if language.lower() in self.skills else 0.0

        # Tag overlap score
        tag_overlap = bounty_tags_set & self.skills
        tag_score = len(tag_overlap) / max(len(self.skills), 1)

        # Weighted combination: language matters most
        return 0.6 * lang_match + 0.4 * tag_score

    def rank_bounties(self, bounties: list[Bounty]) -> list[Bounty]:
        """Rank bounties by match score and reward value."""
        for bounty in bounties:
            bounty.match_score = self.calculate_match_score(
                bounty.tags, bounty.language
            )
            # Combined score: skill match * log(reward)
            # Using log to normalize reward differences
            import math
            bounty.priority = bounty.match_score * math.log1p(bounty.reward)

        return sorted(bounties, key=lambda b: b.priority, reverse=True)

    def daily_digest(self) -> str:
        """Generate a daily digest of top bounty opportunities."""
        issues = self.search_github_issues()
        ranked = self.rank_bounties(self.matched)

        digest = f"=== Daily Bounty Digest ({len(ranked)} opportunities) ===\n\n"
        for i, bounty in enumerate(ranked[:10], 1):
            digest += (
                f"{i}. [{bounty.reward}] {bounty.title}\n"
                f"   Repo: {bounty.repo} | Score: {bounty.match_score:.2f}\n"
                f"   URL: {bounty.url}\n\n"
            )
        return digest

이 도구는 저에게 엄청난 시간 절약을 안겨 주었습니다. 수백 개의 이슈를 일일이 살펴볼 필요 없이, 매일 아침 이 스크립트를 실행하면 가장 관련성 높은 상위 10개의 현상금 리스트를 받아볼 수 있었습니다.

시간 효율성을 판단하기 위한 간단한 추적 시스템

from datetime import datetime, timedelta
from dataclasses import dataclass, field
from typing import Dict, List
import json

@dataclass
class DailyRecord:
    """Track daily bounty work statistics."""
    date: str
    hours_spent: float
    bounties_attempted: int
    bounties_completed: int
    earnings: float
    notes: str = ""

    @property
    def hourly_rate(self) -> float:
        return self.earnings / max(self.hours_spent, 0.01)

    @property
    def success_rate(self) -> float:
        return self.bounties_completed / max(self.bounties_attempted, 1)

class BountyTracker:
    """Track bounty earnings and time investment over time."""

    def __init__(self, data_file: str = "bounty_data.json"):
        self.records: List[DailyRecord] = []
        self.data_file = data_file
        self._load_data()

    def _load_data(self):
        """Load existing data from file."""
        try:
            with open(self.data_file, "r") as f:
                data = json.load(f)
                self.records = [
                    DailyRecord(**r) for r in data.get("records", [])
                ]
        except (FileNotFoundError, json.JSONDecodeError):
            self.records = []

    def record_day(self, record: DailyRecord):
        """Add a daily record."""
        self.records.append(record)
        self._save_data()

    def _save_data(self):
        """Persist data to file."""
        data = {
            "records": [
                {
                    "date": r.date,
                    "hours_spent": r.hours_spent,
                    "bounties_attempted": r.bounties_attempted,
                    "bounties_completed": r.bounties_completed,
                    "earnings": r.earnings,
                    "notes": r.notes,
                }
                for r in self.records
            ]
        }
        with open(self.data_file, "w") as f:
            json.dump(data, f, indent=2)

    def summary(self) -> dict:
        """Generate overall statistics."""
        total_earnings = sum(r.earnings for r in self.records)
        total_hours = sum(r.hours_spent for r in self.records)
        total_attempted = sum(r.bounties_attempted for r in self.records)
        total_completed = sum(r.bounties_completed for r in self.records)

        # Weekly breakdown
        weekly = {}