DEV Community: Riyanshika

Planning an event sounds fun until you're juggling budgets, and a dozen scattered notes.

Riyanshika — Mon, 26 Oct 2026 06:47:58 +0000

EventPilot AI 🦥 — Less Planning Chaos, More Celebrating | Hacktoberfest Week 3

What if we could make that process a little less exhausting?

That's the idea behind EventPilot AI — an AI-assisted event-planning companion built to turn scattered ideas into a more organised starting point, so you can spend less time managing details and more time enjoying the occasion.

What I Built

EventPilot AI is designed for students and small-to-medium event organisers who want to plan something memorable without getting overwhelmed by the logistics.

It focuses on three everyday planning problems:

📝 Planning: Organise an event idea, guest count, budget, and preferred atmosphere into a structured starting point.
💸 Budgeting: Calculate a 7% contingency reserve and estimate the budget per guest instead of doing repetitive calculations manually.
✅ Staying organised: Keep planning considerations such as timelines, checklists, vendor details, and next steps together.

The philosophy is simple: less planning chaos, more room for the celebration.

Rather than making organisers start with a blank page, the goal is to help them get moving with a plan they can review, customise, and improve.

Demo: https://eventpilot-8z66.onrender.com/

The current project includes an interactive planner preview that demonstrates the budgeting workflow.

A public deployment or video walkthrough has not been verified for this submission, so I don't want to link an unrelated demo or misrepresent the preview as a live AI-powered application.

Code

💻 GitHub repository: https://github.com/riyanshika7/EVENTPILOT

The project is built with a lightweight web stack, with an emphasis on maintainability, practical calculations, and a clear separation between the interface and backend.

How I Built It

The current project architecture uses:

Python and FastAPI for backend routes and application logic.
HTML, CSS, and JavaScript for the frontend.
SQLite for data storage.
Pytest for automated testing.
Gemma integration as the intended open-weight AI component, with live endpoint connectivity still requiring verification.

One important design choice is to keep calculations deterministic wherever possible. For example, the contingency reserve and estimated cost per guest should be calculated by application code rather than left to an AI model to guess.

AI can help with planning suggestions, but arithmetic should remain arithmetic.

I'm also working on the reliability details that matter beyond a polished interface: configuration, input validation, useful error messages, accessibility, and deployment readiness.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment, learn, and build useful tools without treating AI as a closed black box.

Open-weight models such as Gemma can give developers more flexibility to explore model behaviour, adapt integrations, and choose deployment approaches that fit their constraints. Open-source frameworks also make it easier for other developers to inspect the surrounding application and contribute improvements.

For a student developer, that freedom matters. It creates room to learn by building, understand the moving parts, and improve a project incrementally.

The important distinction is that using an open model is only part of the story: the integration must actually work, and the application around it must be reliable enough to be useful.

That's the direction I'm working toward with EventPilot AI.

The Lazy Payoff 🦥

The idea is to eliminate some of the repetitive work that makes event planning tiring.

For example, given a budget of ₹8,000 and 30 guests, the planner can calculate:

Contingency reserve (7%): ₹560
Remaining planned-cost budget: ₹7,440
Approximate budget per guest: ₹267

That means fewer manual calculations before you even start refining the event.

The bigger payoff would come from helping organisers move from an idea to a practical checklist without having to assemble everything from scratch. I haven't measured real-world time savings yet, so I'd rather test the workflow with an actual organiser than invent a productivity statistic.

Slow and steady — one useful improvement at a time. 🌱

Building EventPilot AI has reminded me that useful software isn't always about adding more features. Sometimes it's about removing friction, making a confusing process clearer, and giving people a little more breathing room.

The vision is simple: your people, your moment, and a plan that gets you there. ♡

Prize Categories

EventPilot AI is intended to make event planning less stressful by helping people organise their plans and budgets.

Categories I'm considering:

Best Use of Gemma ($200) — for the open-weight AI integration, provided the Gemma model is successfully connected and meaningfully powers the project.
Best Use of Render ($200) — if EventPilot AI is deployed on Render and the deployed application demonstrates the project working.
Best Use of Sentry Agent Tracing ($100) — if Sentry Agent Tracing is configured and meaningfully used to trace the AI workflow.

I'm aiming to make open-source AI a meaningful part of EventPilot AI, not just an add-on. I'll include only the categories supported by the final implementation.

The project is also eligible for consideration for the overall winner prize if it meets the challenge requirements.

devchallenge #hf26challenge #Hacktoberfest #OpenSource #AI #FastAPI #Gemma

🌿 TrailMates: Less Scrolling, More Wandering | Open-Weight AI for Touching Grass

Riyanshika — Sat, 10 Oct 2026 21:40:22 +0000

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

🌿 TrailMates — Less Scrolling, More Wandering

What if AI didn't try to keep you on your screen, but helped you step away from it?

What I Built

TrailMates is an open-source outdoor adventure companion that turns spare time into small, screen-free adventures.

Ever wanted to go outside but had absolutely no idea what to do? TrailMates helps you get started.

Choose your available time, energy level, preferred setting, and interests. The app generates a personalized outdoor plan with practical activity steps, items to bring, safety reminders, a phone-free challenge, and a reflection question for afterward.

Maybe you have 30 minutes and low energy. Maybe you want to explore a nearby park, notice birds, photograph tiny details, or simply take a mindful walk.

You don't need a complicated itinerary. Sometimes, you just need a little nudge.

I designed TrailMates to feel like a playful nature journal, with earthy colors, hand-drawn doodles, and a friendly interface that makes going outside feel inviting.

The real goal? Make the app feel useful enough that you can put your phone away and enjoy the adventure. 🌱

Demo

🌿 Live app: https://trailmates-89sz.onrender.com/

🔍 Health check: https://trailmates-89sz.onrender.com/health

📊 AI status: https://trailmates-89sz.onrender.com/api/status

The application is hosted on Render, with a Python FastAPI backend.

The AI experience depends on the configured model and inference provider. If inference is unavailable, the app can fall back to a clearly labeled rule-based demo plan rather than pretending that a model generated it.

Note: The first request may take longer if the hosted service has been idle.

Code

💻 GitHub repository: https://github.com/riyanshika7/TRAILMATES

The project uses a lightweight architecture built around HTML, CSS, JavaScript, and Python FastAPI.

Some key files:

app/services/hf_service.py — model inference and AI response handling.
static/index.html — the landing page and adventure-planning interface.
static/app.js — frontend interactions and API communication.
render.yaml — Render deployment configuration.
tests/test_api.py — backend API tests.

How I Built It

Open-weight model — Hugging Face Inference Providers

The core AI is Qwen/Qwen2.5-7B-Instruct, one of the models recommended on the HF Inference Providers documentation. It is called via the official OpenAI-compatible router endpoint:

POST https://router.huggingface.co/v1/chat/completions
Authorization: Bearer $HF_TOKEN
The system prompt instructs the model to return a strict JSON schema (title, steps, items_to_bring, safety_tips, phone_free_challenge, reflection_question). The _extract_ai_result() method in hf_service.py validates the response — checking that choices[0].message.content is non-empty, ≥80 chars, parses as JSON, and contains title and steps — before setting is_ai_generated: true. A rule-based fallback runs if any of those checks fail and is always clearly labelled.

TabPFN (Prior Labs)

The tabpfn package is in requirements.txt. When it loads on Render, the suitability scorer is labelled "TabPFN (Prior Labs tabular model)". When it does not load (e.g. local CPU-only environment), it falls back to a heuristic scorer labelled "Heuristic rule-based scorer" — the label is set from self.has_official_tabpfn.

ElevenLabs

elevenlabs SDK is wired up in elevenlabs_service.py. When the API key is valid, it returns an audio URL for the plan briefing. When it returns 401 (expired key) or is unconfigured, the frontend falls back to window.speechSynthesis (browser Web Speech API) — users still get audio, just synthesised client-side.

SerpApi

serpapi_service.py calls the Google Maps engine for local park results when a key and location are provided. Results include a "source": "serpapi-live" tag. Static defaults include "source": "static-default" so the frontend can (and does) show which data is real.

Sentry

sentry_service.py wraps every service call in an AgentSpan context manager that records timing, inputs, and outputs in an in-memory list. When SENTRY_DSN is set in environment variables, the same spans are forwarded to Sentry's trace dashboard. The startup log is honest about which mode is active.

Render

The app is deployed as a Python web service on Render using render.yaml:

Build: pip install -r requirements.txt
Start: uvicorn app.main:app --host 0.0.0.0 --port $PORT
Health check: /health returning {"status": "healthy"}
All API keys stored as Render environment variables — never sent to the client browser

This distinction matters: an application should be honest about when its AI is working.

⚙️ The application stack

Frontend: HTML5, CSS3, and vanilla JavaScript.
Backend: Python and FastAPI.
Model inference: Hugging Face Inference Providers.
Hosting: Render Web Services.
Version control: Git and GitHub.

I chose a lightweight architecture that keeps the frontend and backend straightforward to understand and extend.

🚀 Why Render?

Render provides the public hosting environment for TrailMates and runs the FastAPI application that handles requests from the frontend.

The backend is responsible for communicating with the configured inference provider, handling responses, and returning structured plans to the user. API credentials remain in server-side environment variables rather than being embedded in browser code.

The application also provides a health-check endpoint for deployment monitoring.

Using a single hosted application keeps the deployment relatively simple while leaving room to evolve the AI integration.

Why Does Open Innovation Matter?

For TrailMates, open innovation is about keeping the technology adaptable.

I didn't want the future of this project to depend entirely on one proprietary model API.

Open-weight models give developers opportunities to explore different models, compare their outputs, experiment with prompts, and adapt the behavior of an application to its users' needs.

That flexibility matters for an outdoor companion. Someone with 15 minutes and low energy needs a different suggestion from someone looking for an active afternoon outdoors. I want to be able to experiment with how TrailMates plans those experiences without unnecessarily rewriting the entire application.

Open innovation also encouraged me to think about transparency. When model inference is unavailable, the rule-based fallback can still provide a useful demo plan. But it should never be mislabeled as AI-generated.

There are trade-offs. TrailMates currently relies on external inference infrastructure when using Hugging Face Inference Providers. Availability, latency, and cost depend on the configured provider and model. I am not claiming that the hosted application runs fully offline or that inference is free at scale.

A future version could support local inference with a compatible model, giving users and contributors another way to run the planner and potentially reducing reliance on an external inference service. That would also introduce hardware and performance considerations.

To me, open innovation isn't about claiming that open models are automatically better or cheaper in every situation. It's about having the freedom to investigate alternatives, learn from experimentation, and build something that can evolve.

And that's what I like most about this project: the AI isn't meant to keep people interacting with AI. It's meant to help them discover something beyond their screens.

My Agent Session

Built with Antigravity (AGY) — the full multi-session conversation is what produced the code in this repository, including the endpoint correction, honest attribution logic, and this submission. I'm sharing the source code as the primary reference for the implementation.

Prize Categories

Best Use of Render — TrailMates is deployed as a Render-hosted web application with a FastAPI backend and a health-check endpoint.
Best Use of a Hugging Face Open-Weight Model — Qwen/Qwen2.5-7B-Instruct via https://router.huggingface.co/v1/chat/completions. Attribution is only shown after response validation.
*Best Use of TabPFN *— Prior Labs tabpfn package installed; suitability scorer clearly reports "TabPFN (Prior Labs tabular model)" vs "Heuristic rule-based scorer" depending on what loaded.
*Best Use of ElevenLabs *— ElevenLabs SDK integrated for audio trail briefing with graceful browser Web Speech API fallback.
Best Use of Sentry — AgentSpan context manager records timing and metadata for every service call; forwarded to Sentry when DSN is configured.
Best Use of SerpApi — Google Maps engine search for real local parks and green spaces when SERPAPI_API_KEY and location are present; results tagged "source": "serpapi-live"

🌼 One Last Thing

Technology doesn't always have to ask for more of our attention.

Sometimes, it can help us give that attention back to the world around us.

If you try TrailMates, generate a small adventure, put your phone away, and see what you notice outside.

A little fresh air. A little curiosity. A little less scrolling.

Even a tiny adventure counts. 🌿

devchallenge #hf26challenge