DEV Community: Yagnik Satani

EchoLantern: A Private Little Archive for Memories

Yagnik Satani — Tue, 27 Oct 2026 05:03:06 +0000

A memory doesn't always arrive as a grand story. Sometimes it's a rattling ceiling fan, a pet waiting at the door, a phrase someone always used, or a small ritual that made an ordinary day feel like home. I built EchoLantern to give those details a place to stay.

What I Built

EchoLantern is a local-first keepsake maker for everyday memories, people, places, pets, family stories, and meaningful objects or traditions. A user writes a few rough notes, optionally adds one photo, and creates an editable keepsake card, a short reflective paragraph, a card inscription, and a gentle question for another day. Saved keepsakes live in a searchable archive in the current browser and can be exported as Markdown or JSON.

The app intentionally does not pretend to speak for someone who is gone or contact spirits. It doesn't assume that a person has died. It helps the user shape their own words, and the final copy remains editable. The model is instructed not to invent dates, people, events, favorite things, or exact quotes; generated prose still needs human review.

Demo

Live demo: https://echolantern-ai.vercel.app/

The static deployment shows the interface and browser-based template fallback. It cannot access Ollama running on a user's computer, so it is not a live hosted Gemma demo. The local version runs the Node server alongside Ollama and can generate keepsakes with Gemma 3 1B.

Code

Repository: https://github.com/yagnik-satani-otelier/echolantern-ai

How I Built It

EchoLantern uses Node.js's built-in HTTP server, vanilla JavaScript, CSS, browser localStorage, and the Ollama API. When run locally, the server uses Gemma 3 1B with an explicit JSON schema to return a consistent keepsake structure. When Ollama is missing or the static Vercel route has no local API, the app marks its output as TEMPLATE MODE rather than pretending that it came from the model.

The app has no user account or hosted AI endpoint. In local mode, the notes go to the Ollama service configured on the user's machine. A browser-side photo step compresses an optional image before it is saved with the entry in local storage. The archive can be exported, but browser storage is not encrypted and needs backups.

Why Does Open Innovation Matter?

Memories can be personal in a way ordinary app data isn't. A local model lets a person try AI-assisted writing without sending their notes to a separate hosted writing API, while the prompts, response handling, and storage logic remain inspectable and modifiable. People can switch models or change the rules rather than having their keepsakes depend on a closed service that might change or disappear.

The trade-off is that local inference requires installing a model and using your own machine's resources. Smaller models can get details wrong or add unsupported flourishes. EchoLantern keeps the original note visible, labels the output as a draft, and asks the user to check it. Open weights are not automatically the same as OSI-approved open-source software; model terms should be reviewed separately.

My Agent Session

The current automated suite has 19 passing Node.js tests covering input validation, prompt boundaries, output parsing, template fallback, mocked Ollama integration, and HTTP error/security cases. These tests use a mocked model endpoint and do not establish real Gemma output quality. I also manually verified the deployed Vercel demo: it creates a keepsake, saves it to the browser-based archive, and the entry remains available after refresh. Export behavior was checked as well. The hosted static demo uses template fallback, not local Gemma inference.

I also tested the local Gemma 3 1B path, confirmed locally generated entries are labelled LOCAL AI, and checked saving/reopening and export. I have not conducted a user study, so I make no claim about measured time savings or user outcomes.

The Spirit of It

EchoLantern's promise is intentionally small: keep the story, leave the shadows to the imagination, and let a person choose what deserves another light.

Prize Categories

Best Use of Gemma. The local version runs Gemma 3 1B through Ollama to generate keepsakes from a user's notes. The public Vercel demo is a static fallback demo and does not run Gemma inference.

PausePoint: A Local Gemma Resume Capsule for Interrupted Developers

Yagnik Satani — Tue, 20 Oct 2026 10:32:26 +0000

I lose time twice when I switch tasks: once when I stop, then again when I return and try to remember what I was doing.

For Week 3's Slow and Steady theme, I built PausePoint, a local-first interruption-recovery assistant for developers. Instead of asking AI to keep working in the background, PausePoint helps me leave a useful breadcrumb trail so I can step away and return without reconstructing the whole session.

What I Built

PausePoint asks for a few rough notes: the goal, where I stopped, what changed, what's verified, what's still uncertain, and any blocker. It turns those notes into a compact resume capsule containing a short summary, verified facts, unknowns, next steps, and a prompt I can paste into a coding agent when I return.

It can also attach a local Git snapshot. The user selects a repository folder, and the local server captures the root, current branch, short status, diff summary, and recent commits using fixed read-only Git commands. PausePoint never edits files, commits, pushes, or runs generated commands.

Saved capsules stay in the current browser's local storage. They can be reopened from history, exported as Markdown, or backed up as JSON. There is no account or hosted AI endpoint in the local setup.

Demo

Live web demo: https://pausepoint-ai.vercel.app/

The deployed Vercel version demonstrates the interface and its browser-based template fallback. It cannot access Ollama or a local Git repository on my PC, so it is not a live Gemma demo. The local AI path runs when the PausePoint Node server and Ollama are both running on the same machine. I verified local Gemma generation and read-only Git capture on Windows.

Code

Public repository: https://github.com/yagnik-satani-otelier/pausepoint-ai

How I Built It

PausePoint uses a dependency-free Node.js HTTP server, vanilla JavaScript, CSS, browser local storage, and Gemma 3 1B through Ollama. The local server sends an explicit JSON schema to Ollama to help keep output predictable. Git context comes from fixed read-only commands rather than the model guessing about repository state.

During my first real Gemma smoke test, the model over-weighted an unrelated filename and commit subjects from the Git snapshot. I added deterministic post-processing so the user's goal and stopping point take priority and generated commands are not presented as if the user supplied them. I successfully generated a capsule marked LOCAL AI before and after making those changes, but I still need to recheck the newest guardrails with the same scenario. The capsule always needs human review.

If Ollama or the model isn't available, the UI says TEMPLATE MODE; it doesn't pretend fallback content came from AI.

Why Does Open Innovation Matter?

A return-from-interruption tool may contain unfinished work notes, branch names, blockers, and other context I'd rather not send to an unrelated cloud service. With local inference, prompts can stay on the machine running Ollama. The user can inspect the prompts, alter the logic, and choose their local model instead of depending on a hosted API key or per-call bill.

The trade-off is real: the user must install Ollama and a model, and a small model can misread notes or propose a poor next step. That's why PausePoint separates facts from uncertainty, keeps Git access read-only, and reminds users to verify state before acting. Open weights are not automatically the same as OSI-approved open-source software; review the model's license separately.

The Lazy Payoff

I used PausePoint while working on this challenge to capture where I had stopped, what I had verified, and what I still needed to check. Attaching the NailFlow Git snapshot added branch and recent-commit context without making any repository changes. The result gave me a saved place to resume instead of relying on memory or rereading everything from scratch.

I have not measured exact minutes saved or tested it with other developers, so I won't claim a quantified productivity improvement. The intended payoff is a smaller restart cost: leave a useful note in a short pause, then return to one clear next step.

Prize Categories

Best Use of Gemma — PausePoint uses Gemma 3 1B through Ollama as its local resume-capsule generation model.

What I Tested

Automated tests: 17 passing Node.js tests, including input validation, prompt-injection-as-data handling, separation of verified and uncertain facts, bounded JSON parsing, fallback behavior, Git snapshot handling, and HTTP error/security cases.
Local integration: confirmed that Ollama responds, gemma3:1b is installed, PausePoint can capture read-only Git context from my NailFlow repository, and local capsule generation returns the LOCAL AI label.
Limitation: automated HTTP integration tests use a mocked Ollama server. They validate the app's bridge and expected schema but do not establish general model-output quality. The first real-model test exposed drift toward unrelated Git context; deterministic guardrails were added, and the newest guardrails still need a repeat real-model check.
User validation: I have not conducted a user study or customer trial, so I make no claim about measured time savings or willingness to pay.

[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.