DEV Community: Kashyap Patel

ArthLedger — Smart Accounting. Stronger Businesses.

Kashyap Patel — Fri, 16 Oct 2026 19:01:08 +0000

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

ArthLedger — Smart Accounting. Stronger Businesses.

A private, local-first AI accounting and business management platform designed for Indian freelancers, independent professionals, local retail shops, wholesalers, and small businesses.

What I Built

ArthLedger (from the Sanskrit Arth, meaning wealth, purpose, and finance) is a full-featured, local-first web application that bridges the gap between traditional double-entry bookkeeping and local artificial intelligence.

The Problem It Solves

Small business owners and freelancers face three major problems with existing accounting software:

Predatory Recurring Subscriptions: Cloud SaaS platforms (QuickBooks, Zoho, FreshBooks) charge escalating monthly fees that disproportionately hurt early-stage side hustles, local merchants, and independent consultants.
Financial Privacy & Data Exposure: Most "AI-powered" accounting tools silently transmit bank statements, vendor receipts, customer lists, and proprietary revenue numbers to third-party cloud AI APIs.
Flawed Multi-Currency Support: Many tools either lack genuine multi-currency support, use inaccurate binary floating-point calculations, or silently overwrite historical transactions when exchange rates fluctuate.

Who Would Pay For It?

Indian Freelancers & Remote Contractors: Exporting software, design, or writing services to global clients in USD, EUR, or GBP while filing taxes in INR.
Local Retailers & Shop Owners: Managing physical inventory, tracking low-stock thresholds, and recording domestic GST invoices with lakh/crore Indian number formatting.
Independent Consultants & Agencies: Wanting an automated receipt scanner and intelligent assistant that runs 100% on their own laptop, without an internet dependency or ongoing API bills.

Key Capabilities

Genuine Multi-Currency Engine: Built on Python's exact Decimal arithmetic (no float rounding errors), with an ISO 4217 registry (INR, USD, EUR, GBP, AED, CAD, JPY with 0 decimals, etc.), manual exchange-rate history, and cross-currency settlement.
Local AI Document Scanner: Extracts structured JSON (merchant, document number, date, currency, line items, tax, total) from receipts and invoices locally using PyPDF and Ollama.
Human-in-the-Loop Verification: Extracted data is presented in an editable review screen; no financial record is ever saved automatically without explicit user confirmation.
Conversational Accounting Assistant: Answers natural language questions ("What were my largest expenses this month?", "Which invoices are still unpaid?", "Compare this month's sales with last month") by executing controlled, validated SQLite queries rather than letting AI execute arbitrary SQL.
Professional PDF Generation: Generates clean, print-ready A4 Tax Invoices and Monthly Financial Performance Reports with bank details, terms, and authorized signature boxes using ReportLab.
100% Offline Usability: If the AI model or internet is unavailable, every accounting workflow—invoicing, expenses, inventory, reports, and CSV exports—remains completely functional.

Demo

Web Application Interface

Dashboard: Real-time KPI cards (Invoiced Sales, Money Received, Outstanding Receivables, Total Expenses, Net Margin), monthly cash inflow vs expense SVG chart, pending invoice alerts, and recent transactions ledger.
Sales & Invoices: Interactive line-item editor with auto-calculating quantities, unit prices, discounts, GST/VAT rates, status lifecycle (DRAFT, ISSUED, PARTIALLY_PAID, PAID, OVERDUE, CANCELLED), and one-click PDF generation.
Purchases & Expenses: Category-based expense tracking, receipt attachment previews, and CSV exports.
Customer & Supplier Portals: Real-time calculated balances derived strictly from actual invoices, payments, and expenses, with safe archiving to protect financial history.
Inventory Management: Product catalog with SKU tracking, stock adjustments, low-stock reorder alerts, and inventory valuation.
AI Assistant: Local chat interface with instant query chips, connection status indicators, and deterministic fallbacks.

Running the Demo Locally

# Clone the repository
git clone https://github.com/Kashyap-Patel115/ArthLedger-Local-AI-Accounting.git
cd arthledger

# Install lightweight dependencies
pip install flask reportlab pypdf pytest requests

# Launch ArthLedger
python app.py

Open http://127.0.0.1:5000 in any modern browser.

Demo Video link:https://drive.google.com/file/d/129opE3qH3_B9pQ9SaElSag3a_fKFgV04/view?usp=sharing

Code

My github Repository Link:https://github.com/Kashyap-Patel115/ArthLedger-Local-AI-Accounting.git

The code is designed to be modular, readable, beginner-friendly, and free of heavy front-end build pipelines or proprietary dependencies.

ArthLedger/
├── app.py                     # Flask application factory & context processors
├── config.py                  # Local directory paths, database, & upload safety rules
├── database.py                # SQLite schema, WAL mode, migrations, & audit trail
├── currency.py                # ISO 4217 registry, Decimal financial math, Indian number formatting
├── accounting.py              # Invoicing rules, payment allocation, KPIs, & stock movements
├── pdf_extractor.py           # Local text extraction (pypdf) & path traversal prevention
├── pdf_generator.py           # ReportLab professional PDF generation (A4 Invoices & Reports)
├── ai_service.py              # Ollama local HTTP client, JSON schema extraction, & controlled queries
├── reset_db.py                # Utility to cleanly zero all financial records
├── routes/                    # Clean modular Flask Blueprints
│   ├── dashboard.py           # KPIs and chart endpoints
│   ├── invoices.py            # Invoice creation, status updates, & payments
│   ├── expenses.py            # Expense recording, categorization, & CSV export
│   ├── contacts.py            # Customers and suppliers management
│   ├── inventory.py           # Stock movements and low-stock alerts
│   ├── transactions.py        # Unified ledger view
│   ├── documents.py           # Upload, local extraction, and review/confirm flow
│   ├── ai_assistant.py        # Conversational assistant endpoints
│   ├── reports.py             # Profit & Loss, Cash Flow, Multi-Currency position
│   └── settings.py            # Business details, exchange rates registry, & AI setup
├── static/
│   ├── css/styles.css         # Forest green & warm neutral responsive design system
│   └── js/
│       ├── app.js             # Sidebar toggle, modals, and toast alerts
│       ├── invoices.js        # Dynamic invoice line calculations
│       ├── charts.js          # Zero-dependency responsive SVG bar chart
│       └── ai_assistant.js    # Chat interface with suggestion chips
├── templates/                 # Accessible, semantic Jinja2 templates
└── tests/                     # 26 automated unit and integration tests (100% pass)
    ├── conftest.py
    ├── test_accounting.py
    ├── test_currency.py
    ├── test_invoices.py
    ├── test_inventory.py
    ├── test_documents.py
    ├── test_ai_service.py
    ├── test_pdf_and_exports.py
    └── test_persistence.py

Automated Test Suite

ArthLedger comes with a 26-test automated suite covering financial calculations, security, and offline resilience:

python -m pytest -v

============================= 26 passed in 27.04s =============================

How I Built It

1. Technology Stack

Backend: Python 3.12 with Flask.
Database: SQLite with Write-Ahead Logging (WAL), strict foreign keys (PRAGMA foreign_keys = ON), parameterized queries, and an immutable audit trail.
Frontend: Vanilla HTML5, CSS3, and Vanilla JavaScript. No React, Next.js, or complex bundlers.
Visual Design: Forest green (#1b4332, #2d6a4f) and emerald accents paired with warm neutral backgrounds (#f9f8f5) and crisp charcoal typography.
Document Processing: pypdf for local offline text extraction; reportlab for generating A4 Tax Invoices and Financial Reports.
Financial Arithmetic: Python Decimal with ROUND_HALF_UP precision to prevent binary floating-point discrepancies.

2. Local Open-Source AI Architecture

Model: Evaluated and tested with smollm2:latest (1.7B parameters, Q8_0, Apache 2.0 license by Hugging Face) and qwen2.5:1.5b.
Inference: Communicates locally via Ollama's HTTP API (http://127.0.0.1:11434/api/generate).
Prompt Isolation & Security: Uploaded document text is treated strictly as untrusted user data enclosed in delimited text blocks, preventing prompt injection.
Controlled Assistant Queries: The AI model is never permitted to execute arbitrary SQL or directly mutate the database. Instead, user queries are routed through controlled, validated Python functions that pull verified data from SQLite, perform calculations with Decimal, and ask the model to explain the results in clear business terms.
Graceful Offline Fallback: If Ollama is not installed or offline, the application automatically falls back to deterministic structured summaries and manual document entry without crashing or hanging.

Why Does Open Innovation Matter?

Financial Privacy & Data Sovereignty: Small businesses handle sensitive data: supplier pricing, client billing, personal phone numbers, and profit margins. Open innovation allows small businesses to deploy AI locally on their own hardware, ensuring their data is never harvested to train closed commercial models.
True Affordability: Closed AI APIs charge on a per-token basis. For a small Indian retailer or freelance consultant, unpredictable API bills make AI inaccessible. Small open-weight models (smollm2, qwen2.5) democratize intelligent software by running free of charge on everyday consumer PCs.
No Vendor Lock-In: Standardized local inference means the application is not married to any single proprietary provider. If a faster or more capable open-weight model is released, users can change the model name in Settings with zero code changes.
Offline Resilience: In developing markets and regional hubs, internet connectivity can be intermittent. Open, self-contained software ensures that core accounting, invoicing, and inventory tracking never grind to a halt when the network drops.

My Agent Session

As a second-year IT engineering student, I built ArthLedger through pair programming with Google DeepMind's Antigravity AI Agent.

The project was constructed across 8 structured milestones:

Foundation & Environment Verification: Inspected the workspace, verified Python 3.12 and Ollama, and configured an isolated database architecture.
Core Accounting Logic: Implemented currency.py and accounting.py using Decimal arithmetic, avoiding floating-point rounding pitfalls and supporting Indian number grouping (12,34,567.89).
Multi-Currency System: Constructed an ISO 4217 currency registry and exchange-rate tracking table that preserves historical conversion rates across invoice creation and cross-currency payments.
Professional UI System: Designed a forest green aesthetic with a collapsible sidebar, modal dialogs, status badges, and an SVG comparison chart.
Document Processing & ReportLab PDFs: Integrated pypdf for text extraction and built A4 Tax Invoices and Financial Performance PDF generators.
Local AI Integration & Fallback: Connected Ollama for structured receipt parsing, added an editable review screen with Human-in-the-Loop confirmation, and built controlled query handlers for the conversational assistant.
Inventory & Ledger Reporting: Implemented stock movements, reorder alerts, inventory valuation, cash flow statements, and accounts receivable aging schedules.
Automated Testing & Data Zeroing: Authored 26 automated pytest tests verifying every financial rule, path traversal protection, and persistence across reconnects, concluding with a clean zeroed database ready for real-world use.

My First User

My first user is my maternal uncle, who runs a shop and manages its daily transactions. I shared an early build of ArthLedger with him to help simplify his shop's financial record-keeping.

The Challenge: He was managing his shop's daily sales, purchases, and other transactions manually, making it difficult to maintain organized financial records and track his business income and expenses efficiently. He needed a simple, reliable, and affordable solution to manage his shop's transactions in one place.
Their Feedback:

"ArthLedger makes it easier for me to record my shop's daily transactions and keep track of my income and expenses. Having all my financial records organized in one place saves time and makes managing my shop's accounts much simpler."

- Outcome: My maternal uncle started using ArthLedger to record and manage his shop's transactions. His experience as my first user helped me understand the practical needs of small shop owners and identify ways to make ArthLedger more useful, simple, and accessible for everyday business accounting.

Future Development

This is my first time developing and managing a project of this scale, and I have worked on ArthLedger within a limited time frame. Although the current version includes the core features, I understand that there is still room for improvement. As a student, I also need to balance my project work with my academic responsibilities.

ArthLedger is an ongoing project, not the final version. Whenever I get more time, I will continue improving the software, fixing bugs, adding useful features, and making it more reliable and user-friendly based on real-world feedback. My goal is to keep learning through this project and gradually develop ArthLedger into a more complete accounting solution for small businesses.

Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle
Local AI & Edge Computing
Privacy-First & Open-Source Developer Tools

Smart Accounting. Stronger Businesses. • Built with ❤️ for open-source innovation during Hacktoberfest 2026.

PlantPal AI Assistant

Kashyap Patel — Sun, 11 Oct 2026 08:27:28 +0000

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

🌱 PlantPal — AI Gardening Assistant

A local, privacy-first web companion that turns screen fatigue into mindful indoor gardening, powered by the open-weight SmolLM2 360M model and daily "Touch Grass" habits.

What I Built

The Screen-Fatigue & "Touch Grass" Problem

Developers, students, and tech professionals spend 8 to 14 hours every day glued to glowing screens—writing code, debugging, and scrolling through digital noise. To bring a breath of life into our desks and living rooms, many of us buy houseplants. But within a few weeks, those plants often wither and die due to overwatering, forgotten care routines, improper sunlight, or plain neglect.

When plant troubles arise, existing solutions either demand scrolling through ad-bloated generic search results or relying on expensive cloud AI chatbots that keep users tethered to their browsers.

PlantPal AI Assistant was built to solve this exact problem: it bridges local open-weight artificial intelligence with the physical, tactile world to pull people away from their keyboards and guide them into rewarding, mindful plant care.

How It Gets People Off the Screen and Into the World

PlantPal is intentionally designed so every digital interaction directly inspires a physical, real-world action:

🏆 Daily "Touch Grass" Challenges: A dedicated habits engine featuring 5 interactive physical activities that literally get users away from their monitors:
- Soil Moisture Finger Test: Encourages users to plunge an index finger 1–2 inches into the soil before watering to physically feel moisture levels.
- Foliage & Leaf Inspection: Step away from the desk to examine leaf undersides for dust or pests, and wipe them clean with a damp cloth.
- 10-Minute Outdoor Mindfulness: Step out onto a balcony, terrace, or garden to breathe fresh air and observe natural sunlight.
- Learn a Botanical Fact: Discover the native climate, humidity needs, and growth patterns of indoor species.
- Water Propagation Habit: Snip a stem cutting (from a money plant, pothos, or mint) and place it in a jar of water to sprout fresh roots. A live progress bar and completion tracker celebrate these offline moments.
💧 Smart Physical Watering Cycles: Dynamic date math calculates exact biological intervals, organizing plants into Overdue, Due Today, and Upcoming. Instead of abstract notifications, it prompts a physical check before hydrating, logging timestamps into a permanent SQLite history.
📋 Hands-on Care Task Checklist: Schedule and track physical maintenance like repotting, pruning dead leaves, applying organic fertilizer, or rotating pots 90° for balanced sun exposure.
📚 Curated Plant Library: Pre-configured botanical profiles for 7 indoor favorites (Money Plant, Snake Plant, Aloe Vera, Spider Plant, Peace Lily, Tulsi, and Areca Palm) with instant 1-click import into personal gardens.
🤖 Private AI Gardening Mentor: Powered by the open-weight SmolLM2 360M model running locally via Ollama. It answers urgent queries ("Why are my snake plant leaves yellow?", "How much sun does aloe vera need?") in 2–3 concise, encouraging sentences without creating digital rabbit holes.

Who Is It For?

Developers, Engineers & Students: Anyone experiencing digital burnout who needs a healthy, tactile excuse to step away from the desk and nurture living plants.
First-Time Plant Parents: Beginners who want clear, jargon-free watering schedules, lighting tips, and quick troubleshooting.
Privacy & Open-Source Advocates: Users who demand 100% data sovereignty and offline capability with zero telemetry, paywalls, or cloud dependencies.

Demo

PlantPal runs locally with a nature-inspired design system featuring deep forest green (#2D5A27), calming sage green (#5B8A61), warm organic cream (#FAF9F5), and crisp rounded cards.

Local URL

Once started, the application is accessible in any desktop or mobile browser at:

http://127.0.0.1:5000

Visual Walkthrough & Features

Live Garden Dashboard: Real-time metrics for total plants, urgent watering alerts, pending care tasks, rotating daily gardening wisdom, and a live Ollama connection status pill.
Plant Profiles & Observation Notes: Detailed records showing species, room location, sunlight requirements, watering intervals, and an interactive watering timeline.
Smart Watering Scheduler: Categorized views sorting plants into overdue, due today, and upcoming cycles with 1-click AJAX watering updates.
Interactive AI Assistant: Fast suggestion chips ("Why are leaves yellow?", "Best beginner plants", "Watering rule of thumb"), animated typing status, and transparent badges distinguishing live AI inferences from verified offline handbook tips.
Daily Habit Checklist: Visual progress bar and checkboxes that reward physical, real-world plant care.

Code

The complete source code is available in this repository:

🔗 GitHub Repository: https://github.com/Kashyap-Patel115/PlantPal-AI-Assistant

Project Directory Structure

PlantPal AI Assistant/
├── app.py                  # Main Flask application, routing, and REST endpoints
├── database.py             # SQLite schema, parameterized queries, and date math engine
├── plant_library.py        # Curated botanical data for 7 indoor plant species
├── ai_service.py           # Ollama SmolLM2 integration & transparent offline fallback
├── test_app.py             # Automated 12-point unit and integration test suite
├── requirements.txt        # Minimal Python dependencies (Flask, requests)
├── instance/               # Local SQLite database storage
├── templates/              # Semantic HTML5 templates with responsive sidebar
│   ├── base.html           # Master layout with drawer nav and toast alerts
│   ├── dashboard.html      # Overview metrics, alerts, and daily tip
│   ├── plants.html         # Plant collection with search and sunlight filter
│   ├── plant_form.html     # Add/edit plant form
│   ├── plant_detail.html   # Detailed plant profile and watering history
│   ├── scheduler.html      # Categorized watering schedule
│   ├── tasks.html          # Care tasks checklist and status filter
│   ├── library.html        # Plant library reference cards
│   ├── challenges.html     # Daily gardening habit challenges
│   ├── ai_assistant.html   # Interactive chat interface with prompt chips
│   ├── 404.html            # Custom 404 error page
│   └── 500.html            # Custom 500 error page
└── static/
    ├── css/
    │   └── style.css       # Nature-inspired responsive CSS design system
    └── js/
        └── app.js          # AJAX updates, mobile navigation, and chat logic

Quick Installation & Local Setup

Clone the repository:

   git clone https://github.com/Kashyap-Patel115/PlantPal-AI-Assistant.git
   cd "PlantPal AI Assistant"

Pull the open-weight SmolLM2 360M model via Ollama:

   ollama pull smollm2:360m

Install lightweight dependencies:

   pip install -r requirements.txt

Run the application:

   python app.py

Run the automated test suite:

   python test_app.py

How I Built It

1. Open-Weight AI Architecture

Model Choice: Hugging Face's SmolLM2 360M (smollm2:360m). At just ~725 MB, this ultra-compact open-weight model runs at lightning speed directly on consumer laptop CPUs without requiring dedicated GPUs or cloud APIs.
Inference Runtime: Ollama running locally on port 11434 (http://127.0.0.1:11434/api/generate), providing a clean, self-contained REST API.
Prompt Engineering & Guardrails: Tailored system instructions direct the model to answer concisely in 2 to 3 practical, friendly sentences. A low temperature (0.4) and tight top-p (0.9) ensure answers remain factual and grounded.
Transparent Offline Fallback Architecture: If Ollama is not installed or temporarily stopped, PlantPal gracefully matches keywords against a verified botanical knowledge handbook. It clearly labels the output source (smollm2:360m vs 🌿 Offline Gardening Guide Fallback) and never masquerades canned answers as live AI.

2. Backend & Database

Framework: Python 3.12 with Flask 3.1. Kept clean, modular, and beginner-friendly without unnecessary microservice overhead.
Storage: SQLite 3 with parameterized queries and foreign-key cascade protection, managing tables for plants, watering_history, tasks, and challenges.
Date Math Engine: Custom datetime algorithms compute overdue days, due-today flags, and upcoming watering cycles based on actual biological intervals.

3. Frontend & Interactions

Vanilla Modern Web: HTML5, CSS3, and vanilla JavaScript.
Zero Build Step Bloat: Eliminates heavy Node/Webpack build steps, resulting in near-instant page load times and zero dependency rot.
Asynchronous AJAX: Dynamic watering updates, task completion toggles, challenge tracking, and AI chat run smoothly without disruptive full-page reloads.

Why Does Open Innovation Matter?

Open innovation is the core foundation of PlantPal's design and mission:

Zero Economic Barriers for Students and Global Learners:
Proprietary APIs (such as OpenAI GPT-4o or Anthropic Claude) lock intelligence behind credit card requirements, recurring subscriptions, and per-token pricing. For students, teenagers, and makers worldwide, these economic paywalls prevent everyday adoption. Open-weight models like SmolLM2 liberate AI, enabling anyone with a standard computer to build, learn, and experiment completely free of charge.
Absolute Privacy in Domestic & Living Spaces:
Gardening and personal living spaces are intimate. When users ask questions about their home environment, room lighting, and daily routines, that data shouldn't be funneled to corporate servers for ad targeting or model training. With open-weight AI running locally via Ollama, 100% of data stays on the user's hard drive.
Resilience in Low-Connectivity & Outdoor Environments:
Plants grow on balconies, in greenhouses, on rooftops, and in rural gardens where internet connections are spotty or non-existent. A system tethered to closed cloud APIs breaks the second connection drops. Local open-weight models ensure that essential gardening assistance remains accessible anytime, anywhere, off-grid.
Demystifying AI for Emerging Engineers:
As a second-year engineering student, open innovation turns AI from an intimidating black box into an open, inspectable technology. I can examine model weights, inspect inference parameters, tune prompts, and understand resource utilization directly. Open innovation creates creators, not just passive consumers.

My Agent Session

This project was developed and refined using Antigravity IDE through an iterative agentic pair-programming workflow:

Agent Trajectory & Development: The database schema, backend routing, Ollama integration, frontend templates, and test matrices were developed collaboratively with automated validation loops.
Automated Verification: A 12-point automated test suite (test_app.py) validates empty-database states, CRUD operations, watering date math, task toggles, library imports, Ollama connectivity, and offline fallback resilience.
Reproducibility: You can verify the entire test matrix locally in seconds by running python test_app.py.

Prize Categories

🌿 Touch Grass (Week 1 Primary Category): Using AI to reconnect users with the physical world, build healthy tactile habits (soil moisture testing, leaf care, outdoor time), and nurture living houseplants.
⚡ Best Use of Open-Source / Open-Weight AI: Running Hugging Face's open-weight SmolLM2 360M locally via Ollama with custom prompt tuning, transparent provenance tags, and an offline handbook fallback.
💻 Best Student / First-Time Open-Source Submission: Built with clean, accessible, well-documented code by a second-year Information Technology engineering student.

👨‍💻 Author & Credits

Author: Kashyap Patel
DEV Profile / GitHub: @Kashyap-Patel115
Role: Second-year IT engineering student & open-source builder

Happy Gardening, and don't forget to touch grass today! 🌿

Daily Expense Tracker

Kashyap Patel — Sat, 03 Oct 2026 19:54:43 +0000

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

💰 Daily Expense Tracker — Built for My College Roommate

What I Built

I built Daily Expense Tracker, a sleek, zero-friction web application designed to help college students easily track their day-to-day spending in Indian Rupees (₹) without dealing with bloated apps, sign-in walls, or intrusive ads.

Who I Built It For & The Problem It Solves

As a second-year IT engineering student, moving into a college hostel comes with a sudden shock: budgeting.

My roommate and close friend, Kaushal, constantly struggled with his monthly allowance. Between canteen snacks, semester reference books, lab prints, and daily bus passes, he would find his wallet empty by the third week of every month, having no idea where all his money went.

Most existing budgeting apps are overcomplicated: they demand phone numbers, require bank account linking, bombard you with credit card offers, or don't work offline.

I built this app specifically for Kaushal so he could:

Log expenses in under 5 seconds right from his phone or laptop browser.
Classify spending across student-essential categories: Food, Travel, Shopping, Education, and Other.
See his total expenses update in real time with a live transaction counter.
Enjoy 100% privacy — all data stays strictly on his device using browser localStorage with zero server tracking.

Demo

Live Demo Link: https://kashyap-patel115.github.io/Expense-Tracker/
Offline / Local Run: Simply open index.html in any browser — no web server or npm required!

✨ Key Interface Highlights

Hero Overview Card: High-contrast emerald green gradient displaying the live total spent (₹), transaction count, and current date.
Modern Inputs with SVG Icons: Clean input fields for Expense Name, Amount in Rupees, Category picker, and Date picker.
Category Pill Badges: Dynamic color-coded indicator dots (● Food, ● Travel, ● Education, ● Shopping, ● Other).
Real-time Feedback: Slide-down error validation banners and floating toast alerts for additions and deletions.
Friendly Empty State: Clean vector illustration greeting new users when no expenses are logged.

Code

The entire project is open-source and intentionally lightweight:

GitHub Repository: https://github.com/Kashyap-Patel115/Expense-Tracker

Project Architecture

Expense tracker/
│
├── index.html     # Semantic HTML5 with accessible form & data table
├── style.css      # Vanilla CSS3 with custom properties, CSS Grid & Flexbox
├── script.js      # Clean Vanilla JS (ES6) state management & LocalStorage
├── README.md      # Comprehensive open-source onboarding guide

How I Built It

To build this app quickly and cleanly without drowning in framework overhead, I used an agentic pair-programming workflow powered by Google Antigravity IDE:

Architecture & Constraints First:
- Constrained the stack strictly to pure HTML5, CSS3, and Vanilla JavaScript to keep it accessible for first-year engineering students and first-time open-source contributors.
- Leveraged the browser's native Web Storage API (localStorage) to eliminate server dependencies, cloud bills, and latency.
Fintech Design Iteration:
- Used modern typography pairings via Google Fonts: Plus Jakarta Sans for crisp UI reading and Outfit for bold, readable financial figures.
- Engineered a curated emerald green color palette (#065f46 to #10b981) that evokes financial wellness and clarity.
- Built responsive layouts using CSS Grid and Flexbox with media queries tailored down to 360px mobile screens.
Defensive Logic & Edge Cases:
- Built input sanitation preventing negative amounts, ₹0 entries, or blank descriptions.
- Added Indian numbering currency formatting (en-IN) so large student expenses (e.g. semester fees or tech gear) format cleanly as ₹1,250.00.

Why Does Open Innovation Matter?

Open innovation is what made the web accessible to everyone in the first place, and it matters deeply for tools like this:

Financial Privacy by Design:
Closed financial apps monetize student data by selling spending habits to lenders, credit card companies, and advertisers. Because this project is built on open standards and client-side storage, Aarav's personal data never leaves his browser.
Hackability for Fellow Students:
Because there are no obscure build tools (npm, webpack, vite), any first-year IT student can fork this repo, inspect the code, tweak the categories to fit their campus (e.g., adding "Hostel Mess" or "Tech Fest"), and learn how DOM manipulation works under the hood.
Longevity & Independence:
Closed APIs get deprecated, monetized, or shut down. An open-source, standard-compliant HTML/CSS/JS application will continue working in any browser 10 years from now without breaking.

My Agent Session

This project was developed through an interactive human-in-the-loop pair programming session using the Antigravity IDE:

Refined form requirements and accessibility guidelines.
Iterated on fintech UI aesthetics (converting a basic table into a modern dashboard with ambient glows, icon wrappers, and category pills).
Audited input validation and LocalStorage serialization.

Prize Categories

Build for a Friend (Primary Category — Built for my hostel roommate Kaushal to conquer second year college budgeting)
Most Impactful Open-Source Beginner Project

Thank you to the DEV Community and the Hacktoberfest team for fostering open-source innovation!