DEV Community: Stuti Singhania

AccessPath Go: Making Outdoor Walks More Accessible with Local Gemma

Stuti Singhania — Mon, 12 Oct 2026 06:41:43 +0000

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

What I Built

AccessPath Go — Go farther. Look at your phone less. ♿🌿

What if planning an outdoor walk meant thinking about more than just distance?

For people with mobility challenges, the shortest walking route is not always the most suitable one. Stairs, steep slopes, uneven surfaces, and unexpected obstacles can make an ordinary walk difficult.

I built AccessPath Go, an AI-powered accessibility companion that helps people make more informed decisions about outdoor walking routes.

The idea behind it is simple: technology should help people explore the outdoors with more confidence, not keep them staring at their phones.

Key Features

Accessibility preferences: Specify preferences such as avoiding stairs, steep slopes, and unpaved paths.
Walking directions: Generate walking routes with distance and estimated travel time using OpenRouteService.
Interactive map: Explore route information through a Leaflet-based map.
AI-powered barrier analysis: Upload a photo and use a locally running Gemma model to identify possible walking barriers.
Human-in-the-loop reporting: Review AI-generated findings before choosing whether to share a community report.
Community reports: Help other users become aware of reported barriers.
Touch Grass mode: Keep the experience focused on the outdoor journey.

The goal is not to claim that every route is accessible, but to help users consider potential barriers before setting out.

Demo

Here is a walkthrough of AccessPath Go, including its route-planning interface, accessibility preferences, AI photo analysis, and community reporting workflow.

Watch the full demo on YouTube

Code

GitHub repository: Stuti-Singhania/accesspath-go

The repository includes the application code, setup instructions, architecture details, and development guidance.

How I Built It

I wanted to combine full-stack development with AI that addresses a practical, real-world problem.

The project uses:

Frontend: Next.js, React, TypeScript, Tailwind CSS, and Leaflet.
Backend: Python, FastAPI, and Pydantic.
AI: Gemma 3 running locally through Ollama.
Routing: OpenRouteService.
Persistence: SQLite.

The frontend handles accessibility preferences, route selection, map interactions, photo uploads, and report review. The FastAPI backend coordinates application requests, route generation, image analysis, and data persistence.

One of the most interesting parts was integrating local Gemma inference into the barrier-reporting workflow. The model analyzes an uploaded image and returns a potential barrier classification, severity, and description for the user to review.

For example, a photo might show stairs, a steep hillside path, or an ambiguous stone wall. The application presents the result for human review instead of automatically publishing every model prediction.

This distinction matters: an image model can describe what it sees, but it cannot always determine whether an object actually blocks a walking route.

Why Does Open Innovation Matter?

Accessibility is not a problem that one developer or one company can solve for everyone.

Open innovation makes it possible for developers, accessibility advocates, and community members to share ideas, identify weaknesses, and contribute improvements. Projects like AccessPath Go can become more useful when people with different mobility needs help shape their design.

Open-source technologies also made it possible for me to experiment with a complete AI-powered workflow. By using Gemma locally through Ollama, I could build the photo-analysis feature without depending on a hosted model API for that inference.

Local inference offers more control over the image-analysis step, but the entire application is not fully offline: routing requests and map resources may still require external services.

I also believe accessibility software should be developed with feedback from the people who may use it. This project is a prototype and a starting point for that process, not a substitute for lived experience or verified accessibility information.

My Agent Session

I used coding assistance during development to inspect the codebase, refine implementation details, and review changes. I also ran tests and checked the application behavior rather than assuming that generated code or AI predictions were automatically correct.

My approach is to use AI tools to speed up development while keeping testing, review, and human judgment part of the process.

Prize Categories

Best Use of Gemma

AccessPath Go uses Gemma 3 locally through Ollama to analyze photos of potential walking barriers. The model supports an accessibility-focused workflow in which users can review and confirm findings before sharing reports.

FriendPrep AI — Your Private AI Interview Coach

Stuti Singhania — Mon, 05 Oct 2026 06:58:10 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built FriendPrep AI, a private AI-powered interview coach for a friend preparing for technical interviews and campus placements.

The problem was simple: interview preparation often means searching through hundreds of generic questions, while the questions that matter most are usually connected to your own resume and the specific role you're applying for.

I wanted to build something that feels less like a generic chatbot and more like a friend who knows your background and helps you prepare for the interview you're actually going to face.

FriendPrep AI lets a candidate:

Upload their resume as a PDF.
Paste the job description for the target role.
Generate personalized technical interview questions.
Start a mock interview using those questions.
Submit answers and receive AI-powered feedback.

The evaluation focuses on:

Technical correctness
Completeness
Clarity
Relevance
Missing concepts
How the answer could be improved

The core workflow is:

Resume + Job Description
          ↓
    Local Qwen3 AI
          ↓
Personalized Questions
          ↓
     Mock Interview
          ↓
    Candidate Answer
          ↓
    Local Qwen3 AI
          ↓
   Evaluation + Feedback

The goal wasn't to build another chatbot.

I wanted to build something my friend could actually practice with.

Demo

FriendPrep AI currently runs locally because its AI inference is intentionally performed through Ollama.

Demo Link:

The complete workflow is:

Resume → Job Description → Personalized Questions → Mock Interview → AI Feedback

The project can be run locally with the open-weight Qwen3 model through Ollama.

The application demonstrates the complete interview-preparation workflow, from providing candidate context to generating questions and evaluating interview answers.

Code

GitHub Repository:

https://github.com/Stuti-Singhania/friendprep-ai

The project is a full-stack application:

friendprep-ai/
│
├── frontend/
│   ├── src/
│   │   └── app/
│   │       ├── page.tsx
│   │       ├── layout.tsx
│   │       └── globals.css
│   ├── package.json
│   └── tsconfig.json
│
└── backend/
    └── app/
        ├── routes/
        │   ├── interview.py
        │   └── evaluation.py
        ├── services/
        │   └── llm.py
        └── main.py

The frontend provides the interview experience, while the FastAPI backend handles resume processing, question generation, and answer evaluation.

How I Built It

The AI at the core of FriendPrep AI is Qwen3, an open-weight language model running locally through Ollama.

I deliberately chose local inference because the application works with personal career information such as resumes, projects, skills, and interview answers.

Tech Stack

Frontend

Next.js
React
TypeScript
Tailwind CSS

Backend

Python
FastAPI
Pydantic
pypdf

Qwen3
Ollama
Local inference

Resume Processing

The user uploads a resume in PDF format.

The FastAPI backend validates the file and uses pypdf to extract readable text from the resume.

That extracted information becomes part of the context provided to the local AI model.

Personalized Question Generation

The resume text and target job description are provided to Qwen3 with instructions to generate technical interview questions relevant to both the candidate and the role.

This makes the questions more personalized than a generic list of interview questions.

Mock Interview

The generated questions are presented as an interactive mock interview.

The candidate answers each question one at a time rather than simply reading a generated list.

Answer Evaluation

After the candidate submits an answer, the backend sends the question, answer, and relevant job context to Qwen3.

The model produces feedback covering:

Technical correctness
Completeness
Clarity
Relevance
Missing concepts
A stronger example answer

The application therefore uses open-weight AI for both major AI tasks:

Question Generation + Answer Evaluation

So open-weight AI isn't just an add-on to the application.

It powers the main product experience.

Why Does Open Innovation Matter?

Open innovation mattered because of the kind of information this application handles.

A resume can contain someone's:

Education
Skills
Projects
Work experience
Career goals
Job applications

Interview answers can contain even more personal information.

Using Qwen3 with Ollama allowed me to run the core AI functionality locally instead of requiring a proprietary hosted AI API.

That creates a different privacy model: the user's interview-preparation data can remain on their own machine.

It also gives the developer more control over the AI layer.

With an open-weight model, I can experiment with models, prompts, inference settings, and deployment approaches without redesigning the entire application around a closed provider.

For FriendPrep AI, open innovation wasn't simply a technology choice.

It directly supported the privacy and control goals of the product.

There is also an important practical benefit: the project can be built and experimented with without requiring a paid AI API key just to access the core interview functionality.

That makes the project easier to reproduce and modify for developers who want to experiment with local AI.

👋 Hello DEV Community! I'm Excited to Start My Developer Journey

Stuti Singhania — Tue, 29 Sep 2026 07:44:18 +0000

Hi everyone! 👋

I’m a Computer Science Engineering student passionate about Software Development, AI/ML, and Generative AI.

I’ve been building projects with Python, Java, SQL, FastAPI, React, and AI/ML technologies, and I’m currently exploring RAG, AI agents, and full-stack development.

I’m joining DEV Community to:

🚀 Share what I learn
💻 Build and showcase projects
🌱 Contribute to open source
🤝 Connect with other developers
📚 Learn from the community

I’m excited to document my journey, share both my successes and mistakes, and hopefully learn from all of you along the way.

Looking forward to connecting with the DEV community! 💙

beginners #programming #ai #machinelearning #webdev #opensource