DEV Community: Yagnik Satani

[Boost]

Yagnik Satani — Tue, 13 Oct 2026 07:19:12 +0000

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission 💸

Yagnik Satani

Oct 13

NailFlow AI: A Local-First Studio Assistant for Nail Artists

#devchallenge #hf26challenge #ai #opensource

4 min read

NailFlow AI: A Local-First Studio Assistant for Nail Artists

Yagnik Satani — Tue, 13 Oct 2026 07:17:03 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

Running a small nail studio means doing two jobs: the creative work clients come for, and the admin that happens between appointments. NailFlow AI is a small assistant I built for independent nail artists and beauty studios to make that second job easier.

What I Built

NailFlow turns a service inquiry into a transparent price estimate and editable client-ready copy. It can prepare a WhatsApp reply, general aftercare notes, a follow-up message, and social content such as captions, stories, hashtags, and calls to action. A local client pipeline lets the artist save a quote and track it as Draft, Follow-up, or Done. The service menu can be edited to reflect the studio's own prices and session durations.

The idea is deliberately focused: independent artists shouldn't have to rewrite the same kinds of messages all day or guess at a price on every inquiry. NailFlow gives them a draft they can review and adapt, not an automation that speaks to a client without permission.

The quote itself is calculated in code from the artist's editable menu, design complexity, and selected add-ons. AI helps with wording; it does not decide the final price. Server-side guardrails normalize detected currency amounts to the computed estimate and neutralize some common false booking-confirmation claims. These safeguards reduce risk but are not perfect, so every message should still be reviewed before sending. NailFlow does not send messages or book appointments automatically.

Demo

Live web demo: https://nail-flow-ai-lemon.vercel.app/

The deployed Vercel version demonstrates the web interface and its template fallback. It is not connected to Ollama running on my computer, so the hosted demo should not be treated as proof of live Gemma inference.

I verified the local AI path on Windows with Ollama 0.35.0 and Gemma 3 1B: the model passed a direct prompt test, and NailFlow then generated a client pack marked LOCAL AI · Generated with local Ollama inference. The hosted Vercel demo remains separate and uses its template fallback; it does not connect to the Ollama service on my PC.

Code

Public repository: https://github.com/yagnik-satani-otelier/NailFlow-AI

How I Built It

NailFlow uses a dependency-free Node.js HTTP server, vanilla JavaScript, CSS, and browser localStorage. The local-AI path is designed to use Gemma 3 1B through Ollama. The browser calls the local Node server, which forwards a structured prompt to the Ollama API on the same machine. The model can be changed with the OLLAMA_MODEL environment variable.

The prompts, validation, output parsing, deterministic pricing, and post-generation quote guardrails are visible in lib/core.js and server.js. The server sends an explicit output schema to Ollama for each generation mode to improve structured responses from a small model. When Ollama or the model is unavailable, the interface clearly labels generated content as template fallback rather than pretending it came from AI.

To run the local AI path, install Ollama, then run these commands in the repository folder:

ollama pull gemma3:1b
npm run check
npm test
npm start

Open http://127.0.0.1:4174. Generate a sample client pack and confirm that the result says LOCAL AI. I verified this path locally; if a future run says TEMPLATE MODE, that request did not use Gemma.

Why Does Open Innovation Matter?

For a solo studio, a per-message AI bill or a dependency on a hosted writing API can make a small admin assistant less practical. Local inference can avoid a NailFlow-hosted inference service or API key, while letting the studio control its own service menu, prompts, and model choice. When run with Ollama on the same machine, enquiry text goes to that local Ollama service rather than to a hosted AI provider.

There is a trade-off: the user must install and run Ollama and download a model, and a small model can produce wording that needs editing. The hosted web demo is useful for seeing the interface, while local setup is necessary to demonstrate the Gemma path. Gemma is an open-weight model; open weights should not automatically be described as OSI-approved open-source software, and model terms should be reviewed separately.

What I Tested

Automated suite: 20 passing unit and HTTP integration tests covering input bounds, deterministic pricing, prompt constraints, quote guardrails, parsing, template fallback, a mocked Ollama bridge, and HTTP error/security cases.
Browser smoke test: with mocked generation responses, I checked in-place quote and content editing, saving a quote to the client pipeline, service-duration editing, and a 390px mobile layout without horizontal overflow.
Real local-AI smoke test: ran ollama run gemma3:1b successfully, then generated a NailFlow client pack locally with the visible LOCAL AI label. This confirms the live inference path works on my machine; a single smoke test does not establish that every output is correct.
Important limitation: automated HTTP integration tests use a mock Ollama server, not the actual Gemma weights. They validate the app's bridge and guardrails but do not prove general output quality.

I haven't run a customer trial yet, so I won't claim that a nail artist has paid for or adopted the tool. A useful next validation is to put it in front of one artist, observe a sample inquiry workflow, and use their feedback to improve it.

WildMinute: Open-Weight AI That Gets You Off the Screen

Yagnik Satani — Mon, 12 Oct 2026 08:25:10 +0000

WildMinute: Open-Weight AI That Gets You Off the Screen 🌿

I built WildMinute, a local-first outdoor adventure planner inspired by a simple idea: technology should sometimes help us plan something meaningful, then get out of the way.

The app helps turn “I should go outside” into a manageable adventure. Choose the time you have, your mood, activity, setting, and optional area. WildMinute creates a small mission, a flexible route outline, and a list of details to look for outdoors. After the walk, you can record observations, notes, and photos, then turn the experience into an Adventure Journal.

Demo: https://wild-minute-ai.vercel.app/

Repository: https://github.com/yagnik-satani-otelier/WildMinuteAI

Community feedback shaped the project

The feedback I received suggested taking the experience beyond activity recommendations:

Ask users about their location area and preferences.
Suggest outdoor activities.
Generate a walking or hiking route outline.
Suggest things to look for outside.
Provide an offline adventure checklist.
Let users record observations, photos, and notes.
Generate a small journal after the walk.

Those suggestions helped define WildMinute's full loop: plan → explore → record → remember.

Why local AI?

WildMinute uses Gemma 3 1B through Ollama for AI-generated missions and journal text. The Node.js server talks to a local Ollama instance; there is no WildMinute-hosted inference endpoint or API key.

The model prompt and response-parsing logic are part of the repository, so developers can inspect the constraints and adapt them. The app doesn't request GPS permission or require an account. Preferences and fieldbook data are stored in the browser on the current device, and photos are not sent to the model.

A local model is not the same thing as a blanket claim that every part of the project or its model is OSI-approved open-source software. Check the relevant model and runtime licenses before redistributing weights.

What it does

Personalised micro-adventures: choose a short duration, activity, mood, and optional area.
Route outline and spotting ideas: get a flexible walk structure and prompts for what to notice.
Offline checklist: keep track of what to bring, even without AI inference.
Fieldbook: save observations, notes, and photos locally.
Adventure Journal: turn the saved walk record into a short recap using local AI, or use a clearly labelled on-device template.
Privacy-oriented defaults: no account, no GPS permission, no analytics, and no hosted inference service in this project.

Safety and limitations

The route output is a suggested route shape, not turn-by-turn navigation or a verified trail recommendation. WildMinute does not claim to check live maps, weather, trail access, wildlife, or accessibility. An optional external Maps search can help the user find a real route, which should be independently verified before going out.

AI-generated advice can be wrong. Treat activity suggestions as inspiration, follow local guidance, and prioritise safety and accessibility.

Built with

Node.js built-in HTTP server
Vanilla JavaScript and CSS
IndexedDB for locally stored fieldbook content
Ollama for local inference
Gemma 3 1B by default
Native Node.js test runner

Run it locally

Requirements: Node.js 18.18+ and Ollama for the AI path.

ollama pull gemma3:1b
npm start

Open http://127.0.0.1:4173. To run the built-in fallback without Ollama, start the app and explore the interface; the AI-specific path requires Ollama and the model to be available.

Run the automated tests:

npm test

The current automated suite passes 5 tests covering preference validation, prompt safety constraints, route and spotting response parsing, and journal prompt/output parsing. These tests don't replace end-to-end tests of actual model inference, offline behavior, photo persistence, or an outdoor field test.

Demo

The project currently runs locally. I have not added a hosted demo URL because the AI path depends on a local Ollama installation. A short screen recording or genuine screenshots of the running app are the most honest demo until a hosted option is deliberately built and verified.

What I learned

This project reminded me that adding AI isn't only about generating text. The surrounding experience matters just as much: make the offline behavior clear, distinguish suggestions from verified facts, preserve a person's notes locally, and build a reason to put the phone away again.

WildMinute is an experiment in making AI a quiet planning tool rather than the destination.