DEV Community: Sudeepta Sarmah

FinZ: a first-paycheck desk that runs Gemma on the laptop

Sudeepta Sarmah — Sun, 18 Oct 2026 18:43:42 +0000

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

What I Built

FinZ is a money desk for a first real paycheck. You write the note the way you would text a friend.

$14 matcha after a bad standup, felt like a treat.

Gemma, running on your computer through Ollama, turns that into an amount, a direction, a short label, and a feeling. You can change any of those before it is saved. The note hits the desk only when you say so.

The desk is one pay period. Cash in, cash out, what's left. In the sample below, take-home is $2,800 every other week. The matcha landed at $16, the paycheck got dropped in, and $2,784 was left. The feeling mix is one survival note and one treat. Leftover cash fills dreams smallest first, so an $800 fridge is full and "Japan with my sister" sits at $1,984 of $4,000. Her reason for the trip is on the card: she turns 30, and the point is to be in the room.

Open the dream and FinZ will do two more jobs. A money mood is a short read of the notes already on the desk, held up against that dream. A starter split is three buckets for money she might set aside later: an emergency buffer, cash, and a broad index fund. The page says "not financial advice" before the button and again on the sketch. There are no tickers, and nobody places a trade.

The person who would pay for this is in their first year of getting paid, and wants that note read on their own machine. The job is small on purpose. Read a messy line, show the period, move leftover cash toward a named dream, and sketch a boring split when they ask. After ollama pull gemma3:4b, those model calls cost nothing, so the thing for sale is the desk. A metered API on every note would eat a product this small before anyone paid for it.

Demo

The screenshots are FinZ and Gemma on the same laptop. That is the path where the Mastra agent, the weights, and the ledger share a machine.

The public desk is finz-omega.vercel.app. The page is hosted. Gemma runs on the visitor's computer. The guide at finz-omega.vercel.app/guide is the setup: install Ollama, pull gemma3:4b, then start Ollama so the browser is allowed to reach localhost (OLLAMA_ORIGINS). A note can then be read on that machine, and the ledger for the demo stays in the browser.

The money mood and the starter split are the Mastra agent. They run when you start FinZ yourself, next to Ollama:

ollama pull gemma3:4b
npm install
npm run dev

Open http://localhost:47291. The repo README has the same steps, including the smaller gemma3:1b switch if the laptop is tight on memory.

Cash in $2,800, cash out $16. Surplus fills the smaller dream first.

Gemma's read was titled "Sister's Trip Still Calling." It names the $2,800 paycheck, then the trip, and it signs off "FinZ, on this laptop."

Emergency plus cash is 75%. The index is 25%. A dream happening this year has to come out that way.

Code

sudeepsarmah / FinZ

A local-first personal finance website for Gen Z people who just entered the workforce.

FinZ

Live site: https://finz-omega.vercel.app

A local-first money desk for the first real paycheck. Dreams and feelings up front, a spreadsheet nowhere. Gemma reads a messy note on your laptop. Mastra is the agent harness. Income, expenses, and dreams stay in a SQLite file on the machine.

Run on your laptop

You need Node.js 22 or newer (FinZ uses the built-in node:sqlite) and Ollama.

Pull the model FinZ runs here:

ollama pull gemma3:4b

If Ollama did not start a background service (common when systemd is not running), start it in another terminal:

ollama serve

Then:

npm install
npm run dev

Open http://localhost:47291. The dev server binds 0.0.0.0:47291. The first page explains the desk. Start Gemma is a plain-language setup guide at /guide. Onboarding includes a currency (USD, INR, EUR, or GBP).

gemma3:1b was the first try. It parsed a matcha note, then invented a purchase when…

View on GitHub

github.com/sudeepsarmah/FinZ

The agent is one Mastra Agent in lib/agent.ts. The model is whatever OLLAMA_MODEL says. The default is gemma3:4b.

export const finzAgent = new Agent({
  id: "finz",
  name: "FinZ",
  instructions: `You are FinZ, the money friend on someone's laptop. They just got a first real paycheck.
Be warm, specific, and a little irreverent. Short sentences. No shame. No corporate tone. No hashtags. No bullet lectures.
Never invent amounts, entries, or dreams that are not in the prompt.
You are not a financial advisor. Allocation sketches only use three buckets: an emergency buffer, cash, and a broad index fund. Never name a ticker, fund company, coin, or individual stock.
When asked for JSON, reply with one JSON object and no markdown.`,
  model: ollama.chat(MODEL_ID, { think: false }),
});

Instructions are not a guarantee. A small model will still invent a purchase, so a finished reflection has to mention the dream, mention a real entry label, and only use dollar amounts that were actually logged. The sketch has its own rule for a dream happening this year:

const safe = allocation.emergencyPercent + allocation.cashPercent;
if (
  dreams.some((dream) => dream.timeline === "this year") &&
  allocation.indexPercent >= safe
) {
  return "A this-year dream needs emergency plus cash to be greater than the index percent.";
}

Fail the check and FinZ asks Gemma once more, with the reason in the prompt. Fail again and the request errors. The bad sketch is not saved.

How I Built It

The open-weight model is Google's Gemma 3, tag gemma3:4b, served by Ollama at 127.0.0.1:11434. The agent harness is Mastra (@mastra/core), connected with ollama-ai-provider-v2. I did not fine-tune anything. The model is stock. The behavior comes from the prompt, a loose JSON schema, and the checks above.

Three calls:

Parse a note into amount, direction, label, emotion, and one sentence. Feelings are a fixed set: survival, treat, glow-up, ick, soft-launch, chaos. Temperature stays low. Rent and a paycheck come out as survival. "Felt like a treat" comes out as treat.
Write a money mood. Two sentences. The first names a real entry. The second names the dream. If the desk is empty, the first sentence has to say so, and it is not allowed to invent a purchase.
Sketch the three buckets as integers that sum to 100. If risk is set to steady, the index cannot be the biggest bucket. If risk is set high, the emergency buffer still stays at least 15%.

I tried gemma3:1b first. It parsed the matcha note correctly, then invented a purchase when I asked for a mood. gemma3:4b stayed on the entries that were actually there. That is the bar. The smaller tag is still a switch, OLLAMA_MODEL=gemma3:1b, for a laptop that cannot hold the 4B weights. The harness stays put.

Around the model, the app is Next.js 16, TypeScript, and Tailwind. Amounts are integer cents. Onboarding asks for a name, a currency (USD, INR, EUR, or GBP), take-home, how often it lands, how much movement you can stand, and one to three dreams. The note box will finish the word under the cursor from a local list, so spe can become spent. That completion is the word list.

Run it yourself and Node 22's built-in node:sqlite stores the profile, the dreams, and the notes in data/finz.db. The hosted demo cannot keep that file, so its copy of the ledger lives in the browser, and a note that the server cannot read falls back to a direct call from the page to local Ollama. The Mastra path, the one with the repair step, is the app and Ollama on the same computer. A 4B model on a laptop is allowed to be slow: each call can take up to 150 seconds a step.

Why Does Open Innovation Matter?

This desk is pointless if the note leaves the laptop. The dream in the screenshot is a sister turning 30, and the wish is to be in the room rather than the group chat. That sentence, next to a paycheck, is a bad thing to drop into a request log someone else owns. A closed API can publish a retention policy. Ollama on localhost is a stronger promise: the weights are already on the machine, and the call is to 127.0.0.1.

A side hustle this small also dies if every note has a meter on it. Reading a line, writing two sentences, and sketching three numbers will not support a token bill. One ollama pull and the marginal cost of a mood is electricity. I can charge for the desk, or wait until someone asks to pay, and a vendor's price change does not decide whether the project still runs.

I needed to be able to throw the model out. gemma3:1b lied about a purchase. I pointed the same Mastra agent at gemma3:4b and kept the checks. A closed default model would have left me waiting on someone else's changelog, or paying up a SKU, to fix a failure I could already see. The check that rejects an invented dollar amount is there because an open model will wander, and I get to decide what counts as a finished answer.

Nothing in that loop needs an account, a key, or a network I trust. Pull the weights once. On a plane, on cafe wifi, or on a laptop that has never held an API key, FinZ still reads the note.

Prize Categories

Best Use of Gemma. Parsing, the money mood, and the starter split are calls to gemma3:4b through Ollama. The 4B tag replaced 1B because the smaller one invented a purchase.
Best Use of Mastra. One Mastra agent, id: "finz", is the harness over that local model. It asks for JSON, and it gets one repair step when a reflection or a split fails the check.

TrailDex: Turn a Walk into a Pocket Nature Deck

Sudeepta Sarmah — Mon, 12 Oct 2026 05:48:37 +0000

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

What I Built

TrailDex is an Android field guide game for people who want a small reason to notice more on a walk. Pick two points on the map to preview an open walking route, start a GPS walk, and collect a bird, plant, fungus, insect, or other observation as a retro pocket-monster card. Each card has simple battle stats and a short field haiku. You can save and share cards, keep a local field journal, and use the collection in an offline practice battle.

The intended rhythm is short: plan the walk, put the phone away, stop briefly when something catches your eye, then look through the cards and battle after the walk. TrailDex does not identify species in the background; photo suggestions happen only when the user asks the configured model.

Screenshots

These screenshots are from the Android demo build. The map and route screen requires internet for map tiles and route planning; GPS logs and cards remain on the device.

Demo

Download the TrailDex Android APK and follow the phone installation guide. The APK is a debug demo distributed directly from GitHub; it is not a Play Store release and does not update automatically.

Code

The complete Android project, build steps, and tester guide are in the TrailDex GitHub repository.

How I Built It

TrailDex is written in Kotlin with Jetpack Compose. The interactive map is rendered with the open-source Leaflet library in an Android WebView, using OpenStreetMap tiles. Walking route geometry comes from the public FOSSGIS Open Source Routing Machine foot profile and is drawn in TrailDex; no Google Maps or Mapbox API key or billing account is involved. The public map and routing services are community resources with fair-use limits and no uptime guarantee.

The AI card flow uses Gemma 3 4B through Ollama. Ollama runs on a computer the user controls, and the phone connects to it when the host is reachable. With a photo, the model can suggest a visible organism and write a haiku; a text observation can be used to generate a haiku. If the model is unavailable, saving still works with varied bundled verse templates. Those fallback verses are not model output. TrailDex does not bundle the model or run Ollama on the phone.

Cards, field notes, and saved GPS tracks are stored locally. There is no account system or multiplayer service. Map tiles and route requests need internet; route requests send the selected endpoints to FOSSGIS. See the README for the map service limits, Ollama setup, and privacy scope.

Why Does Open Innovation Matter?

The model is replaceable, and the prompt and client code are visible. A user can run Gemma on a computer they control instead of sending an observation photo to a hosted model API. That gives the user more control over where their photo and field note go, and avoids a per-request hosted AI bill for this flow. It does require the user to install Ollama and download a model, so this is not a one-tap offline AI app.

Open map rendering and OpenStreetMap data also let TrailDex show a real map and pedestrian route without a proprietary map SDK or API key. Using a public tile or routing service is not unlimited free hosting: the community endpoints have usage policies, can be unavailable, and should be replaced by a suitable provider or self-hosted infrastructure if the demo grows.

My Agent Session

No shareable agent-session link is attached yet. This section is optional for the challenge.

Prize Categories

Best Use of Gemma — TrailDex uses Gemma 3 4B through Ollama for opt-in photo suggestions and haiku generation.

# Nudge: I built my friend a productivity app that treats procrastination like a roguelike

Sudeepta Sarmah — Mon, 05 Oct 2026 06:42:29 +0000

Hacktoberfest Weekend Challenge: Build for a Friend Submission

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

What I (tried to) Built

My friend is an MBA student. Her problem isn't that she doesn't know
what she needs to do.

It's that the list of things she needs to do can become overwhelming
enough that starting any one of them feels difficult.

There are classes, assignments, presentations, deadlines, and a phone
full of apps designed to make ten minutes disappear.

So I started building Nudge.

Nudge is a productivity companion designed around one simple idea:

Don't solve the whole task. Just make the next step easier to
start.

The MVP combines:

a Focus Shield for distracting apps,
simple task creation,
an AI task-slicing workflow,
voice-note capture,
XP for completed work,
and earned screen-time unlocks.

The app is intentionally small. I wanted to build something that could
actually be used by one person rather than another giant productivity
dashboard.

Demo

Live demo: Under progress --- I wasn't able to finish the public
AI demo before the submission deadline.

I got the Android application running on an emulator and built the main
product loop, but I ran out of time while finishing the live Gemma
inference and public deployment.

For now, these are screenshots from the working Android build.

Today

The Today screen is deliberately simple: progress, current tasks, and
Focus Shield status.

The goal is to open Nudge and immediately understand what needs
attention without being overwhelmed by another complicated productivity
interface.

Tiny Steps

Tasks are displayed as small steps rather than one intimidating block of
work.

The task-slicing flow is designed to turn something like:

"Finish my final semester project."

into a handful of actions that are easier to begin.

Focus Shield

Focus Shield is the other half of the loop.

Instead of treating app blocking as punishment, Nudge connects focused
work with earned access to distracting apps.

Code

GitHub: Under progress --- I am uploading the current codebase.

The repository contains the Android application, Node/Express API,
native Android accessibility service, task-slicing logic, voice-note
integration, and the project setup needed to continue development.

How I Built It

The MVP stack is:

React Native + Expo for the Android application
Node.js + Express for the backend
Gemma as the intended open-weight model for task decomposition
ElevenLabs Scribe for voice transcription
Render for the planned backend deployment
Android's native accessibility capabilities for Focus Shield

I also explored Ollama for local Gemma inference during development.
The backend is structured around an OpenAI-compatible model endpoint, so
the model-serving layer can be swapped without rewriting the mobile
application.

The AI Task Slicer

The core AI idea is intentionally simple.

A user gives Nudge a large or overwhelming task:

"I need to finish my final semester project."

The intended flow is:

Large task
    ↓
Gemma
    ↓
3–5 tiny actions
    ↓
Nudge task cards
    ↓
Complete one small step
    ↓
Earn XP / unlocks

I implemented the backend integration path for this workflow, but I
wasn't able to get the live Gemma inference working reliably before the
submission deadline. The current build therefore falls back to a simple
task-splitting response when the model endpoint isn't available.

I am leaving that limitation visible rather than presenting the fallback
as completed AI inference.

Voice Capture

Nudge also includes a voice-note path intended to turn a spoken thought
into a task.

The intended flow is:

Voice note
    ↓
ElevenLabs Scribe
    ↓
Transcript
    ↓
Task slicer
    ↓
Tiny task

This was another part of the MVP I started wiring together, but the
submission-time build was not polished enough for me to call the
complete voice-to-task pipeline finished.

Focus Shield

The Android side includes a native accessibility service for Focus
Shield.

The app can maintain a list of distracting apps such as:

Instagram
YouTube
TikTok

The product loop is:

Focus
  ↓
Complete tasks
  ↓
Earn XP
  ↓
Earn unlock time
  ↓
Use distracting apps intentionally

That is the part of the idea I wanted to make feel different from a
normal app blocker.

Why Does Open Innovation Matter?

A productivity app like this can eventually know quite a lot about its
user:

what they need to do,
what deadlines they have,
how they plan their work,
what they struggle to start,
and potentially their voice notes and personal context.

I don't want the AI layer of that experience to depend completely on a
black-box model that I cannot change.

Using an open-weight model gives Nudge the possibility to:

run inference locally,
change the prompts and task-decomposition logic,
swap models as better open models become available,
experiment with different serving setups,
and keep the AI workflow under the developer's control.

For this MVP, the important part is the architecture: the mobile app
talks to a backend, and the backend can talk to a separately hosted
open-weight model.

The final production architecture I had planned was:

                Nudge Android App
                       │
                       ▼
                 Render API
                  /       \
                 /         \
                ▼           ▼
       Application Data    Gemma
                            │
                            ▼
                     GPU / Local Inference

I didn't reach the final public deployment stage during the challenge
window, but this separation is already reflected in the project
structure.

What I Learned While Building It

The hardest part wasn't designing a productivity app.

It was keeping the scope small enough to finish.

I started with a much larger idea involving planners, calendars,
integrations, memory, and automation. The weekend challenge forced me to
strip that down to the part that actually mattered for my friend:

Make starting a difficult task feel smaller.

I also learned that getting an LLM into a project is only the beginning.

The generated output has to fit the application's data model, UI, and
user experience. A useful task decomposition needs to be:

small,
actionable,
ordered,
realistic,
and short enough that the user doesn't feel like they have another task manager to manage.

The reward loop raised another design question: how do you make app
blocking feel motivating rather than punitive?

That led to the idea of earned unlocks: focused work creates progress,
and progress creates controlled access to distractions.

What I'm Building Next

Because I ran out of time before the final deployment, the next steps
are clear:

Finish reliable Gemma inference.
Replace the fallback task slicer with the live model response.
Finish and test the voice → transcript → task pipeline.
Test Focus Shield against real installed distracting apps.
Deploy the API publicly.
Publish a live web demo of the task slicer.
Test the complete focus → task → XP → unlock loop with my friend.

Handing It Over

The real test isn't whether the demo looks polished.

It's whether my friend actually opens Nudge when she has something
stressful to do.

If Nudge can turn:

"I have an enormous assignment and I don't know where to start"

into:

"Just open the brief."

and then make that first step feel worth doing, it has done what I
wanted.

I didn't get the whole product finished within the challenge window.

But I did get the core Android experience, the product loop, the native
Focus Shield foundation, and the AI integration structure into a working
project.

The rest is now a much smaller engineering problem than the original
idea.

My Agent Session

DevRelay / agent session: [OPTIONAL — ADD IF AVAILABLE]

AI assistance was used during development, but the product decisions
were driven by the real workflow I wanted to solve for my friend:
reducing the friction of starting, making progress visible, and turning
distraction access into an earned choice.

Prize Categories

Best Use of Gemma

Nudge is designed around Gemma as the open-weight model for turning
overwhelming tasks into small, structured actions.

The Gemma integration path is implemented in the backend, but live model
inference was not completed before the submission deadline. I am not
claiming the unfinished inference stage as completed.

Best Use of DigitalOcean

DigitalOcean was part of the planned deployment architecture for hosting
Gemma inference on a GPU.

This deployment was not completed before the deadline.

Best Use of MongoDB Atlas

MongoDB Atlas was considered for persistent task and application data,
but I intentionally removed it from the final MVP to keep the project
within the weekend scope.

Best Use of ElevenLabs

ElevenLabs Scribe was selected for the voice transcription layer. The
voice-to-task flow was started, but the complete production-ready
pipeline was not finished before submission.

Best Use of Render

Render was selected for the Node/Express backend deployment. The backend
is structured for deployment, but the public deployment was not
completed before the deadline.

Team Submissions

This is an individual submission.

Thanks for participating!

Nudge started with one friend and one problem:

Sometimes the hardest part of a huge task is doing the first five
minutes.

I didn't manage to ship every part of the original plan before the clock
ran out.

But I did build enough of the idea to see the product loop working on
Android, and enough of the architecture to continue from here.

That's what Nudge is for:

one small step.