This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

In Mumbai, we know our stations. We know which train to catch, where to change, and which platform gets us home. But ask what grows a short walk outside that station, and the answer gets less certain.

That gap became Platform to Park.

It turns a Mumbai railway or metro stop into a small outdoor mission: find a nearby mapped green space, discover what people have observed around it, and leave with one thing to notice. Choose a station. Generate a mission. Pocket the phone.

The idea started with station connections—those awkward gaps between a railway station and a metro stop with a similar name. Then I found a question I liked more: What if the space outside a station was somewhere worth spending a little time?

Platform to Park is for the commuter who has room for a small detour. You don’t need hiking gear, a weekend plan, or a trip out of the city. You can start at a station you already use.

The mission gives that detour a purpose. Look closely at a leaf. Listen for a bird. Notice something you normally pass at commuter speed. There’s also an optional Pocket Mode, which uses ElevenLabs to read the mission aloud. It’s a simple interaction with a specific job: help you stop looking at the app.

My favourite line in the interface is what appears when you take a mission:

Phone down. Eyes up.

That’s the intended outcome.

Demo

The quickest way to explore it:

1. Search for a supported Mumbai railway or metro station.
2. Generate an outdoor mission.
3. Check the mapped green space and the linked observation sources.
4. Take the mission with you.

For the Gemma experience, run the project locally with Ollama. The mission card identifies when Gemma generated the text, so it’s clear which mode you’re seeing.

The hosted app also works when local inference isn’t available, using a mission assembled from the retrieved open data.

Code

How I Built It

I built Platform to Park with Next.js, TypeScript, Gemma 3 through Ollama, OpenStreetMap, and iNaturalist. Each piece has a deliberately small role.

• OpenStreetMap supplies the place: The app uses mapped green spaces near supported stations. It links back to the source so users can inspect the place themselves.
• iNaturalist supplies the observation context: Nearby research-grade observations give the mission something concrete to draw from. They describe what has been recorded around the area—not what the app can promise you’ll see today.
• Gemma supplies the invitation: I use gemma3:1b locally through Ollama to turn those facts into a short headline, an outdoor action, and a noticing prompt.

The model receives the station, green-space name, straight-line distance, and available observation names. Its instructions ask it to stay within those facts and avoid inventing routes, opening hours, access information, or species. That boundary matters. A pleasant sentence is useful. A confidently invented shortcut is not.

The distance display is also labelled as a straight-line map estimate. Mumbai’s streets, entrances, crossings, and access rules deserve more respect than a line between two coordinates.

One lesson from building this was that open data still needs checking. Some station queries worked while others failed. I added discovery and verification scripts to check candidates against the data sources rather than filling the dropdown with names that looked convincing.

On the deployment side, the repository includes a Render Blueprint for the Next.js service, with environment configuration and a health-check endpoint. Gemma runs in the local setup. The public deployment uses the open-data fallback unless a reachable Ollama service is configured. I wanted visitors to be able to try the idea without installing a model first.

Why Does Open Innovation Matter?

For this project, openness affects what I can build and what someone else can change.

The map comes from community mapping. The biodiversity context comes from people recording the living world around them. Gemma lets me work with an open-weight model on my own machine. Together, those pieces let me connect a familiar station to a place and an observation without asking a model to make up the city.

Local inference also means the mission-generation step can run without sending its prompt to a proprietary AI provider. I can inspect the prompt, change the instructions, or swap the model through configuration. That flexibility is useful for a small project. I can experiment with how a mission sounds without making every rewrite a paid API call. Someone extending the app can try another model or adapt the experience for another city.

There are limits worth being clear about: the app fetches map and observation data online, so it isn’t an offline trail guide. Optional ElevenLabs narration sends the finished mission text to that service.

But the central idea remains portable: community data gives the model its grounding, and local open-weight inference turns that grounding into something a person might actually want to do.

The data tells me what’s nearby. Gemma helps me find a reason to notice it.

Prize Categories

Best Use of Gemma

Platform to Park uses Gemma 3 through Ollama to generate concise outdoor missions grounded in retrieved map and biodiversity data. Its role is to turn a place and a set of observations into a small, specific invitation to go outside. The local setup makes that generation inspectable, replaceable, and runnable without a proprietary inference API.

Best Use of Render

Platform to Park includes a Render Blueprint for hosting the Next.js application and its server routes, with environment configuration and a deployment health check.

Deployment: platform-to-park.onrender.com