This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle
What I Built
A GitHub issue with “$400” in its title looks like an opportunity. It still leaves the questions that determine whether I should spend a weekend on it: Is the work available? What counts as acceptance? Do I have the skills? Who can authorize payment?
I built BountyPilot around that gap between finding a lead and deciding it deserves my time.
It searches real public GitHub issues, retrieves their sources, and puts reward evidence beside the technical task. Local Gemma analysis adds a scope summary, relevant skills, estimated difficulty, suggestions, risks and unanswered questions. I can inspect the quoted sources, save an opportunity, and return to a persistent local pipeline.
The distinction I kept coming back to was a reward claim versus verified funding. An amount, a label or a maintainer-associated comment cannot establish that money is available or that my contribution would qualify. BountyPilot exposes that uncertainty instead of presenting a list of promised earnings.
The intended customer is an independent developer or freelancer who repeatedly evaluates paid coding leads. The practical value would be less time piecing together scattered threads and fewer decisions made from a bounty title alone.
Possible businesses around that workflow include managed setup and support, opt-in notifications, or paid hosting. Those are future possibilities, not implemented services or existing revenue. Hosted operation would need authentication, privacy boundaries and operating-cost work. I have no external-user or willingness-to-pay evidence yet.
These are genuine October 16 application screenshots. The video below was recorded October 17 using another real issue; screenshot amounts and timings belong to their original captures. Every pictured reward remains an unverified source claim.
Demo
Watch the completed 88-second BountyPilot demo. The public player opens without sign-in. Select full screen for the interface text; the video is captioned and silent.
It shows real GitHub discovery, opening oll4com/spaceapp#60, reviewing source/payment evidence, selecting local Gemma 3 4B, generating an analysis, inspecting difficulty and citations, saving, and reloading Pipeline.
The recorded request performed new inference, measured at 14.537 seconds by the application. I removed 8.4 seconds of waiting and added reading holds; the edit discloses the shortened wait. This is recorded footage, not live playback, a cached response or a general latency promise. The browser reload demonstrates saved-data retention; it is not a filmed process restart.
Code
Source and setup: RishavRajSingh44/BountyPilot. The repository is public; the verified code baseline is 85d57a4.
Local browser → Next.js / TypeScript → GitHub REST API
├── local SQLite
└── local Ollama → Gemma 3 4B
Original application code is AGPL-3.0-only. You can inspect, run, modify and redistribute it under that license, including its source-sharing obligations. Ollama is separately MIT licensed; Gemma weights have Google's separate model terms. Fonts, icons, adapted components and source excerpts retain their own rights. Third-party notices explain those boundaries; no model weights are bundled.
After installing compatible Node 24 and Ollama, clone the repository and follow its platform-specific README configuration. The core commands are:
npm ci
ollama pull gemma3:4b
npm run dev
Start the Ollama runtime separately. The app runs on loopback for one trusted local user. Contributors can run deterministic tests without downloading a model, inspect the small server modules, and submit focused changes through CONTRIBUTING.md.
How I Built It
I initially considered a separate Python API. For this workload, another backend would mostly forward HTTP to Ollama while duplicating contracts. One Next.js/TypeScript application kept UI, validation and server-side integration together. SQLite provides local snapshots, analyses and saved statuses without a database service.
GitHub REST supplies the real issues and bounded discussion excerpts. Search does not run a model for every result. A deterministic score combines evidence signals, explicit skill matches, recency, availability and scope signals. Its breakdown is inspectable, applies to the fetched page, and is neither a payment probability nor expected earnings. Gemma cannot change that score or the payment-evidence state.
For analysis, I send bounded excerpts and skills to Gemma 3 4B, the open-weight model. Ollama is the inference runtime that loads and serves it. BountyPilot is the application orchestrating sources, validation, presentation and storage. This integration does not use the Gemini API.
The model must return structured JSON. The application checks the schema, source identifiers, unique citation identifiers, exact quote membership and risk-to-citation references. It records omitted or shortened context. Substantive input requires a valid citation, and malformed output gets at most one validation retry within the overall deadline.
I learned to draw a precise boundary around “grounded”: a quote can exist in a source while poorly supporting a conclusion. These checks establish quotation fidelity, not truth, semantic entailment or payment. Human source review remains part of the workflow.
Failure recovery mattered as much as the prompt. A failed analysis preserves the last successful result. Successful writes are transactional; a source refresh racing an analysis cannot silently attach an old answer to changed evidence. Cached results retain their original generation time. Timeouts and cancellation give the user a recovery path.
GitHub quotas produced another concrete lesson: an exhausted detail quota originally blocked searches even when search budget remained. Separating those cooldowns fixed unnecessary waiting, with a regression test protecting the distinction.
Here is the verified evidence, rather than a claim that every future issue will work:
| Check | Recorded result |
|---|---|
| Deterministic tests | 79 passed; 12 opt-in model cases skipped in ordinary runs |
| Chromium checks | 7 passed; synthetic HTTP boundaries, separate from live inference |
| Clean source installation | Fresh dependencies/browser installation and production build passed on macOS |
| Real-issue Gemma 4B analysis | 11.394 seconds on an M4 Pro Mac with 48 GiB RAM; one observed request |
| Gemma 1B grounding evaluation | All 12 cases failed validation; experimental only |
| Updated live discussion | Two 4B requests failed validation; neither was persisted as a successful analysis |
| Durability/recovery | Process-restart persistence and separate backup restoration passed integrity and content checks |
Published CI passed six Linux/macOS/Windows jobs across Node 24.14.0 and 24.21.0; each current-Node job also passed the seven browser checks. These automated runners do not establish Gemma performance on those operating systems. Release verification records commands, failures and limits.
The separate 12-case 4B prompt-v4 evaluation produced 12 valid outputs; manual assessment judged 11 useful. That small result did not prevent later live failures. I kept rejection as product behavior rather than weakening validation for a cleaner demo.
Codex helped with planning, implementation and checks. Ponytail FULL guided small changes and reviews of connected code. Neither replaced actual model runs, database checks or inspecting the resulting interface.
Why Does Open Innovation Matter?
The strongest reason for this architecture is control over the decision-making process. A developer can inspect the ranking weights, see which excerpts reached the model, challenge an evidence heuristic, and change validation without waiting for a hosted vendor to expose an internal feature.
Local Gemma also makes the core analysis available without a mandatory paid LLM API or commercial AI subscription. With Ollama local, selected skills and excerpts go to a process on the user's machine. Personal snapshots and the pipeline stay in local SQLite by default. That database is plaintext, protected by operating-system permissions, not a promise of isolation from other software running as the same user.
Live GitHub discovery and refresh require internet. Once dependencies, weights and a snapshot are available, inference over retained content can run locally; the saved pipeline does not need GitHub to answer another request. Users can explicitly configure a secured remote Ollama endpoint, but that sends analysis input to its operator and changes the privacy assumptions. It is not an automatic fallback.
The 1B experiment made the value of inspectability concrete. A smaller download returned responses, yet failed all twelve grounding checks. I could preserve that evidence, label the option experimental and keep 4B primary. A successful local installation alone would have hidden the quality problem.
The tradeoffs remain real. My measured machine has 48 GiB RAM; I have not established a lower-memory minimum. Installing Node, Ollama and model weights takes effort and storage. Inference takes noticeable time. Models can echo supplied skills, omit important context or fail validation. Schema-valid results still need judgment. Local operation costs electricity and hardware even when no API invoice arrives.
I kept one small provider interface for future work, while deferring Gemini, OpenAI and other cloud adapters until after submission. That preserves room to extend the project without making a proprietary service a prerequisite. AGPL source access lets contributors reproduce failures, propose better evidence rules and improve the same local tool they run themselves.
Those freedoms apply to BountyPilot's software. Gemma remains an open-weight model under Google's separate terms, not an AGPL-licensed or OSI-approved model. Keeping that distinction visible is part of making an honest open project.
My Agent Session
My First User
Prize Categories
Best Use of Gemma
Gemma 3 4B performs the opportunity analysis at the center of BountyPilot, served locally through Ollama. I am also entering the overall Side Hustle challenge. The aim is a useful decision aid developers can run, inspect and improve while deciding which coding opportunity deserves their time.
Top comments (0)