Forem: Adithyan G

Bulk Applicant Dispatcher — A Privacy-First MERN Stack Application for Smart Job Hunting

Adithyan G — Wed, 25 Feb 2026 07:09:46 +0000

Applying to jobs as a fresher can feel repetitive, overwhelming, and unstructured.

You find dozens of openings.

You copy-paste emails.

You attach resumes repeatedly.

You try to track who you’ve contacted.

You worry about accidentally emailing the same recruiter twice.

To solve this, I built Bulk Applicant Dispatcher — a locally hosted MERN stack application designed to help job seekers send multiple applications efficiently, professionally, and safely.

This is not a marketing spam tool.

It is a structured, privacy-first job application system.

💡 The Problem

Most job seekers:

Send applications manually
Struggle to track recruiter responses
Risk duplicate emailing
Use third-party tools that store sensitive data externally

Existing bulk email tools are usually:

Designed for marketing campaigns
Cloud-based
Not privacy-focused
Lacking cooldown safeguards

I wanted a system that:

Runs entirely on localhost
Uses my own Gmail securely
Enforces responsible email scheduling
Keeps all personal data under my control

🔐 Core Philosophy: Privacy First

Bulk Applicant Dispatcher runs 100% locally.

No external server
No cloud database
No third-party email relay
No external storage of resumes or contacts

Everything — templates, company lists, history logs — is stored in a local MongoDB instance.

Your data never leaves your machine.

✨ Key Features

🧠 Smart Cooldown Mechanism (15 Days)

One of the most important features.

The system:

Tracks every dispatched email
Stores recipient email + timestamp
Prevents sending duplicate applications within 15 days
Allows a Force Send override when necessary

Cooldown Logic Example

if (lastEmailDate && daysSinceLastEmail < 15 && !forceSend) {
  skipEmail();
} else {
  sendEmail();
}

This ensures:

Professional outreach
Reduced spam risk
Safer Gmail usage
Controlled automation

Editable Plain-Text Templates

Instead of copying and pasting from Word documents:

Write professional cover letters directly in the app
Save multiple template variations
Easily switch between them
Use structured profile data for personalization

The app reads user details from a local profile.json file:

{
  "name": "Your Full Name",
  "my_place": "Your City, Country",
  "phone_no": "+91 1234567890",
  "my_email": "your_email_id@gmail.com"
}

Templates dynamically populate this data during dispatch.

No HTML required. Just clean, readable English.

Built-In Contact Manager

Managing contacts through spreadsheets becomes messy quickly.

This system allows:

Manual company entry via UI
Bulk import using JSON
Easy editing and deletion
Structured storage inside MongoDB

As companies are added, a companies.json file is automatically generated inside the server directory.

Dashboard & Application Tracking

The dashboard provides structured visibility into your job hunt:

Total applications sent
Pending contacts
Total companies added
Full application history
Timestamped logs

This turns job hunting into a measurable workflow instead of chaos.

Force Sending Override

Sometimes urgency matters.

The app allows:

Force sending to a specific recruiter
Force sending an entire batch
Bypassing cooldown when required

Automation with control.

Technology Stack

Frontend

React (v19)
Vite ### Backend
Node.js & Express.js
- Email dispatch logic
- Cooldown validation
- API routing
- Template processing
- Communication between frontend and backend
Nodemailer
- Gmail SMTP connection
- Secure authentication via App Password
- Resume attachment
- Bulk email dispatching

Uses Google App Password authentication (not your regular Gmail password).

MongoDB & Mongoose

Local database storing:

Contact list
Templates
Email history
Cooldown metadata
Dispatch logs

Using MongoDB provides flexible and structured storage for scalable tracking.
Environment Configuration

Inside server/.env:

EMAIL_USER=your_real_email_id@gmail.com
EMAIL_PASS=your_gmail_app_password
MONGO_URI=mongodb://localhost:27017/bulk_email_sender
PORT=3000
resumePath=your_resume_name.pdf

Important: Gmail App Password

You must generate an App Password:

Go to Google Account → Security
Enable 2-Step Verification
Generate App Password
Paste the 16-character key into .env

Never use your actual Gmail password.

Usage Flow

Add contacts manually or import JSON.
Edit or create email templates.
Ensure resume is placed inside server/resumes/.
Click Start Run.
System checks cooldown.
Eligible contacts receive emails.
History updates automatically.
Everything runs locally.

What This Project Demonstrates

This project goes beyond CRUD operations.

It demonstrates:

SMTP automation
Cooldown / rate-limiting logic
Secure environment configuration
Structured MERN architecture
Privacy-first system design
Real-world application tracking

Responsible Usage Notice

This tool is strictly for ethical, professional job applications.

It is not intended for spam, unsolicited marketing, or misuse.

The cooldown system exists to promote respectful communication and protect both users and recruiters.

Written by Adithyan G

Portfolio: https://adithyan-phi.vercel.app/

Clowbot AI Complete Guide: Setup, Installation, Security Risks & Best Practices

Adithyan G — Mon, 23 Feb 2026 16:19:46 +0000

Introduction to Clowbot AI

Clowbot AI is an AI-powered chatbot platform designed to automate conversations across websites and digital channels. It enables businesses to deploy intelligent bots capable of answering FAQs, capturing leads, guiding users through workflows, and supporting customer service operations.

With natural language processing (NLP) capabilities, Clowbot AI can interpret user intent and provide contextual responses in real time. The platform is typically used in industries such as e-commerce, SaaS, education, and online services to reduce response time, improve engagement, and streamline repetitive communication tasks.

However, like all AI-driven automation systems, proper configuration, security awareness, and ongoing monitoring are critical for safe and effective deployment.

System Requirements

Clowbot AI is generally cloud-based, meaning no heavy local installation is required. Most users only need a compatible browser and stable internet connection.

Minimum PC Requirements

Operating System:
- Windows 10 or later
- macOS 10.13 or later
- Linux (Ubuntu 18.04+ or equivalent)
Processor: Dual-core 2.0 GHz or higher
RAM: 4 GB minimum (8 GB recommended)
Storage: At least 500 MB free
Browser: Latest version of Chrome, Firefox, or Edge
Internet: Stable broadband connection (5 Mbps or higher recommended)

For developers integrating APIs, additional tools such as Node.js or Python may be required.

Installation Guide (All Platforms)

1. Web-Based Installation (Recommended)

Clowbot AI is typically accessed through a web dashboard.

Steps:

Open your browser.
Visit the official Clowbot AI website.
Sign up or log in.
Access your dashboard.

There is no command-line installation required for standard usage.

2. Windows Installation

Browser-Based

No installation command is needed. Use a supported browser.

Desktop Client (If Provided)

Download the .exe installer.
Run the installer.
Follow on-screen instructions.
Launch from the Start Menu.

3. macOS Installation

Browser-Based

Access directly through Safari or Chrome.

Desktop App (If Available)

Download the .dmg file.
Drag the app to Applications.
Launch normally.

4. Linux Installation

For browser usage:

sudo apt update
sudo apt install firefox

Then log in through the browser.
If a Linux AppImage is provided:

chmod +x clowbot.AppImage
./clowbot.AppImage

Only use commands officially provided by the vendor.

How to Set Up Clowbot AI

Step 1: Create an Account

Register on the official website.
Verify your email.
Log in to the dashboard.

Step 2: Create a New Bot

Navigate to the dashboard.
Click Create New Bot.
Enter:
- Item one
- Bot name
- Business name
- Use case (Support, FAQ, Lead Generation)

Choose a template or start from scratch.

Step 3: Configure Basic Settings

Add a welcome message.
Upload branding elements.
Customize colors.
Set fallback responses for unknown queries.

Step 4: Build Conversation Flows

Using the visual builder:

Add structured FAQ blocks.
Create button-based responses.
Configure conditional logic.
Add lead capture forms. Keep flows clear and goal-oriented.

Step 5: Train the AI

Improve performance by:

Adding FAQs.
Including multiple variations of * user questions.
Defining precise answers.
Updating training data regularly.

Step 6: Integrate with Your Website

Copy the embed script.
Paste it before the </body> tag.
Publish your website. Alternatively, use CMS plugins if supported.

Step 7: Test Before Going Live

Test all conversation paths.
Verify lead capture.
Test fallback responses.
Use incognito mode for realistic testing.

Step 8: Monitor & Optimize

Track:

Chat volume
Engagement rates
Conversions
Drop-off points Refine workflows based on analytics.

Security Concerns & Industry Risks

While chatbot platforms provide automation benefits, related projects in the ecosystem (including similarly named AI agents) have faced security discussions.

Reported Technical Risks (OpenClaw / Related Projects)

Some AI agent projects have disclosed vulnerabilities such as:

Log-Poisoning

A vulnerability where attackers could inject malicious instructions into system logs, potentially influencing agent behavior.

Prompt Injection

Attackers may embed hidden instructions within user inputs, leading AI systems to perform unintended actions—especially dangerous if connected to crypto tools or sensitive APIs.

These are software-level risks and not confirmed large-scale financial breaches, but they highlight architectural concerns in AI agent systems.

Scam & Token Misuse Risks

Reports have indicated scammers used similar branding to launch fake tokens (e.g., “CLAWD”) claiming affiliation with AI projects.

Typical pattern:

Launch token with familiar branding.
Inflate price via hype.
Dump holdings.
Token crashes (reportedly ~90% in one case).

Always verify official channels before purchasing tokens associated with AI projects.

AI Trading & Automation Risks

If Clowbot or related systems are integrated into financial automation:

Bots can execute unintended large trades.
Market volatility can amplify losses.
Misconfiguration can multiply risk exposure. Automation increases efficiency—but also magnifies errors.

Important Disclaimer

This blog is for informational purposes only and does not constitute financial, legal, or cybersecurity advice.

AI bots require proper configuration and monitoring.
Automated trading carries financial risk.
Always verify official sources before investing.
Use limited API permissions when connecting to exchanges.
Start with minimal capital when testing automation systems. AI automation tools are powerful—but they must be used responsibly.

Written by Adithyan G, MERN stack developer.

Portfolio: adithyan-phi.vercel.app/

Understanding Git and GitHub as a Beginner

Adithyan G — Sat, 24 Jan 2026 10:37:34 +0000

When I first started learning to code, Git and GitHub were two things that completely confused me.

I kept asking myself questions like:

Are Git and GitHub the same thing?
Why do I need them?
What does commit, push, or pull even mean?

If you’re a beginner and feel the same way, this post is for you. I’ll explain Git and GitHub in simple terms, without assuming prior knowledge.

What Is Git?

Git is a version control system.

That sounds complex, but here’s a simple way to think about it:

Git is like a save history for your code.

Instead of having files like:

project-final
project-final-v2
project-final-really-final

Git keeps track of every change you make in an organized way. You can:

Go back to older versions
See what changed and when
Experiment without fear of breaking everything

Git works locally on your computer.

What Is GitHub?

GitHub is a platform that stores Git repositories online.

If Git is your local save history, then GitHub is:

A backup of your code on the internet
A collaboration platform for working with others
A portfolio to show your projects

In short:

Git → version control tool
GitHub → place to host Git repositories

Repository (Repo)

A repository is just a project folder that Git is tracking.

It contains:

Your project files
The entire history of changes

You can have repositories:

Locally (on your machine)
Remotely (on GitHub)

Basic Git Workflow (Beginner-Friendly)

Here’s the basic flow most beginners use:

Make changes to your code
Tell Git which files you want to save
Save those changes with a message
Send them to GitHub

Let’s break that down.

`git init` – Start Tracking a Project

git init

This command tells Git:

“Start tracking this folder.”

It creates a hidden .git folder that stores the history

`git status` – Check What’s Going On

git status

This shows:

Which files were changed
Which files are ready to be saved
Which files are not tracked yet

This is one of the most useful Git commands.

`git add` – Stage Changes

git add .

This tells Git:

“I want to include these changes in the next save.”

Think of this like selecting files before clicking Save.

`git commit` – Save Changes

git commit -m "Add initial project files"

A commit is a snapshot of your project at a point in time.

The message should briefly explain what changed.

Good commit messages matter more than you think.

Connecting Git to GitHub

Once your project is on GitHub, you connect it to your local project:

git remote add origin <repository-url>

Now Git knows where your remote repository lives.

`git push` – Send Code to GitHub

git push origin main

This uploads your commits from your computer to GitHub.

If GitHub is empty and your local project has code, this is how you publish it.

`git pull` – Get Updates from GitHub

git pull origin main

This brings changes from GitHub to your local machine.

Useful when:

You’re working on multiple devices
You’re collaborating with others

Branches (Very Simple Explanation)

A branch is a separate line of development.

You can:

Experiment safely
Work on features without breaking the main code

Beginners usually start with the main branch, and that’s perfectly fine.

Common Beginner Mistakes (I Made These)

Being afraid of Git commands
Forgetting to commit often
Writing vague commit messages
Thinking GitHub automatically saves code

Git only saves when you tell it to.

Why Git and GitHub Matter

Even as a beginner, Git and GitHub help you:

Build good habits early
Track progress over time
Collaborate confidently
Create a public coding portfolio

You don’t need to master everything at once. Just understanding the basics is enough to get started.

Final Thoughts

Git and GitHub feel overwhelming at first, but they become clearer with practice.
The key is to use them regularly, even for small projects.

If you’re learning to code, start using Git now, not later.

Thanks for reading. If you’re also a beginner, feel free to share your experience or ask questions in the comments.

Written by Adithyan G, MERN stack developer.

Portfolio: adithyan-phi.vercel.app/

Will AI Replace Web Developers? Or Are We Entering the Era of Vibe Coding?

Adithyan G — Mon, 05 Jan 2026 09:10:04 +0000

AI tools like ChatGPT, GitHub Copilot, and Cursor have changed how we write code.

A question every developer is asking now is:

Will AI replace web developers?

No, It’s changing how we code — not who codes.

Welcome to the era of Vibe Coding.

🤖 What Is Vibe Coding?

Vibe coding means:

You focus on what you want to build
AI helps you with how to write it faster

Instead of writing every line manually, you:

Describe features
Ask AI for boilerplate
Refactor, optimize, and validate the output

You’re still the architect — AI is the assistant.

❌ Why AI Won’t Replace Web Developers

1️⃣ AI Doesn’t Understand Business Context

AI can generate code, but it doesn’t understand:

Client requirements
User behavior
Business goals
Real-world constraints

Developers translate human problems into technical solutions.

AI only reacts to prompts.

2️⃣ AI Can Write Code, But Not Systems

AI is good at:

Components
Functions
Simple logic

But web development involves:

Architecture decisions
Security
Scalability
Performance optimization
Trade-offs

These require experience and judgment.

3️⃣ Someone Has to Verify the Code

AI-generated code can:

Be inefficient
Be insecure
Break edge cases
Use outdated practices

Developers are still responsible for:

Debugging
Reviewing
Testing
Maintaining

AI doesn’t take responsibility — you do.

✅ How AI Is Actually Helping Developers

AI is boosting productivity, not replacing jobs.

🔥 Real Benefits

Faster prototyping
Less boilerplate code
Quick debugging help
Learning new frameworks faster
Better documentation generation

Developers who use AI well are 10x more productive.

🚀 The New Role of a Web Developer

The role is shifting from:

❌ Write every line of code

✅ Design systems, guide AI, and solve problems

Modern developers:

Think in architecture
Focus on UX and performance
Use AI as a tool, not a crutch

🧠 Skills That Matter More Than Ever

To stay relevant, developers should focus on:

JavaScript fundamentals
Framework knowledge (React, Next.js, etc.)
System design basics
Debugging skills
Prompt engineering
Code review mindset

⚠️ Who Is at Risk?

Let’s be honest.

People at risk are:

Those who only copy-paste
Those who don’t understand the code they use
Those who refuse to learn new tools

AI replaces low-effort coding, not real developers.

🧩 Final Verdict

AI will not replace web developers.

But developers who use AI will replace those who don’t.

Vibe coding is not about laziness.

It’s about working smarter, not harder.

💬 What Do You Think?

Are you excited about AI-assisted coding or worried about it?

Let’s discuss in the comments 👇

🔗 Portfolio

What Building One Real Project Taught Me More Than 5 Tutorials

Adithyan G — Tue, 30 Dec 2025 10:49:16 +0000

When I started learning web development, I did what most beginners do: I followed tutorials. A lot of them.

React crash courses. MERN playlists. “Build this app in 1 hour” videos. I finished them, felt productive, and assumed I was learning.

Then I tried to build one real project on my own.

That single project exposed more gaps in my understanding than five tutorials combined.

This post is about what actually changed when I stopped following along and started building.

Tutorials Give You Confidence. Projects Take It Away.

Tutorials are clean and controlled.

The folder structure is decided for you
Dependencies magically work
Errors are rare and predictable
The app always runs at the end

Real projects are the opposite.

In my project:

Nothing worked the first time
I didn’t know where files should go
Errors made no sense
Deployment broke everything again

That discomfort wasn’t a failure.

That was the learning.

I Finally Understood Why Code Is Written the Way It Is

In tutorials, you copy patterns without questioning them.

In a real project, you are forced to ask:

Why should this logic be in the backend?
Why does this need its own component?
Why should routes be structured this way?

I learned this the hard way:

Dumping everything into one file becomes unmaintainable fast
Separating routes, controllers, and services is not “overengineering”
Environment variables exist because hardcoding secrets will break production

You don’t understand architecture by copying it.

You understand it when bad structure slows you down.

Debugging Became a Skill, Not a Panic Reaction

Tutorial bugs are simple.

Real project bugs are not.

I dealt with:

CORS issues
Environment variables not loading in production
MongoDB connections failing only after deployment
Builds working locally but failing on Vercel

At first, I panicked.

Eventually, I learned to:

Read error messages carefully
Use console.log intentionally
Inspect network requests
Search issues instead of blindly pasting fixes

This is when it clicked: debugging is the real job.

Deployment Taught Me More Than Writing Code

Nothing exposed my weak understanding faster than deployment.

Locally, everything worked.

In production:

API URLs were wrong
Environment variables were missing
Build commands failed
Static assets didn’t load

Deployment forced me to understand:

How frontend and backend actually communicate
How hosting platforms work
Why “it works on my machine” means nothing

After deploying one real app, tutorials felt incomplete without deployment sections.

SEO and Performance Suddenly Mattered

Tutorial apps don’t care if anyone finds them.

A real project does.

While working on my project, I learned:

Why meta tags matter
Why Google doesn’t index empty or poorly structured pages
Why performance affects real users, not just Lighthouse scores
Why clean URLs matter for discoverability

Submitting my site to Google Search Console taught me more about SEO than reading SEO articles ever did.

I Stopped Watching Tutorials the Same Way

After building one real project:

I stopped binge-watching tutorials
I watched smaller, targeted videos
I read documentation more
I implemented features immediately after learning them

Tutorials became references, not a comfort zone.

The Biggest Lesson: Feeling Lost Means You’re Learning

If you feel confused while building:

You’re not bad at development
You’re finally doing real development

Tutorials hide complexity.

Projects force you to face it.

That’s where real growth happens.

Final Advice for Beginners

If you’re starting out:

Build one real project
Make it messy
Deploy it
Break it
Fix it

Then write about it.

One real project will teach you more than five perfectly edited tutorials ever will.

If you’re curious, this is the kind of work I’m building and documenting:

Portfolio: https://adithyan-phi.vercel.app

How I Built a Dynamic Admin Panel for My MERN Stack Portfolio

Adithyan G — Sat, 27 Dec 2025 08:56:53 +0000

As a developer, building a portfolio isn’t just about showcasing projects — it’s about demonstrating how you can create flexible, maintainable web applications. For my portfolio website, I wanted more than a static showcase. I needed a dynamic Admin Panel that would allow me to easily manage my projects, skills, profile details, and resume — all without touching the code every time.

In this post, I’ll walk you through how I built a dynamic admin dashboard using the MERN stack (MongoDB, Express, React, Node.js) that powers my portfolio backend and frontend. This admin panel makes managing my portfolio content a breeze, and I’ll share the key architecture decisions, tools, and lessons learned.

Why Build an Admin Panel for Your Portfolio?

At first, I just had a simple React portfolio displaying static content. But soon, every update required code changes and redeployments, which was time-consuming and error-prone.

By building an admin dashboard, I achieved:

Real-time content updates: Add, update, or delete projects, skills, and other profile data via a UI.
Secure access: Only I can log in to manage content with JWT authentication.
Scalability: Easily extend with new sections or data types without modifying the frontend.
Better organization: Store portfolio content in a database instead of hardcoded files.

Tech Stack Overview

Here’s the stack I used to build the admin panel and the portfolio backend:

Frontend: React with functional components and hooks for building the admin UI.
Backend: Node.js + Express REST APIs for handling CRUD operations.
Database: MongoDB with Mongoose for schema modeling and data storage.
Authentication: JWT (JSON Web Tokens) to secure admin routes.
File Storage: Cloudinary for managing image uploads (profile pics, project images).
Styling: CSS modules and some UI libraries for clean layouts.

Key Features of the Admin Panel

The dashboard lets me manage:

Profile Section: Update bio, profile picture, contact info.
Skills: Add, update, or remove programming skills dynamically.
Projects: CRUD operations for projects including title, description, images, links.
Resume: Upload and update resume files.
Authentication: Secure login with email and password, protected routes using JWT.

How It Works — Architecture Breakdown

1. Backend API Design

I created RESTful APIs to handle CRUD actions for all portfolio data.

Example routes:

GET /api/projects — fetch all projects
POST /api/projects — add a new project
PUT /api/projects/:id — update project by ID
DELETE /api/projects/:id — delete project by ID

The APIs validate requests and interact with MongoDB collections using Mongoose models. I also implemented authentication middleware to protect sensitive endpoints.

2. Authentication with JWT

To secure the admin panel, I built a login system with:

Password hashing using bcrypt.
JWT token generation on login.
Protected routes in both frontend and backend that require a valid token.

3. React Admin Dashboard UI

Using React hooks and axios for API calls, I built components for:

Login Page: Authenticate and store JWT in localStorage.
Dashboard: Overview of portfolio content.
Forms: Controlled forms for adding/editing skills and projects.
File Uploads: Integrated Cloudinary API for image and resume uploads.

I also used conditional rendering and loading states for smooth UX.

Code Snippet — Example: Fetching Projects in Admin Panel

import React, { useEffect, useState } from "react";
import axios from "axios";

const AdminProjects = () => {
  const [projects, setProjects] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    const fetchProjects = async () => {
      try {
        const token = localStorage.getItem("authToken");
        const response = await axios.get("/api/projects", {
          headers: { Authorization: `Bearer ${token}` },
        });
        setProjects(response.data);
      } catch (error) {
        console.error("Error fetching projects:", error);
      } finally {
        setLoading(false);
      }
    };
    fetchProjects();
  }, []);

  if (loading) return <p>Loading projects...</p>;

  return (
    <div>
      <h2>Manage Projects</h2>
      {projects.length === 0 ? (
        <p>No projects found.</p>
      ) : (
        projects.map((project) => (
          <div key={project._id}>
            <h3>{project.title}</h3>
            <p>{project.description}</p>
            {/* Buttons for Edit/Delete can go here */}
          </div>
        ))
      )}
    </div>
  );
};

export default AdminProjects;

Challenges & Lessons Learned

Handling File Uploads: Uploading images and resumes required integrating Cloudinary's API with signed URLs and managing upload states.

State Management: Keeping the admin UI in sync with backend data, especially with real-time CRUD updates, needed careful use of React state and effects.

Authentication Flow: Securing routes and managing JWT tokens was critical to avoid unauthorized access.

UX Considerations: Designing simple but effective forms and feedback messages improved admin usability.

Final Thoughts

Building a dynamic admin panel transformed my portfolio from a static webpage into a powerful content management system I can control without redeploying. It gave me hands-on experience with full-stack development, API design, secure authentication, and file management — all essential skills for a modern web developer.

If you’re planning to build or improve your portfolio, I highly recommend adding an admin dashboard. It not only shows your technical skills but also saves you a ton of time and effort in the long run.

If you want to check out my portfolio in action, feel free to visit:
https://adithyan-phi.vercel.app

Got questions or want to share your experience? Drop a comment below!

Happy coding!

Building an AI-Powered Expense Tracker with the MERN Stack

Adithyan G — Fri, 26 Dec 2025 17:47:57 +0000

Managing personal finances is a challenge a lot of us face. While many expense trackers focus on just logging transactions or basic charts, I wanted to build something smarter—an app that not only tracks expenses but also analyzes spending behavior and provides actionable insights powered by AI.

So I built an AI-Powered Expense Tracker using the MERN stack, enhanced with an AI financial coach powered by LLaMA 3.3 and Groq.

In this post, I’ll walk you through the project idea, architecture, core features, tech stack, and key learnings.

Project Overview

This app helps users:

Track daily expenses with clear categories (Food, Travel, Bills, etc.)
Visualize spending patterns with interactive charts and dashboards
Set budgets and receive smart alerts as spending approaches limits
Interact with an AI financial coach that provides personalized advice

The app is designed as a Progressive Web App (PWA)—installable, offline-capable, and responsive across devices.

🔗 Check out the live project:

https://adithyan-phi.vercel.app/project/expense-tracker

Core Features

Expense Tracking

Add, edit, and delete expenses easily. Each transaction updates the dashboard in real time.

Dashboard & Analytics

View monthly spending breakdowns, recent transactions, and savings trends using charts powered by Recharts.

Budget Management

Set monthly budgets with optional 50/30/20 rule analysis (Needs, Wants, Savings).

Receive email alerts at 30%, 50%, 90%, and 100% of your budget usage.

Authentication & Security

Two-step email OTP verification for secure sign-up
JWT-based authentication for protected routes and sessions
Rich, dark-themed HTML email notifications for budget thresholds

PWA Support

Installable on mobile and desktop
Offline caching for dashboard access
Light, dark, and custom themes for user preference

AI Financial Coach — The Unique Twist

The standout feature of this project is the AI-powered financial assistant.

Built with LLaMA 3.3 and the Groq SDK, the AI allows users to ask questions such as:

“How am I spending on food this month?”
“What are some tips to save more?”

The AI analyzes real user data to:

Detect unusual spending patterns
Identify recurring subscriptions
Provide actionable savings advice
Localize insights strictly to Indian Rupees (₹)
Auto-categorize expenses to reduce manual input

Tech Stack

Frontend

React.js
Vite
VitePWA
Recharts
Framer Motion

Backend

Node.js
Express.js
MongoDB
Mongoose
JWT
Nodemailer

AI / ML

Groq SDK
LLaMA 3.3

Challenges & Learnings

Designing scalable data models for expenses and budgets
Implementing secure OTP and JWT-based authentication
Ensuring AI responses were accurate, contextual, and localized
Optimizing performance for dashboards and charts
Supporting offline functionality without breaking UX

Final Thoughts

Building this AI-Powered Expense Tracker helped me level up my full-stack development skills, explore PWA capabilities, and integrate AI into a real-world application.

If you’re learning the MERN stack, I strongly recommend building projects that go beyond basic CRUD—solve real problems, experiment with new technologies, and focus on user experience.

Feel free to check out the live app and source code, and reach out if you have questions or feedback.

Forem: Adithyan G

Bulk Applicant Dispatcher — A Privacy-First MERN Stack Application for Smart Job Hunting

💡 The Problem

🔐 Core Philosophy: Privacy First

✨ Key Features

🧠 Smart Cooldown Mechanism (15 Days)

Cooldown Logic Example

Editable Plain-Text Templates

Built-In Contact Manager

Dashboard & Application Tracking

Force Sending Override

Technology Stack

Frontend

MongoDB & Mongoose

Important: Gmail App Password

Usage Flow

What This Project Demonstrates

Responsible Usage Notice

Clowbot AI Complete Guide: Setup, Installation, Security Risks & Best Practices

Introduction to Clowbot AI

System Requirements

Minimum PC Requirements

Installation Guide (All Platforms)

1. Web-Based Installation (Recommended)

Steps:

2. Windows Installation

Browser-Based

Desktop Client (If Provided)

3. macOS Installation

Browser-Based

Desktop App (If Available)

4. Linux Installation

How to Set Up Clowbot AI

Step 1: Create an Account

Step 2: Create a New Bot

Step 3: Configure Basic Settings

Step 4: Build Conversation Flows

Step 5: Train the AI

Step 6: Integrate with Your Website

Step 7: Test Before Going Live

Step 8: Monitor & Optimize

Security Concerns & Industry Risks

Reported Technical Risks (OpenClaw / Related Projects)

Log-Poisoning

Prompt Injection

Scam & Token Misuse Risks

AI Trading & Automation Risks

Important Disclaimer

Understanding Git and GitHub as a Beginner

What Is Git?

What Is GitHub?

Repository (Repo)

Basic Git Workflow (Beginner-Friendly)

git init – Start Tracking a Project

git status – Check What’s Going On

git add – Stage Changes

git commit – Save Changes

Connecting Git to GitHub

git push – Send Code to GitHub

git pull – Get Updates from GitHub

Branches (Very Simple Explanation)

Why Git and GitHub Matter

Final Thoughts

Will AI Replace Web Developers? Or Are We Entering the Era of Vibe Coding?

🤖 What Is Vibe Coding?

❌ Why AI Won’t Replace Web Developers

1️⃣ AI Doesn’t Understand Business Context

2️⃣ AI Can Write Code, But Not Systems

3️⃣ Someone Has to Verify the Code

✅ How AI Is Actually Helping Developers

🔥 Real Benefits

🚀 The New Role of a Web Developer

🧠 Skills That Matter More Than Ever

⚠️ Who Is at Risk?

🧩 Final Verdict

💬 What Do You Think?

What Building One Real Project Taught Me More Than 5 Tutorials

Tutorials Give You Confidence. Projects Take It Away.

I Finally Understood Why Code Is Written the Way It Is

Debugging Became a Skill, Not a Panic Reaction

`git init` – Start Tracking a Project

`git status` – Check What’s Going On

`git add` – Stage Changes

`git commit` – Save Changes

`git push` – Send Code to GitHub

`git pull` – Get Updates from GitHub