DEV Community: Jaswant Kr Nayak

Hirune — Understand Your Workday. Keep the Evidence. Own Your Data.

Jaswant Kr Nayak — Sun, 25 Oct 2026 09:27:00 +0000

What if you could understand your computer activity at the end of the day without manually reconstructing everything you did?

We switch between applications, write code, browse the web, research information and work on different tasks throughout the day. But remembering exactly what happened can be difficult.
That's why I built Hirune, a privacy-first AI-powered desktop activity reporting application.

What I Built
Hirune transforms recorded desktop activity into structured, understandable daily reports.

It records active application names and window titles at regular intervals, organizes them into sessions and uses AI to generate activity summaries.

Core features:

Activity tracking: Records active application names and window titles.
Session organization: Groups recorded activity into meaningful sessions.
Session review: Allows users to review sessions, edit labels and add personal notes.
AI-powered reporting: Generates summaries from recorded activity using Gemma 4.
Evidence-backed AI claims: AI-generated statements include references to supporting activity records.
Human verification: Users can confirm, reject or edit AI-generated claims.
CSV export: Allows users to export their activity records.

Demo
Here's Hirune in action:

The demonstration covers activity tracking, session review, AI-generated reporting, evidence references, claim verification and CSV export.

Code
GitHub repository:
https://github.com/JASWANT-KUMAR-NAYAK/Hirune

The repository includes the application source code, setup instructions, documentation and tests.

How I Built It

Hirune is built using:

Python: Activity tracking, session processing, report generation and backend logic.
SQLite: Local activity storage.
HTML, CSS and JavaScript: Dashboard and user interactions.
Gemma 4 (31B): AI-powered activity summarization.
Ollama Cloud: Access to the AI model through an OpenAI-compatible API.
python-dotenv: Environment-based configuration for AI credentials.

The application follows a straightforward workflow:

Capture active application information.
Store activity records locally.
Organize records into sessions.
Generate reports from recorded evidence.
Use AI to produce interpretations.
Allow users to inspect and verify AI-generated statements.

I also focused on handling AI responses carefully, including parsing structured JSON and validating evidence references.

Why Does Open Innovation Matter?

Open innovation makes it possible to build useful applications using open-weight AI models and accessible developer tools.

For Hirune, Gemma 4 provides the language-model capabilities needed to turn activity records into readable summaries.

Using an open-weight model gives the project flexibility in model selection and deployment options rather than tying its AI layer to a single proprietary model.

Hirune currently uses Ollama Cloud for inference. The application also keeps its activity-tracking and reporting logic separate from the AI provider.

This separation makes future experimentation with different models and inference environments easier.

Privacy by Design

Activity tracking should not require invasive monitoring.
Hirune does not capture:

Screenshots
Keystrokes
Clipboard contents
Audio
URLs Activity records are stored locally. Window titles can contain sensitive information, so they should be treated carefully.

When Ollama Cloud is enabled, relevant application names, sampled window titles and report context are sent to the cloud provider for AI summarization.

The Lazy Payoff

Instead of manually remembering and reconstructing a workday, users can review an organized activity report.

Hirune aims to reduce the effort involved in understanding recorded computer activity while keeping users in control of the final interpretation.

It is not a productivity score or proof of attention. Recorded activity provides context, and AI-generated interpretations remain subject to human review.

*What's Next?
*
There is plenty of room to improve Hirune.

Some ideas for future versions include:

AI Daily Insights.
Visual activity timelines.
Daily and weekly comparisons.
More detailed evidence-backed recommendations.
Additional privacy controls.

For this submission, I focused on getting the core tracking, reporting, evidence review and export workflow working reliably.

Hirune

Understand your workday. Keep the evidence. Own your data.

Thanks for reading!

ShilpiList Desk: Using Gemma to Help Odisha's Craft Sellers Create Multilingual Listings

Jaswant Kr Nayak — Sun, 18 Oct 2026 05:55:30 +0000

What I Built

Small craft sellers and the people who help artisans sell online often need to create product descriptions for multiple marketplaces and languages. Writing these listings takes time, and important product details can be lost or incorrectly described.

I built ShilpiList Desk, an AI-assisted product listing tool designed for Odisha's craft sellers.

Users upload product photos and enter seller-provided facts, including the product name, craft or technique, material, dimensions, maker, location, and GI status. The application generates draft listings in English, Hindi, and Odia.

Features include:

Batch entry for up to 10 products through the web interface.
Separate product-name and craft/technique fields.
Multilingual title and description generation.
Prompt-level accuracy rules and heuristic warnings.
A retry when the model returns malformed JSON.
Listing history, regeneration, ratings, copying, and CSV export.
An explicit native-speaker review warning for Odia drafts.

The people who could benefit include individual craft sellers, artisan groups, and small businesses managing product catalogs for multiple makers.

My business hypothesis is to test a low-cost subscription or pay-per-batch service for people who regularly prepare product listings. I haven't established paying customers yet; validating whether sellers would pay is future work.

Demo

Here's the demo of the working application, from entering product facts and uploading a craft photo to generating multilingual listings and exporting a CSV.

Code

GitHub repository: ShilpiList Desk

The project uses Python, FastAPI, HTML, CSS, JavaScript, SQLite, and a Gemma model through an OpenAI-compatible inference endpoint.

How I Built It

I built ShilpiList Desk around Gemma 4, an open-weight multimodal model, using an OpenAI-compatible chat-completion endpoint.

The application sends product photos and seller-provided facts to the model and requests structured JSON containing titles and descriptions in English, Hindi, and Odia. FastAPI validates the output, and SQLite stores products and generated listings.

One useful improvement was separating the product's identity from its craft technique. For example, Pipili Applique Wall Hanging is the product name, while Pipili applique is the technique. I updated the form, database, prompts, listing display, and CSV export to preserve that distinction.

I also added prompt rules to discourage unsupported claims and a retry when the model returns malformed JSON. Heuristic checks flag some potentially unsupported claims and missing craft terminology, but they cannot guarantee factual accuracy.

Latest recorded validation results:

19 automated tests passed, with one dependency deprecation warning.
6 out of 6 sample evaluation cases generated valid listings.
English glossary hit rate: 100%.
Hindi glossary hit rate: 50%.
Odia glossary hit rate: 50%.
Median generation latency: 3.7 seconds.

The evaluation covers only six sample products. Glossary hit rates measure whether configured terms appear in the generated text; they do not establish translation quality or factual accuracy.

Hindi and Odia glossary entries remain unreviewed drafts. Odia output is explicitly marked for native-speaker review before publication.

Why Does Open Innovation Matter?

Open-weight AI gives developers flexibility to adapt a model to a specific problem instead of treating a hosted AI service as an unchangeable black box.

For ShilpiList Desk, Gemma provides the model behind image-and-facts-to-listing generation. I can adjust the prompt, add craft-specific terminology, require structured output, and experiment with alternative models and inference environments without rebuilding the entire application.

This matters because a tool for regional craft sellers needs to balance cost, latency, image understanding, factual accuracy, and multilingual quality. An open-weight approach creates room to experiment with these trade-offs and potentially explore local inference in the future.

My current tested setup uses a hosted inference endpoint. I have not demonstrated fully offline operation, proved that all submitted images remain on the seller's computer, or conducted a controlled comparison against a closed model. Those are possible future experiments, not claims about the current application.

For me, open innovation matters because it makes this workflow adaptable and inspectable as I learn what craft sellers actually need.

Prize Categories

Best Use of Gemma

Gemma is the model powering the project's multilingual product-listing workflow. I'm entering this category because it directly matches the technology used in the application.

Building a Google Play Store Audit Tool with Python 📱

Jaswant Kr Nayak — Sun, 11 Oct 2026 14:36:08 +0000

```Have you ever wondered what app reviews can tell us about a product?

An app might have thousands of reviews, but going through them one by one to understand what users like, what they dislike, and what needs improvement can take a lot of time.

That's the problem I wanted to explore with my Play Store Audit project.

💡 What does it do?

The project analyzes Google Play Store app data and reviews to help make sense of user feedback.

Some of the features I worked on include:

📊 App rating and review analysis

🔍 Identifying common complaints and positive feedback

📈 Visualizing review data and comparing competitors

📄 Generating PDF audit reports

🖥️ Building a frontend to display audit results

🛠️ Technologies

Python for data processing and analysis

APIs for retrieving app information and reviews

FastAPI for backend endpoints

React, TypeScript, and Tailwind CSS for the frontend

PDF generation for downloadable reports

🧠 What I learned

Working on this project helped me understand how different parts of an application fit together, from retrieving data and processing it to presenting results through a user interface.

It also taught me that building a useful tool involves more than just writing code. Handling errors, connecting the frontend to the backend, and presenting information clearly are equally important.

🚧 What's next?

I want to continue improving the project, refining the analysis, and making the overall experience more useful.

This is part of my journey into software development and data analytics, and I'm looking forward to learning more by building real projects.

I'd love to hear your thoughts!

What features would you add to a tool that audits app reviews? 👇