Three Started, One Stayed: My Hacktoberfest Hack Day Experience

I walked into the Hacktoberfest Hack Day at Rishihood University with two teammates, an idea, and absolutely no idea how the next 12 hours would turn out.

We were a team of three, and we had decided to build something around the Gemma 4 track. I was excited to work on the idea, explore new things, and hopefully build something we could be proud of.

But the night turned out quite differently from what I had imagined.

The idea behind PaperTrail

We decided to build PaperTrail, an AI-powered tool that connects research papers with their actual code implementations.

Here's the problem we wanted to solve.

Imagine reading a machine learning research paper and then opening its GitHub repository to understand how the authors implemented the methods they described. You might find hundreds of files, different functions, and complicated code structures. Finding the exact code related to a particular claim in the paper can take a lot of time.

PaperTrail was our attempt to make this easier.

The user uploads a research paper PDF and provides its GitHub repository link. The application analyses the paper and the repository, then tries to connect claims from the paper with relevant code. It classifies the findings as Supported, Ambiguous, or Missing, along with explanations and references to the source code.

We wanted Gemma 4 to handle the AI analysis, so we ran it locally using Ollama.

And that's where things started getting interesting.

Working with Gemma 4

Since we were participating in the Gemma 4 track, I wanted the model to be an actual part of the project, not just something we mentioned in our presentation.

We connected Gemma 4 through Ollama and built a workflow around it. The application extracts text from the PDF, examines the GitHub repository, retrieves relevant code, and gives that information to Gemma 4 to analyse.

One thing we were careful about was the evidence. We didn't want the model to simply say that something was implemented without showing where it found that information.

So we also worked on validating file paths, line numbers, and code snippets on the backend.

Getting all these parts to communicate with each other was not easy, especially with a limited amount of time. But it was interesting to see a local AI model being used for something more specific than a normal chatbot conversation.

From three people to one

This is probably the part of the hackathon I will remember the most.

We started as three members, but as the hours passed, things started getting difficult. The project was bigger than we had expected, and there were many things we still needed to figure out.

My teammates gradually lost motivation. They felt that they weren't able to contribute much and started thinking that the project might be too difficult for us to complete.

Eventually, I found myself continuing alone.

Honestly, I hadn't planned for this. I had imagined all three of us working together, solving problems, and finishing the project as a team. Instead, I was standing in the hackathon room trying to figure out how to get everything working on my own.

I won't say it was easy. It was frustrating at times, and there were moments when I wasn't sure how much I could actually finish.

But I had already invested so much into the idea that I didn't want to leave it unfinished.

So I kept going.

The night was long!

Once I was working alone, there was a lot to handle.

The frontend was already something we had to bring together with the backend. Then there was PDF extraction, GitHub repository analysis, Gemma integration, and making sure the results actually included useful evidence.

I used Antigravity and DeepSeek as coding assistants during development. They helped me move through unfamiliar parts of the project, but I still had to test things, understand errors, and keep checking whether everything was working as expected.

One issue that took more time than I expected was getting the frontend tests to run in GitHub Actions.

First, the test files weren't being discovered properly. After fixing that, Node had another problem running the TypeScript test files. We eventually sorted it out using tsx.

It sounds like a small thing now, but at that moment, every failed check felt like another problem standing between me and a finished project.

There was barely any sleep. I kept switching between the code, terminal, GitHub, and the things that still needed fixing.

At some point, I stopped keeping track of how tired I was. I just wanted to get the project into a state where I could confidently show what I had built.

A little appreciation for the burgers and stickers

Of course, a hackathon isn't only about code.

The burgers and Coca-Cola deserve a special mention. After spending hours staring at a screen, the refreshments were genuinely appreciated.

And the stickers were so damn good! I don't know why, but small things like these make an event memorable.

Between debugging, working on the project, and trying to finish everything on time, these little breaks were nice.

It wasn't all stress and code. There were also those small moments that made the night fun.

Finally, PaperTrail started coming together

After all the debugging and integration work, PaperTrail started looking like the application we had imagined.

Our stack included React, TypeScript, FastAPI, PyMuPDF, Git-based repository analysis, and Gemma 4 running locally through Ollama.

For testing the idea, I used the BERT research paper and the official Google Research BERT repository.

In one demo run, PaperTrail analysed 30 claims:

• 9 were marked Supported.
• 8 were marked Ambiguous.
• 13 were marked Missing.

These results were not an accuracy score or proof that the original research experiments had been reproduced. They showed how the application could organise claims and connect them with evidence found in a repository.

Seeing the different parts finally work together was satisfying. The project wasn't perfect, and I knew there were things left to improve, but I had something real to demonstrate.

What I learned

This was one of those experiences where I learned a lot more than I expected.

I got to work with a local AI model, understand how Gemma 4 could fit into an actual application, connect a frontend with a backend, work with GitHub repositories, and deal with testing and CI.

I also realised how different building a project is from simply having an idea. You can plan everything beforehand, but once you start building, there will always be things you haven't considered.

And personally, this hackathon taught me that I can push myself further than I sometimes think.

I started the night with a team of three and ended up continuing alone. That wasn't the experience I had planned for, but I gave the project my best instead of giving up when things got difficult.

I am grateful to the organisers for putting together the event and giving us the opportunity to build, experiment, and learn.

And yes, I am also grateful for the burgers, Coca-Cola, and those amazing stickers!

Three of us started with an idea. I ended up carrying it forward alone. It was a sleepless night, but definitely an experience I won't forget.

PaperTrail is something I want to continue improving. For now, I'm happy that I got to take an idea, work through the challenges, and turn it into something I can show.

On to the next build!