EventFile: Gemma 4 on a 4 GB laptop turns event photos into NAAC reports

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle EventFile turns what's left over after a college club event into the report the accreditation file needs. You give it the poster, photos of the attendance sheets, the photos from someone's phone and a few lines about how it went, in Tamil, English or both. About two minutes later you get a Word file with the event details, the participant count, an objective, summary and outcome, every photo stamped with the venue and the date, time and GPS location it recorded, a signature block, and the poster and attendance sheets attached as annexures.

Some context if you're not from India. Colleges here are assessed by NAAC, and every seminar, workshop and guest lecture a club runs is expected to have an "event file" behind it: permission letter, poster, signed attendance, geotagged photos and a written report. After each event, someone puts that file together by copying the last report in Word, retyping the poster, counting signatures and captioning photos one at a time. When the evidence is thin, assessors send it back. One query I found asked a college for "any other geotagged photographs with proper captions" (source).

The people who would pay are faculty coordinators, club secretaries and the departments that have to submit these files. What I'd sell is EventFile installed on one department laptop, paid per semester, with no per-report cost because the model runs on that laptop.

Most of the evidence already exists by the time the event ends. Phone photos carry their date, time and location in EXIF data, the poster has the title, date, venue and speaker printed on it, and the attendance sheet has the headcount. EventFile reads those and lays them out the way the IQAC office expects.

There's no hosted demo, because EventFile is meant to run on the laptop that already holds the files. The repo's README has the five commands to run it yourself. Below is a full run on a sample event. The college, the students and the handwriting are all made up by a script in the repo, so anyone can try the app without real student data.

First, drop in the files. The notes box takes Tamil, English or a mix of the two, which is how most of us actually write.

Gemma 4 then reads everything on the laptop. On my RTX 3050 with 4 GB of VRAM, the whole sample event takes between 95 and 145 seconds. he slow end is the first run, while the model loads.

Everything it read lands in fields you can edit. The evidence check at the top lists what an assessor would query, such as unsigned rows or a photo with no GPS.

Dates and coordinates in the photo table come straight from the files, so they're locked. The objective, summary and outcome are drafts written from the notes, and you can rewrite them before export.

It's about 1,200 lines of Python plus 20 tests. The tests run without the model because a fake stands in for Ollama. There's also a script that generates the sample event and another that takes all the screenshots in this post.

Turn a college club event's poster, attendance sheet photos and phone photos into the event report an IQAC / NAAC accreditation file needs: event details, participant count objective / summary / outcome, geotagged photos with captions, signature block, and annexures.

Everything runs on your laptop. The poster and attendance sheets are read by Gemma 4 (open weights, Apache 2.0) through Ollama. Students' names, register numbers and photos never leave the machine.

After every club event, someone has to build the "event file": copy last time's Word report, retype the poster, count signatures, re-shoot or watermark photos with a GPS camera app, and caption each one. Assessors send back queries when photos aren't geotagged or captioned properly.

The evidence is already on someone's phone: date, time and GPS sit in each photo's EXIF data, and the title, date and speaker are printed on the poster. EventFile reads…

The stack is small. Gemma 4 E4B (gemma4:e4b-it-qat, 7.5B parameters, 4-bit QAT, 6.1 GB) is served by Ollama. The UI is Gradio, Pillow handles the photos and python-docx writes the report. It all runs on a laptop with an RTX 3050 (4 GB of VRAM) and 28 GB of RAM. My C drive was 92% full, so Ollama, the model and the project live on an external SSD.

One rule shaped the design: Gemma reads text and writes prose, and code produces every number.

Testing on the sample event taught me three things.

Asking for JSON straight from an image cost accuracy. My first version had Gemma return the poster as JSON in one step, using Ollama's structured output. Every field was right except the speaker, who came back as "Dr. Meekshi" instead of "Dr. R. Meenakshi", the same way three runs in a row. When I asked it to just transcribe the poster, it read the name correctly. So the app now makes two calls: one transcribes the image, and a text-only call pulls the fields out of the transcript using the JSON schema. All eight fields come out right, for about ten extra seconds.

Attendance works better as a markdown table. I ask for one table per sheet (S.No, Name, Reg. No, Signature) and parse it in Python. On two sheets with 22 rows in handwriting-style fonts, it got every row and every register number, and 21 of the 22 names exactly. It wrote "Nandini" for "Nandhini". The table version was also faster than the JSON one: 28 seconds per sheet instead of 45. These sheets were generated with handwriting fonts and a fake phone-photo tilt and blur, so real ballpoint on folded paper will be harder. That's my next test.

Signatures are its weak spot. Across runs it got 2 or 3 of the 22 wrong, and it tends to mark the last row on a sheet as unsigned. The app says so in the evidence check, the Signed column is a checkbox you tick against the paper, and the sheet photos go into the report as an annexure, so the real signatures are in the file either way.

The objective, summary and outcome come from one more call. The prompt passes only the poster fields, the count and the coordinator's notes, and tells Gemma not to add names, numbers or outcomes that aren't there. The sample notes end with "Next time longer session venum nu sonnanga" (they said they want a longer session next time). Gemma wrote that up as "attendees expressing a desire for longer future sessions", which is what the note says, in the formal English an IQAC report uses.

Photos are the plain part, and I kept them that way. Pillow reads the EXIF date and GPS and adds a strip under each photo with the venue, date, time and coordinates. The caption combines Gemma's short description of the photo with those same values.

Here's where the time goes on the 4 GB GPU:

An attendance sheet is a list of students' names and register numbers. To use a hosted model, I'd have to upload one for every event. India's Digital Personal Data Protection Rules were notified in November 2025, and colleges are going to be asked where their students' data goes. With EventFile, it stays on the laptop that already has the files. I turned off Gradio's usage analytics, then watched the network connections of the app and Ollama during a full run. Over five minutes, covering startup and the whole run, neither one opened a single connection outside 127.0.0.1.

There's no per-report bill, which is what lets me price it per semester instead of per use. Gemma 4 is released under Apache 2.0, so selling a tool built on it doesn't mean reading through a custom model license first. If a department's laptop is weaker than mine, one environment variable (EVENTFILE_MODEL) switches to the 4.3 GB E2B model after an ollama pull, though I haven't measured how well that one reads handwriting yet.

Running the model myself also made the bugs easy to see. The "Dr. Meekshi" misread came back identically every time I ran it at temperature 0, so I could compare two pipelines on the same image and keep the one that worked.

I didn't benchmark a closed API. Up a sheet of students' names just to run that test was the step I wanted to avoid in the first place.

Best Use of Gemma: Gemma 4 E4B, run locally through Ollama, does all of EventFile's reading and writing.