This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.
What I Built
For many first-time open-source contributors, the hard part is choosing where to begin in a repository they have never seen before. A project can have hundreds of open issues, dense setup instructions, and an unfamiliar layout. âGood first issueâ is useful only when a newcomer can tell what the issue involves and where to start reading.
I built OpenMate around that problem. A contributor supplies a public GitHub repository and a short profile of their skills, experience, interests, and available time. OpenMate analyzes that repository and recommends a real open issue from it, with an explanation of fit, a rough scope, relevant files to read, and a starting plan. It does not search arbitrary repositories for people or operate a maintainer marketplace.
OpenMate was already built around the first-time-contributor problem when, during Hacktoberfest, I met Blaze through the MLH Discord. Blaze told me this was his first Hacktoberfest and he was still figuring out how things worked. That made him a relevant person to hand the product to, so I sent him the live app and asked him to test it for five minutes. He replied:
Sure I'll share my reviews after analysing it
His full review had not arrived by the time I prepared this submission. I am submitting without claiming that he tested a flow or gave product feedback.
Separately, I received this genuine feedback from another Hacktoberfest community tester:
Good problem solver but i think you can simplify it a bit more with âusers looking for repo/issue for themâ & âuser posting out issues to look for users to solve themâ
I took two things from that: the underlying problem resonated, and my original explanation of OpenMate was more complicated than it needed to be. I simplified the positioning around the actual flow: a contributor brings a repository, and OpenMate helps them find a grounded issue in it. I did not build the suggested two-sided maintainer marketplace; that would have expanded the scope beyond this weekend project.
Demo
OpenMate is live at openmate-zq7d.onrender.com. Its health endpoint reports the deployed revision. The project is also available at github.com/Ismailco/OpenMate.
Code
OpenMate is open source under the MIT License: github.com/Ismailco/OpenMate.
The deployed application is available at openmate-zq7d.onrender.com. The production service is a Render Node web service, and the latest GitHub Actions CI run for main passed.
How I Built It
The central design decision was to give deterministic software control over identity and boundaries, while using the model to interpret repository context and explain fit. OpenMate is a Next.js 16 and TypeScript application. The user supplies a public GitHub repository; the GitHub API ingestion is bounded, and the resulting RepositoryContext has a 60,000-character ceiling. The context builder prioritizes project documentation, manifests, selected source files, and issue descriptions instead of trying to send an entire repository to the model.
Repository text and issue descriptions are untrusted input. OpenMate frames that content as data, restricts outbound repository fetching to GitHub, and validates model output before displaying it. The analysis recommends only file paths present in the fetched tree.
For recommendations, OpenMate first scores real open issues deterministically and narrows them to a shortlist of at most eight candidates. Backboard orchestrates structured inference with Gemma 3 27B (google/gemma-3-27b-it) for repository analysis and contributor-to-issue matching. After inference, the application restores the canonical issue number, title, and URL from GitHub data. The model can explain a choice, but it does not get to invent the identity of the issue being recommended.
Ask OpenMate uses Backboard thread-scoped retrieval over the bounded repository context. Persistent memory is off, web search is off, and the assistant has no executable tools. Conversation access uses server-signed tokens; provider credentials stay server-side. These controls complement the grounding checks and prompt-injection defenses rather than depending on the model to follow instructions in repository content.
The production service runs on Render. Sentry Agent Tracing instruments the analysis pipeline. The captured production trace for POST /api/repositories/analyze took 48.14 seconds end to end. In that trace, GitHub ingestion took 2.01 seconds, repository context construction 22.86 milliseconds, candidate issue selection 0.27 milliseconds, Gemma repository analysis 35.77 seconds, and Gemma contribution recommendation 10.27 seconds. The two Gemma spans totalled 46.04 seconds, about 96% of the overall duration. RAG indexing during chat initialization took about 8.35 seconds; after indexing, chat responses took approximately 3.3â5.9 seconds.
That trace made the next performance question concrete: optimize the two sequential reasoning calls, rather than spending the first effort on already-small deterministic stages. Backboard did not provide authoritative cost telemetry for these runs, so I have not included estimated cost figures.
The repository includes 255 Vitest tests and 14 Playwright tests, with GitHub Actions CI gating changes. Production hardening includes bounded request inputs, SSRF protections, strict schema validation, canonical issue and file-path checks, response sanitization, security headers, and Sentry scrubbing for secrets and sensitive content.
Why Does Open Innovation Matter?
Gemma is an open-weight model, and OpenMate keeps model/provider integration separate from its deterministic business rules. The application owns repository bounds, issue selection, canonical identities, and output validation. That lets the model be evaluated or changed more independently than in a design where those rules are buried inside one opaque provider-specific workflow.
Open weights do not make this application local or offline. OpenMate runs as a hosted Render service, and the selected repository context is sent to hosted inference and retrieval services so they can analyze it. The open part matters here because it gives the project more choice and a clearer boundary around what the model is allowed to decide; the surrounding software still has to ground and validate its output.
My Agent Session
Create a curated Agent Session for this OpenMate Hacktoberfest build. Tell a coherent engineering story and preserve the real architecture, iteration, production evidence, security decisions, and honest submission story.
Curated retrospective: this excerpt is assembled from the public repository history, project documentation, and verified submission-preparation evidence. It is not a complete raw build transcript.
OpenMate started from a contributor problem: a newcomer can reach a public repository and still have no grounded way to choose an issue or know which files to read first. The product's core flow is deliberately narrow: the user supplies a public GitHub repository, and OpenMate recommends a real open issue from that repository.
The implementation keeps identity and boundaries deterministic while using a model for interpretation. In the Next.js 16 and TypeScript application, GitHub ingestion is bounded; selected metadata, documentation, source files, and issues become a capped RepositoryContext. Backboard orchestrates structured inference with Gemma 3 27B (google/gemma-3-27b-it) for repository analysis and contributor-to-issue matching. Deterministic code selects at most eight real candidate issues and restores canonical issue numbers, titles, and URLs after inference. Model-suggested paths are checked against the actual repository tree.
Ask OpenMate extends the same context through Backboard thread-scoped retrieval. Persistent memory and web search are off, and the assistant has no executable tools. Repository text is treated as untrusted input. SSRF restrictions, bounded payloads, schema checks, path and issue grounding, signed chat access, response scrubbing, and Sentry privacy hooks keep the model inside an application-owned validation perimeter.
The Git history shows the product growing from repository analysis and contributor results into RAG chat, then security hardening and adversarial regression coverage, Playwright and GitHub Actions CI, Render deployment, Sentry Agent Tracing, and final onboarding and messaging simplification. The production health endpoint reports revision 39701cc; the latest CI run for that main commit succeeded.
The captured production Sentry trace for POST /api/repositories/analyze took 48.14 seconds end to end. Its GitHub ingestion span took 2.01 seconds, repository context construction 22.86 milliseconds, candidate issue selection 0.27 milliseconds, Gemma repository analysis 35.77 seconds, and Gemma contribution recommendation 10.27 seconds. The two Gemma spans totalled 46.04 seconds, about 96% of the overall duration. Separately, RAG indexing during chat initialization took about 8.35 seconds; after indexing, chat turns took about 3.3â5.9 seconds. Backboard did not provide authoritative cost telemetry, so no cost estimate is claimed.
The human story is kept separate from the product's origin. OpenMate was built around the first-contributor problem before the author met Blaze, a first-time Hacktoberfest participant, through the MLH Discord. The author handed Blaze the live app and asked for five minutes of testing. Blaze replied, âSure I'll share my reviews after analysing itâ; his full review had not arrived by submission preparation. A separate community tester said, âGood problem solver but i think you can simplify it a bit more with âusers looking for repo/issue for themâ & âuser posting out issues to look for users to solve themââ. The author simplified the positioning and did not expand the weekend build into a two-sided marketplace.
The draft presents four eligible categories: Best Use of Render, Best Use of Gemma, Best Use of Backboard, and Best Use of Sentry Agent Tracing. The article is staged for human review and remains unpublished.
Prize Categories
- Best Use of Render
- Best Use of Gemma
- Best Use of Backboard
- Best Use of Sentry Agent Tracing
Top comments (0)