DEV Community: Victoria

Ledger: A Small-Business Finance Tracker with Groq-Hosted Open-Weight AI

Victoria — Mon, 19 Oct 2026 00:27:38 +0000

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

What I Built

Ledger is a small-business finance tracker and AI pricing assistant for solo business owners and freelancers. It helps users record income and expenses, review business totals, and estimate prices for products or services.

The Price Calculator keeps saved estimates separate from actual financial transactions. Users can calculate a price, review it, and save it as a pricing record. Saved prices can be searched, filtered, viewed, edited, deleted, or reused as calculator inputs. Reusing a record prefills the form but does not restore its old result; users must calculate again before saving a new price.

Ledger is aimed at small business owners who want a simpler workflow than a full accounting suite.

Demo

Try the live Ledger demo.

Screenshot

Overview

Transaction

Create a Transaction

Price Calculator

AI recommended Pricing

Saved Prices

Code

Ledger on GitHub

How I Built It

The frontend uses React, TypeScript, Vite, and Tailwind CSS. The backend is an Express and TypeScript API backed by MongoDB Atlas through Mongoose.

Both AI flows use the same Groq client and configured model. The server uses the OpenAI SDK with Groq's OpenAI-compatible endpoint:

new OpenAI({
  apiKey,
  baseURL: "https://api.groq.com/openai/v1",
});

The default model ID is openai/gpt-oss-120b. “OpenAI-compatible” describes the API protocol; inference requests go to Groq. This is hosted inference, not local inference, and the user's submitted text is sent to Groq.

For transaction entry, Ledger asks the model for JSON-formatted drafts, then validates the response on the server and checks whether amounts and dates are supported by evidence in the user's original text. Drafts are not saved automatically; the user reviews and confirms them. For pricing, the model offers qualitative advice around the deterministic calculation. The application validates the recommendation, while financial arithmetic remains ordinary application code.

The standard selling-price formula is:

(unit cost + additional costs per unit) × (1 + markup percentage / 100)

Saved prices have a dedicated Mongoose model and business-scoped API rather than being stored as transactions. One limitation: Ledger does not yet authenticate users or establish business ownership. A business ID scopes a request but does not prove that its caller owns the business, so this prototype should not be exposed as a private multi-user finance service until authorization is added.

Why Does Open Innovation Matter?

Using an open-weight model gives Ledger another option beyond a proprietary model endpoint, and the OpenAI-compatible API meant the server could keep its existing client shape while switching inference providers. That is useful flexibility, but it is not the same as running the model locally or keeping data on the user's device. This version sends text to Groq, and I have not measured inference costs, extraction quality against other models, or customer willingness to pay.

I also keep the boundary between model interpretation and financial decisions explicit: the model can help interpret language and suggest pricing context, but application code calculates prices, validates model output, and leaves consequential saves under user control.

My Agent Session

This earlier session captures the Saved Prices work discussed here; it predates the switch to Groq:

Building Ledger's Saved Prices and Preparing a Hacktoberfest Post

You

Extend Ledger's saved-pricing feature with a dedicated business-scoped Saved Prices page: retrieve and filter real pricing records, show details, reuse stored inputs in the calculator, and support editing and confirmed deletion without touching transactions.

Agent

The existing pricing-record model and business-scoped GET/POST endpoints were reused. The Saved Prices page adds search and type/currency filters, detail views, calculator prefill without restoring an old result, direct record edits, and confirmed deletion. Business-scoped PATCH/DELETE routes validate updates and keep pricing records separate from transactions. Typechecks, production builds, 47 server tests, and a mobile browser check passed. The application still has no authentication or business-ownership layer, so IDs scope records but cannot prove requester ownership.

You

How should Mastra be included in this project? Plan an integration.

Agent

The proposed scope is the transaction-drafting flow only: use a bounded Mastra workflow for structured extraction while preserving Ledger's existing Zod schema, evidence-grounding checks, response contract, and review-before-save behavior. Do not give the model transaction or database tools.

▸ dependency_compatibility_check Check current Mastra package versions against Ledger's documented Node suppor...

Input

Check current Mastra package versions against Ledger's documented Node support floor and inspect dependency audit findings.

Output

Latest @mastra/core 1.78.0 requires Node >=22.13. Latest stable version compatible with Node 20 is 0.24.9; npm audit reports 6 high and 32 moderate vulnerabilities, with fix requiring the major upgrade.

You

Keep Node 20 support and defer Mastra integration.

Agent

Mastra was not retained as a dependency and no repository feature changes were made for this integration. The future option is to revisit the workflow when the runtime floor can move to Node 22.13+ or a safe compatible Mastra release is available.

You

Prepare a DEV post using the Hacktoberfest Week 2 Side Hustle structure and include an agent session.

Agent

The current code uses an OpenAI-backed parser and has no Mastra integration, so the Week 2 open-source AI eligibility should not be claimed. The user requested an honest project post using the challenge structure, not an eligible submission claim.

Prize Categories

Based on the implemented technology and available project evidence, these are the partner categories I can substantiate:

Best Use of Render — Ledger runs as a single Render web service serving the API and built React app, with a configured health check.
Best Use of MongoDB Atlas — Ledger persists its business data and saved pricing records through Mongoose; the deployment setup uses an Atlas connection string, and the live health check reports a connected database.
Best Use of GitHub Copilot — Copilot was used to implement, debug, and test Ledger; the embedded agent session documents part of that work.

out'n'about - wander into a world of wonder

Victoria — Sun, 11 Oct 2026 13:34:35 +0000

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

What I Built

out'n'about is a web app designed to encourage people to step away from their screens and reconnect with the world around them.

out'n'about uses AI to generate outdoor challenges that encourage users to slow down, explore their surroundings, and notice the little things they might usually overlook.

After completing a challenge, users can write down their observations on paper, take a picture of their handwritten notes, and save the experience in their personal journal. AI also helps interpret their handwritten reflections, making it easier to revisit those little outdoor moments later.

It's for users who are looking to get off their screen but are always left with a "now what" feeling. This gives them something refreshing and entertaining to do

Demo

Here's a link to the demo video: https://youtu.be/fLFJYft4Dng

Below are some screen shots:

Home Page

Challenge Generation

Challenge Description

Submission

Journal History

Journal Entry

Code

Here is a link to the repository: https://github.com/Victoria-vee/TouchGrass

How I Built It

I built out'n'about with React and Vite for the frontend, Node.js and Express for the backend, and MongoDB Atlas to store prompts and their journal entries.

The AI component is powered by Gemma 3 4B, an open-weight model run locally using Ollama. I used the model to generate outdoor challenges and help interpret users' handwritten reflections from uploaded photos. Running inference locally allowed me to experiment with an open-weight model without depending on a paid, proprietary AI API.

Why Does Open Innovation Matter?

For a project like out'n'about, open innovation made experimentation more accessible.

Using an open-weight model meant I could explore AI-powered features without building the entire experience around a closed API. Running Gemma locally with Ollama also gave me more control over how I tested and integrated the model. That made it possible for me to learn and build something around an idea I cared about while working with the resources available to me.

I also like that open innovation gives developers room to explore unconventional ideas. AI doesn't always have to be about doing more things on a screen or making existing digital experiences more engaging. It can also help us create experiences that encourage us to step away.

My Agent Session

A snippet of my codex session during the instantiation of my project

Touch Grass: Local AI Outdoor Quests and Reflection Journal

You

I’m building Touch Grass for Hacktoberfest 2026: a small web app that encourages people to step away from screens and spend time outdoors. Inspect the project and verify the development environment before implementation.

Agent

The project uses a React + Vite client and a separate Node.js + Express server. The AI provider is local Ollama running Gemma 3 4B. The implementation was kept small and separate across client and server.

You

Build a calm home screen, then connect its challenge button to the backend. Preserve the visual design and provide loading, error, and retry states.

Agent

The frontend challenge flow requests one outdoor activity from the Express API and presents loading, retry, and result states.

You

Add the outdoor session journey: require paper and pen, let the user go offline, return when ready, and reflect on handwritten notes. Support a note photo and optional typed summary.

Agent

The frontend journey includes preparation confirmation, an active session, reflection, photo preview and replacement/removal, and completion. Reflection AI feedback is optional; the selected photo and typed text are retained through request errors.

You

Add local Gemma reflection feedback and clarification when handwriting is unclear. Diagnose timeout and runtime errors without hiding failures or removing image support.

Agent

The Express reflection endpoint reuses the Ollama configuration and returns structured feedback and handwriting interpretation. The client supports follow-up clarification using the original photo and notes, with bounded attempts and retry states.

You

Connect MongoDB Atlas for one local user. Persist completed quests and reflections, require a handwritten photo for completion, award exactly 5 XP once, and reject reused photo hashes.

Agent

The backend uses Mongoose completion records with stable completion IDs, unique photo hashes, and idempotent retries. The journal exposes saved entries and photo references. Photos remain in local server storage rather than MongoDB.

You

Review and update the open-source README using verified commands, directories, environment variables, and the actual local photo-storage limitation. Do not invent a license.

Agent

The README documents the React/Vite and Express/Mongoose/Ollama stack, local setup, the six server environment variables and defaults, usage, contribution guidance, local photo storage in server/uploads, and the repository’s current lack of a license file. The environment example uses safe placeholders.

You

Refine the full-screen responsive meadow and make the grass divider an upside-down double wave that fades into the page.

Agent

The existing meadow artwork now fills the hero viewport below the navbar. The inline divider keeps its aspect-ratio behavior, uses two downward wave layers in matching sage colors, and fades to the page cream at the bottom. The Vite production build passed.

Prize Categories

Best use of MongoDB Atlas
Best use of Gemma

Hello Dev.to

Victoria — Wed, 19 Mar 2025 13:59:24 +0000

Hey guys. This is kinda my intro post here.
I've been coding for a while now though I've not been making progress(due to laziness, procrastination, lack of motivation and discipline).I never had the motivation to go forward until my internship program as a frontend developer last year. During that period, I started progressing. I learnt HTML, CSS and JavaScript(a little) and worked on some projects. But after my internship program, I started slacking off again.
I joined dev.to hoping that posting my progress would keep me determined, disciplined and motivated.
So I would be starting from the beginning (for the nth time).

Wish me luck.