DEV Community: Gowtham M

CareerBuddy - Private Local AI That Tells You Exactly What to Do Next in Your Job Search

Gowtham M — Sun, 04 Oct 2026 19:25:15 +0000

This is a submission for the [Hacktoberfest Weekend Challenge: Build for *This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built CareerBuddy for my friend Arun, a Computer Science final-year student at SRM Institute preparing to land his first developer job.

Arun had the resume. He had the skills. He had a list of companies. But every day he asked the same question: what should I actually focus on today?

Most tools tell you to improve your skills or apply to more jobs. That is not useful when you have 2 hours before your next interview.

CareerBuddy answers one question: given your resume, your target jobs, your skill gaps, your upcoming interviews, and the time you have today, what is the single most impactful thing you should do right now?

And it answers it. Specifically. With a plan. Powered entirely by local AI running on your own device. No cloud. No subscription. No data leaves your machine.

The Friend

Arun Kumar, B.E. Computer Science, SRM Institute 2024. Skills: Python, SQL, React, FastAPI, Git. Goal: land a junior developer role within 3 months. His biggest problem was not ability. It was knowing what to focus on each day.

Features

Career X-Ray is the signature feature. Paste your resume and any job description. Local AI runs a full pipeline and returns a career match score from 0 to 100, the skills you already have that the job needs, the missing skills ranked by job relevance, the single biggest opportunity to close, and one specific time-boxed next action.

Next Best Move is the core product feature. Not 20 suggestions. One. The system weighs skill gap severity, interview proximity, application urgency, and available time. It surfaces the single highest-impact action for right now.

Application Tracker covers the full pipeline from Saved to Applied to Assessment to Interview to Final Round to Offer or Rejected. It flags applications needing attention today.

Interview Coach generates questions tailored to the exact role, company, and your specific skill gaps. You answer, get scored from 0 to 100, receive targeted feedback, and get a follow-up question.

Skill Gap Engine visually compares your current skill levels against what target jobs actually require, sorted by relevance.

AI Settings shows live Ollama connection status, model detection, and a full privacy breakdown. Transparent about exactly what is running locally.

Demo Mode populates Arun's complete profile with one click: full resume, 5 realistic applications across all pipeline stages, 2 upcoming interviews, 10 skills with real proficiency levels, and a pre-computed Career X-Ray result. Everything visible in under 10 seconds.

Demo

Live app: https://gowtham280103.github.io/Career-X-Ray/

Open the link, click Load Demo Profile on the landing page, then explore the Dashboard, Career X-Ray, Applications, and Interview Coach. No signup, no API key, no configuration required.

To test Career X-Ray, go to the X-Ray page, the demo resume is pre-filled, paste any job description, and click Run Deep Analysis.

Code

Gowtham280103 / Career-X-Ray

CareerBuddy

"CareerBuddy doesn't just tell you where you stand. It tells you what to do next."

Built for the Hacktoberfest Weekend Challenge: Build for a Friend

A private local AI career companion for Arun — a CS student preparing to land his first developer job.

🚀 Quick Start · ✨ Features · 🎯 Demo · 🔧 Architecture · 🛡️ Privacy

The Problem

Job hunting is overwhelming. You have a resume, a list of companies, a set of skills — and no idea what to focus on today to get closer to an offer.

Most tools tell you to "improve your skills" or "apply to more jobs." That's not useful.

CareerBuddy asks a different question:

"Given everything I know about your resume, your target jobs, your skill gaps, your upcoming interviews, and the time you have today — what is the single most impactful thing you should do right now?"

And…

View on GitHub

How I Built It

The entire AI layer is built on Ollama, an open-source runtime that runs open-weight models fully on your local machine.

The architecture is:

React frontend communicates with a FastAPI backend. The backend calls an AIProvider abstract class. OllamaProvider implements that class using Ollama's Python client. Ollama runs llama3.2 or any installed open-weight model locally. All data is stored in a local SQLite database.

The AIProvider defines four methods: analyze_resume extracts skills, experience, and education from resume text. calculate_match scores the resume against a job description and finds gaps. generate_next_move produces one high-impact recommendation from full context. _generate_json handles structured JSON output from the model.

The model is auto-detected from whatever is installed in Ollama. It is configurable via the OLLAMA_MODEL environment variable. When Ollama is offline the app falls back to deterministic responses clearly labeled as Demo Mode, never pretending to be AI.

Tech stack: React 19, TypeScript, Vite 8, Tailwind CSS v4, Framer Motion, Zustand, React Router 7 on the frontend. FastAPI, Python 3.10, SQLAlchemy, SQLite, and the Ollama Python client on the backend.

Key API endpoints: POST /api/career-xray for deep resume and job analysis, POST /api/next-move for a single recommendation, POST /api/interview/generate-questions for role-specific questions, POST /api/interview/evaluate-answer for scoring, POST /api/daily-plan for today's schedule, and GET /api/ai/status for Ollama connection status.

To run it locally, clone the repo, activate the Python virtual environment in the backend folder, run pip install -r requirements.txt, then python -m uvicorn main:app --reload --port 8000. In the frontend folder run npm install then npm run dev. Optionally run ollama pull llama3.2 and ollama serve for real AI. The app runs at localhost:5173 and the backend at localhost:8000.

Why Does Open Innovation Matter

CareerBuddy is built for someone who cannot afford a subscription to a career AI product. Arun is a student. His resume, his interview anxiety, his job search is deeply personal data. He should not have to hand it to a corporation to get career guidance.

Open-source AI made three things possible that a closed API would not.

First, privacy is structural not a promise. With OpenAI or Gemini, data privacy is a policy. With Ollama and llama3.2, there are zero network calls during inference. The resume never leaves the machine. This is not a policy, it is physics.

Second, cost is zero. Llama3.2 is free. Running it locally is free. CareerBuddy can be given to Arun and anyone like him with no subscription, no API key, no credit card. The barrier to intelligent career guidance drops to zero.

Third, the model is replaceable. Because AIProvider is abstract, swapping llama3.2 for Mistral, Gemma, Phi, or any future model is a one-line config change. CareerBuddy is not locked to any company's roadmap or pricing. As open-weight models improve, CareerBuddy gets better for free.

The most important thing open innovation made possible: I built a genuinely useful tool for a real person, for free, that respects his privacy, without asking permission from any AI company. That is what open innovation means in practice.

Prize Categories

Hacktoberfest Weekend Challenge: Build for a Friend
Open-Source AI at the Core (Ollama + llama3.2)

Building MoneyBuddy: From a Simple Voice Agent to a Multi-Agent AI System in 10 Days

Gowtham M — Sat, 15 Aug 2026 16:53:01 +0000

Hi, I'm Gowtham M.

Over the last 10 days, I participated in the 10 Days of Voice Agents — VoiceForBharat Edition and built MoneyBuddy, an AI-powered voice assistant designed to make financial and government scheme-related information more accessible through natural conversations.

What started as a basic voice interaction gradually evolved into a system involving real-time AI, voice processing, memory, tool usage, human escalation, analytics, and multi-agent handoffs.

The goal was simple:

Can users get help with financial and government scheme-related questions through a natural voice conversation instead of navigating multiple websites and forms?

What started as a basic voice interaction gradually evolved into a system involving real-time AI, voice processing, memory, tool usage, human escalation, analytics, and multi-agent handoffs.

The idea behind MoneyBuddy

Users often need answers to questions like:

Am I eligible for a scheme?
What information do I need?
What should I do next?
Can this be explained in a simpler way?

Instead of searching through multiple sources, MoneyBuddy is designed to let users speak naturally to an AI assistant.

The core flow looks like this:

User Voice
    ↓
Speech-to-Text
    ↓
MoneyBuddy AI Agent
    ↓
Tools / Memory / Agent Routing
    ↓
Response Generation
    ↓
Text-to-Speech
    ↓
User

The 10-day journey

Day 1 — Building the foundation

I started by understanding how a real-time voice agent works.

The basic pipeline was:

Voice Input → AI Processing → Voice Output

This became the foundation for MoneyBuddy.

Day 2 — Designing better conversations

A voice assistant cannot simply read long chatbot-style responses.

I focused on making interactions:

Short
Conversational
Clear
Natural for voice

This made me think more about user experience, not just AI responses.

Day 3 — Defining the agent's role

I worked on giving MoneyBuddy clear instructions.

The agent needed to understand:

What it is responsible for
How it should respond
When to ask follow-up questions
When not to guess
When another action is required

One important lesson: an AI agent performs better when its responsibilities are clearly defined.

Day 4 — Adding tools

Some information should not be generated or guessed by an LLM.

So I explored structured tool usage.

User Request
    ↓
Agent Understands Intent
    ↓
Tool Required?
    ↓
Call Tool
    ↓
Get Result
    ↓
Explain Result to User

This was an important shift from a simple conversational AI system toward an AI agent capable of taking structured actions.

Day 5 — Working with memory

I explored how MoneyBuddy could remember useful conversation context.

The goal was to avoid making returning users repeat the same information.

At the same time, memory requires responsible handling.

The agent should ask for consent before storing relevant information.

This taught me that AI memory is not just a database feature—it is also a user trust feature.

Day 6 — Human escalation

Not every problem should be handled completely by AI.

For situations requiring additional help or manual intervention, I explored human escalation.

A useful AI system should not pretend to know everything.

Sometimes the best response is knowing when to say:

This requires additional assistance.

My key learning:

Good AI systems should understand their limitations.

Day 7 — Thinking beyond a chatbot

At this stage, I started looking at MoneyBuddy as a complete system.

The focus moved toward:

Conversation flows
Agent states
Error handling
Different user paths
System reliability

This was when the project started becoming more than a basic voice demo.

Day 8 — Analytics and outcomes

Building an agent is only the first step.

I also explored tracking what happens during interactions.

Examples of useful metrics include:

Total conversations
Successful outcomes
Escalations
Types of user requests
Agent handoffs

This helped me understand an important engineering principle:

If you cannot observe a system, it becomes difficult to improve it.

Day 9 — Multi-agent architecture

This was one of the biggest upgrades to MoneyBuddy.

Instead of asking one agent to handle everything, I added a dedicated Government Scheme Specialist.

The architecture became:

                     User
                       ↓
             MoneyBuddy Main Agent
                       ↓
          Is specialist help needed?
                  ↙          ↘
                No            Yes
                ↓              ↓
        Main Agent       Scheme Specialist
                ↘          ↙
                 Final Response
                       ↓
                     User

The main agent handles:

Greetings
General conversations
Initial request understanding
Basic assistance
Deciding whether a handoff is required

The specialist handles:

Government scheme-related questions
More detailed scheme discussions
Specialized assistance

The important part was context handoff.

The user should not have to explain the entire problem again after being transferred.

This was my biggest takeaway from multi-agent systems:

Specialized agents with clear responsibilities can be easier to manage than one agent trying to do everything.

Day 10 — Bringing everything together

By the end of the challenge, MoneyBuddy had evolved into a system involving:

Voice AI
   +
LLM
   +
Clear Instructions
   +
Structured Tools
   +
Memory
   +
Consent
   +
Human Escalation
   +
Analytics
   +
Specialist Routing
   +
Multi-Agent Handoff

What I learned

Building MoneyBuddy taught me that a voice AI application is much more than:

LLM + Microphone + Speaker

A useful AI agent needs:

Clear objectives
Good prompts
Natural conversation design
Reliable tools
Responsible memory
User consent
Error handling
Real-time performance
Human escalation
Observability and analytics
Clear agent responsibilities
Agent routing
Continuous testing

Challenges I faced

Some of the biggest challenges were:

Real-time latency

A voice pipeline contains multiple stages:

Speech → STT → LLM → Tools → TTS → Audio

A delay at any stage affects the overall user experience.

Agent handoff

Transferring a conversation between agents requires clear routing logic and context management.

Without proper context transfer, users may need to repeat themselves.

Defining agent responsibilities

As the system grew, it became increasingly important to clearly define what each agent should handle.

What's next for MoneyBuddy?

I would like to continue improving the project by exploring:

More specialist agents
Better tool integration
More verified data sources
Improved latency
Better multilingual support
More advanced analytics
Stronger memory management
Better mobile experience
Public deployment

Final thoughts

These 10 days changed the way I think about AI applications.

I started with the idea of building a voice assistant.

I ended up learning about real-time systems, AI agents, tools, memory, user consent, escalation, observability, and multi-agent architectures.

My biggest takeaway:

A useful AI product is not built by choosing only a powerful model. It is built by connecting the right components with clear responsibilities, good user experience, reliable systems, and continuous testing.

MoneyBuddy is still a work in progress, but these 10 days gave me a much stronger foundation for building AI agents that can interact with users in more natural and useful ways.

VoiceForBharat #MurfAI #VoiceAI #AIAgents #MultiAgentAI #LiveKit #Python #GenerativeAI #MoneyBuddy

The Agentic Era Is Here — But Are We Actually Ready?

Gowtham M — Wed, 29 Apr 2026 07:56:57 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

While watching Google Cloud NEXT ’26, I didn’t just feel excited. I felt a bit uncomfortable too.

Because what Google introduced is not just another update in cloud or AI. It’s a shift in how work itself might happen.

The biggest announcement for me was the Gemini Enterprise Agent Platform.

Until now, most of us have been using AI as a tool. We ask questions, get answers, maybe generate code or content. But what Google is pushing is something very different. They are moving towards systems where AI agents can actually take actions, collaborate with each other, and complete tasks end-to-end.

One line from the keynote stayed with me.

The era of the pilot is over. The era of the agent is here.

That sounds powerful. But it also raises important questions.

What really impressed me was how multiple agents can work together from a single prompt. One agent handles research, another analyzes data, another creates content, and another interacts with development tools. This is not just automation. This feels like assigning work to a team.

If this becomes normal, then using software may change completely. Instead of clicking through apps, we might just describe what we want, and a system of agents handles everything.

Another part that stood out was Workspace Intelligence. Anyone who uses productivity tools knows how much time is wasted searching for information. Emails, documents, chats, spreadsheets — everything is scattered. Google is trying to solve that by creating a system that understands context across all of them and gives you exactly what you need.

If it works as shown, it could remove a lot of friction from daily work.

The Agentic Data Cloud idea also felt very practical. In real-world scenarios, data is never clean or centralized. It lives in different formats and platforms. Instead of forcing everything into one place, Google is allowing AI to understand data where it already exists. That approach feels more realistic than traditional pipelines.

But this is where my concerns begin.

If organizations start using hundreds or even thousands of agents, how do we manage them? Even today, debugging distributed systems is difficult. Now imagine debugging autonomous agents making decisions.

There is also the question of trust. When agents move from assisting to acting, we are giving them more responsibility. In critical systems, even small mistakes can have serious consequences.

And from a learner’s perspective, I’m still thinking about accessibility. These tools are described as low-code, but understanding how to design and control agent-based systems may still require strong fundamentals in cloud, data, and AI.

Personally, this event changed how I look at my future in tech.

Earlier, I thought learning tools and frameworks was enough. Now it feels like the real skill will be designing systems where multiple intelligent components work together. The role of a developer might shift from writing everything manually to orchestrating how things work.

Google Cloud NEXT ’26 didn’t just introduce new features. It introduced a new way of thinking.

We are moving from using software to describing outcomes, and letting systems figure out how to get there.

That is powerful.

But it also means we need to think carefully about control, reliability, and responsibility.

So I’m curious.

Are we ready for this shift, or are we still underestimating how complex it could become?

EcoTrack AI — Carbon Footprint Tracker & Dashboard

Gowtham M — Fri, 17 Apr 2026 18:18:55 +0000

This is a submission for Weekend Challenge: Earth Day Edition

EcoTrack AI — Track, Visualize & Reduce Your Carbon Footprint
This is my individual work, built entirely from scratch for the #weekendchallenge.

🔗 Links
🚀 Live Demo: ecotrack-ai-317275340485.asia-south1.run.app
💻 GitHub Repo: github.com/Gowtham280103/greenprint
💡 What is EcoTrack AI?
EcoTrack AI is a full-stack web application that helps users track, visualize, and reduce their daily carbon footprint using AI-powered suggestions, interactive charts, and gamification.

You enter your daily habits — travel, electricity, food, and shopping — and the app instantly calculates your CO₂ emissions, gives you an Eco Score, and generates personalized tips to help you live greener.

✨ Features
🎯 Daily Tracker — Log travel, electricity, food & shopping habits
📊 Eco Score (0–100) — Animated SVG ring showing your green rating
🟢 Impact Level — Low / Medium / High with color coding
🌳 CO₂ Equivalents — See your footprint as trees, flights, phone charges
🤖 AI Suggestions — Powered by Google Gemini API with smart local fallback
📉 7-Day Trend Chart — Line chart with global average reference line
🥧 Category Breakdown — Doughnut & pie charts via Chart.js
🏆 Badges & Gamification — Earn badges like "Green Warrior", "EV Rider", "Cyclist"
🎮 Daily Challenges — 9 eco challenges with XP rewards
🌙 Dark Mode — Full dark/light theme toggle with persistence
📱 Fully Responsive — Works on mobile, tablet, and desktop
📋 History Log — All past entries with Eco Score column
🛠️ Tech Stack
Layer Technology
Backend Python, Flask, Flask-CORS
Frontend HTML5, CSS3, Vanilla JavaScript
Charts Chart.js 4
AI Google Gemini API
Storage JSON file-based (no database needed)
Deployment Google Cloud Run + Docker
Font Inter (Google Fonts)
🏗️ Architecture
greenprint/
├── Dockerfile
├── .dockerignore
└── ecotrack/
├── backend/
│ ├── app.py # Flask API + static file serving
│ ├── calculator.py # Emission logic + AI suggestions + Eco Score
│ ├── storage.py # JSON persistence
│ └── requirements.txt
└── frontend/
├── index.html # 4-page SPA (Tracker, Dashboard, History, Challenges)
├── style.css # 700-line modern dashboard CSS with dark mode
└── app.js # 600-line frontend logic + Gemini integration
🚀 How to Run Locally

Clone

git clone https://github.com/Gowtham280103/greenprint.git
cd greenprint

Install dependencies

pip install -r ecotrack/backend/requirements.txt

Start server

python ecotrack/backend/app.py
Then open http://localhost:5000

☁️ Deployment
Deployed on Google Cloud Run using Docker. The container auto-scales to zero when idle (free tier friendly).

gcloud run deploy ecotrack-ai \
--source . \
--region asia-south1 \
--allow-unauthenticated
🧠 How the AI Works
The app uses rule-based logic with real emission factors from EPA & IPCC to calculate CO₂, then calls the Google Gemini API to generate personalized, context-aware suggestions like:

"Your 20 km petrol car trip contributes 3.84 kg CO₂. Switching to public transport 2 days/week saves ~1.1 kg CO₂/day — that's 286 kg/year!"

If no Gemini API key is set, a smart local fallback generates equally personalized insights.

📸 Screenshots

Built and Deployed a Smart Stadium Dashboard using Google Cloud Run

Gowtham M — Wed, 15 Apr 2026 10:08:16 +0000

I recently built and deployed a Smart Stadium Dashboard that simulates real-time crowd management inside a large venue.

This project focuses on improving the physical event experience by monitoring crowd density, waiting times, and operational alerts in real-time.

🔹 Key Features
• Live stadium map with crowd density visualization
• Waiting time tracking for gates and facilities
• Priority alert system for critical situations
• Staff allocation monitoring
• AI-based crowd suggestions for better management

🔹 Tech Stack
• Frontend: HTML, CSS, JavaScript (Vite)
• Backend: Node.js (Express)
• Deployment: Google Cloud Run

🔹 What I Learned
• How to deploy full-stack applications on cloud platforms
• Handling frontend and backend integration in production
• Understanding real-world scalability concepts
• Debugging cloud deployment issues

🔹 Challenges Faced
Initially faced multiple deployment errors while configuring Cloud Run, especially with build and server setup. After debugging logs and fixing the server configuration, I successfully deployed the application.

🌐 Live Demo: https://smart-stadium-dashboard-317275340485.us-central1.run.app

This project gave me a strong understanding of cloud deployment and real-time system design.

I built an app that forces you to procrastinate (and it actually works)

Gowtham M — Wed, 08 Apr 2026 18:41:21 +0000

This is a submission for the DEV April Fools Challenge

A chaotic funny scene of a person trying to work on a laptop while popups, alerts, and distractions explode everywhere, colorful, meme style, modern UI elements

What I Built

I built a web app that finally solves productivity…

By completely destroying it.

Introducing Procrastination-as-a-Service (PaaS) — an app designed to make sure you never finish your work.

Instead of helping you focus, it actively distracts you with:

Fake urgent alerts 🚨
Random useless tasks
Sudden redirects to YouTube
Annoying popups that question your life choices

It doesn’t improve your productivity.
It makes sure you avoid it entirely.

Demo

Try to be productive here (good luck 😈):

👉 https://remarkable-starship-ffc0ec.netlify.app/

Code

Check out the chaos behind the scenes:

👉 https://github.com/Gowtham280103/CHAOS_APP.git

How I Built It

HTML, CSS, JavaScript
Used setInterval() to trigger random distractions
Created fake notifications and alerts
Random actions like opening tabs, changing UI, and interrupting users
Deployed using Netlify

The logic is simple:
User tries to work → App interrupts → Productivity destroyed

Prize Category

Community Favorite

Because this is something everyone relates to…

Even if they didn’t ask for it 😄

Final Thoughts

We spend so much time building tools to improve productivity.

So I built one that does the opposite.

And honestly… it works too well.

Thanks for reading 🚀