DEV Community: Archit Mittal

Build a Desktop File Organizer in 35 Lines of Python — Weekend Project

Archit Mittal — Sat, 11 Apr 2026 04:50:20 +0000

Your Downloads folder is a mess. Mine was too — 400+ files, zero organization. So I spent a Saturday afternoon writing a Python script that watches a folder and auto-sorts files into subfolders by type. 35 lines, no external libraries beyond watchdog, runs forever in the background.

Here's the full weekend project. You'll have it running in under 30 minutes.

Why Build This?

Every developer I know has a chaotic Downloads folder. PDFs from 2019 sitting next to screenshots from yesterday. You could manually sort them — or you could automate it once and never think about it again.

This project teaches you:

File system operations with os and shutil
The watchdog library for real-time file monitoring
How to build a script that runs as a background service

The Code

First, install the only dependency:

pip install watchdog

Now here's the complete script — file_organizer.py:

import os
import shutil
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

# Configure your folder path and file type mappings
WATCH_DIR = os.path.expanduser("~/Downloads")

FILE_TYPES = {
    "Images": [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"],
    "Documents": [".pdf", ".docx", ".xlsx", ".pptx", ".txt", ".csv"],
    "Videos": [".mp4", ".mkv", ".avi", ".mov"],
    "Audio": [".mp3", ".wav", ".flac", ".aac"],
    "Archives": [".zip", ".rar", ".tar", ".gz", ".7z"],
    "Code": [".py", ".js", ".html", ".css", ".json", ".sql"],
    "Installers": [".dmg", ".exe", ".msi", ".deb", ".pkg"],
}

def get_destination(filename):
    ext = os.path.splitext(filename)[1].lower()
    for folder, extensions in FILE_TYPES.items():
        if ext in extensions:
            return folder
    return "Other"

class SortHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.is_directory:
            return
        time.sleep(1)  # wait for download to finish
        filename = os.path.basename(event.src_path)
        dest_folder = get_destination(filename)
        dest_path = os.path.join(WATCH_DIR, dest_folder)
        os.makedirs(dest_path, exist_ok=True)
        try:
            shutil.move(event.src_path, os.path.join(dest_path, filename))
            print(f"Moved: {filename} -> {dest_folder}/")
        except Exception as e:
            print(f"Error moving {filename}: {e}")

if __name__ == "__main__":
    observer = Observer()
    observer.schedule(SortHandler(), WATCH_DIR, recursive=False)
    observer.start()
    print(f"Watching {WATCH_DIR} for new files...")
    try:
        while True:
            time.sleep(10)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

How It Works

The mapping dictionary (FILE_TYPES) maps folder names to file extensions. When a new file arrives, the script checks its extension and picks the right folder.

get_destination() loops through your mappings and returns the folder name. If the extension doesn't match anything, it goes to "Other" — nothing gets lost.

SortHandler extends watchdog's FileSystemEventHandler. The on_created method fires every time a new file appears. The 1-second sleep is important — it prevents the script from moving a file that's still downloading.

The main block creates an Observer that watches your Downloads folder. It runs in an infinite loop until you press Ctrl+C.

Make It Your Own

Here are 5 ways to extend this project:

1. Add date-based subfolders:

from datetime import datetime

def get_date_folder():
    return datetime.now().strftime("%Y-%m")
# Creates folders like "Documents/2026-04/"

2. Handle duplicate filenames:

def safe_move(src, dest_dir, filename):
    dest = os.path.join(dest_dir, filename)
    base, ext = os.path.splitext(filename)
    counter = 1
    while os.path.exists(dest):
        dest = os.path.join(dest_dir, f"{base}_{counter}{ext}")
        counter += 1
    shutil.move(src, dest)

3. Add desktop notifications (macOS):

import subprocess
def notify(title, message):
    subprocess.run(["osascript", "-e",
        f'display notification "{message}" with title "{title}"'])

4. Log everything to a file:

import logging
logging.basicConfig(filename="organizer.log", level=logging.INFO)
logging.info(f"Moved: {filename} -> {dest_folder}/")

5. Run it on startup — Add it to your crontab:

# crontab -e
@reboot python3 /path/to/file_organizer.py &

Real Numbers From My Setup

I've been running this on my machine for 3 months:

1,200+ files auto-sorted without lifting a finger
Downloads folder went from 400 files to 7 organized subfolders
Time saved: roughly 15 minutes per week of manual sorting
At a modest consulting rate of ₹1,500/hr, that's ₹6,000/month in recovered time

The Bigger Lesson

This is a 30-minute project, but it teaches you a pattern that scales. The same watchdog + handler architecture works for:

Auto-uploading invoices to Google Drive
Parsing incoming CSVs and loading them into a database
Monitoring log files for error patterns
Triggering alerts when specific files land in a shared folder

Start small. Automate one annoying thing this weekend. Then next weekend, automate another.

Run It Now

pip install watchdog
# Save the script above as file_organizer.py
python file_organizer.py

Or just copy-paste the script above. It works out of the box.

I'm Archit Mittal — I automate chaos for businesses. Follow me for daily automation content.

How I Built an Automated WhatsApp Invoice System for My Client in 3 Hours

Archit Mittal — Thu, 09 Apr 2026 04:46:34 +0000

Last week, a CA firm in Jaipur reached out to me with a painfully familiar problem: their accountant was manually creating invoices in Excel, converting them to PDF, and sending them on WhatsApp — one by one — to 200+ clients every month.

Time spent? About 3 full working days. Every. Single. Month.

I built them an automated system in 3 hours flat. Here's exactly how.

The Problem

The firm's workflow looked like this:

Open Excel template
Fill in client name, GSTIN, amounts, due dates
Save as PDF
Open WhatsApp Web
Search for the client
Attach PDF, type a message, hit send
Repeat 200 times

The accountant was burning ~24 hours/month on this. At ₹300/hour, that's ₹7,200/month — or ₹86,400/year — just on invoice delivery.

The Solution: Python + WhatsApp Business API

I broke the automation into 3 parts:

Invoice generation from a Google Sheet
PDF creation using a template
WhatsApp delivery via the Business API

Part 1: Pull Data from Google Sheets

First, I set up a Google Sheet as the single source of truth. The accountant just fills in the data — the script does the rest.

import gspread
from google.oauth2.service_account import Credentials

SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly']
creds = Credentials.from_service_account_file('creds.json', scopes=SCOPES)
client = gspread.authorize(creds)

sheet = client.open("Monthly_Invoices").worksheet("April2026")
records = sheet.get_all_records()

# Each record has: client_name, gstin, amount, due_date, phone
print(f"Found {len(records)} invoices to process")

This gives us a clean list of dictionaries — one per client.

Part 2: Generate PDF Invoices

I used reportlab for PDF generation. The firm wanted their letterhead, so I created a reusable template.

from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
from datetime import datetime
import os

def generate_invoice(data, output_dir="invoices"):
    os.makedirs(output_dir, exist_ok=True)

    filename = f"{output_dir}/{data['client_name']}_{datetime.now().strftime('%B_%Y')}.pdf"
    c = canvas.Canvas(filename, pagesize=A4)
    width, height = A4

    # Header
    c.setFont("Helvetica-Bold", 18)
    c.drawString(1*inch, height - 1*inch, "TAX INVOICE")

    # Firm details
    c.setFont("Helvetica", 10)
    c.drawString(1*inch, height - 1.5*inch, "Sharma & Associates, Chartered Accountants")
    c.drawString(1*inch, height - 1.7*inch, "GSTIN: 08AXXXX1234X1Z5")

    # Client details
    c.setFont("Helvetica-Bold", 11)
    c.drawString(1*inch, height - 2.5*inch, f"Bill To: {data['client_name']}")
    c.setFont("Helvetica", 10)
    c.drawString(1*inch, height - 2.8*inch, f"GSTIN: {data['gstin']}")

    # Invoice details
    inv_number = f"INV-{datetime.now().strftime('%Y%m')}-{data['client_name'][:3].upper()}"
    c.drawString(4.5*inch, height - 2.5*inch, f"Invoice #: {inv_number}")
    c.drawString(4.5*inch, height - 2.8*inch, f"Date: {datetime.now().strftime('%d-%m-%Y')}")
    c.drawString(4.5*inch, height - 3.1*inch, f"Due Date: {data['due_date']}")

    # Amount table
    amount = float(data['amount'])
    gst = amount * 0.18
    total = amount + gst

    y_pos = height - 4*inch
    c.setFont("Helvetica-Bold", 10)
    c.drawString(1*inch, y_pos, "Description")
    c.drawString(5*inch, y_pos, "Amount (₹)")

    c.setFont("Helvetica", 10)
    c.drawString(1*inch, y_pos - 0.4*inch, "Professional Services")
    c.drawString(5*inch, y_pos - 0.4*inch, f"{amount:,.2f}")
    c.drawString(1*inch, y_pos - 0.7*inch, "GST @ 18%")
    c.drawString(5*inch, y_pos - 0.7*inch, f"{gst:,.2f}")

    c.setFont("Helvetica-Bold", 12)
    c.drawString(1*inch, y_pos - 1.2*inch, "TOTAL")
    c.drawString(5*inch, y_pos - 1.2*inch, f"₹{total:,.2f}")

    # Bank details
    c.setFont("Helvetica", 9)
    c.drawString(1*inch, 2*inch, "Bank: HDFC Bank | A/C: XXXX1234 | IFSC: HDFC0001234")

    c.save()
    return filename

# Generate all invoices
invoice_files = {}
for record in records:
    path = generate_invoice(record)
    invoice_files[record['phone']] = {
        'path': path,
        'name': record['client_name'],
        'amount': record['amount']
    }
    print(f"Generated invoice for {record['client_name']}")

Part 3: Send via WhatsApp Business API

This is where the magic happens. I used the WhatsApp Business API (via a BSP provider — costs about ₹0.50 per message in India).

import requests
import time

WHATSAPP_TOKEN = "your_access_token"
PHONE_NUMBER_ID = "your_phone_number_id"

def upload_media(file_path):
    """Upload PDF to WhatsApp media endpoint"""
    url = f"https://graph.facebook.com/v18.0/{PHONE_NUMBER_ID}/media"
    headers = {"Authorization": f"Bearer {WHATSAPP_TOKEN}"}

    with open(file_path, 'rb') as f:
        files = {'file': (file_path, f, 'application/pdf')}
        data = {'messaging_product': 'whatsapp'}
        response = requests.post(url, headers=headers, files=files, data=data)

    return response.json().get('id')

def send_invoice(phone, media_id, client_name, amount):
    """Send invoice PDF with a message via WhatsApp"""
    url = f"https://graph.facebook.com/v18.0/{PHONE_NUMBER_ID}/messages"
    headers = {
        "Authorization": f"Bearer {WHATSAPP_TOKEN}",
        "Content-Type": "application/json"
    }

    payload = {
        "messaging_product": "whatsapp",
        "to": f"91{phone}",
        "type": "document",
        "document": {
            "id": media_id,
            "filename": f"Invoice_{client_name}.pdf",
            "caption": (
                f"Hello {client_name},\n\n"
                f"Please find attached your invoice for the amount "
                f"of Rs.{float(amount):,.2f} (inclusive of GST).\n\n"
                f"Kindly process the payment by the due date.\n\n"
                f"Regards,\nSharma & Associates"
            )
        }
    }

    response = requests.post(url, headers=headers, json=payload)
    return response.json()

# Send all invoices
sent_count = 0
failed = []

for phone, info in invoice_files.items():
    try:
        media_id = upload_media(info['path'])
        result = send_invoice(phone, media_id, info['name'], info['amount'])

        if 'messages' in result:
            sent_count += 1
            print(f"Sent to {info['name']} ({phone})")
        else:
            failed.append(info['name'])
            print(f"Failed for {info['name']}: {result}")

        time.sleep(1)  # Rate limiting

    except Exception as e:
        failed.append(info['name'])
        print(f"Error for {info['name']}: {e}")

print(f"\nDone! Sent: {sent_count} | Failed: {len(failed)}")
if failed:
    print(f"Failed clients: {', '.join(failed)}")

Putting It All Together

I wrapped everything in a single run.py script with logging and error handling. The accountant now:

Updates the Google Sheet with this month's data
Runs python run.py (or I set up a cron job for the 1st of every month)
Gets a summary in the terminal showing what was sent

Total execution time for 200 invoices: under 8 minutes.

The Numbers

Metric	Before	After
Time per month	~24 hours	~8 minutes
Cost per month	₹7,200 (labor)	₹100 (API costs)
Errors (wrong client)	2-3/month	0
Client complaints	Frequent delays	Same-day delivery

Annual savings: ₹85,200 in labor + eliminated errors.

The firm paid me ₹15,000 for this build — ROI in less than 2 months.

Key Lessons

Start with the spreadsheet. Every automation project I take on starts with understanding the data source. If the data is messy, fix that first. The actual automation is the easy part.

Use APIs, not UI bots. I could have used browser automation to control WhatsApp Web, but that breaks every time WhatsApp updates their UI. The Business API is stable, fast, and gives you delivery receipts.

Build for the person who runs it. The accountant isn't a developer. So I made the Google Sheet the only interface they touch. No terminal, no config files, no "just edit this JSON."

Charge for value, not hours. This took me 3 hours. If I charged hourly at ₹1,000/hr, that's ₹3,000. But I saved them ₹85,000/year. ₹15,000 is a no-brainer for the client and fair compensation for the value delivered.

Want to Build Something Similar?

Here's the minimal setup you need:

Python 3.8+
gspread and google-auth for Sheets access
reportlab for PDF generation
WhatsApp Business API access (apply through Meta Business)
A Google Cloud service account with Sheets API enabled

Install everything with:

pip install gspread google-auth reportlab requests

The entire codebase is under 200 lines. You could build this in an afternoon.

I'm Archit Mittal — I automate chaos for businesses. Follow me for daily automation content.

I Had My First Automated Trade Running in 47 Minutes — Here's the Exact Setup

Archit Mittal — Wed, 08 Apr 2026 12:58:21 +0000

A friend called me last week with a familiar problem.

He had been comparing broker API documentation for three days straight. Zerodha versus Fyers versus Upstox versus Angel One. Spreadsheets of feature comparisons. Reddit threads. YouTube reviews. Three days of research, zero lines of code written.

I told him to stop comparing and start building.

By that evening, he had his first automated trade running. A simple bot that auto-squares-off all open positions at 3:15 PM so he never forgets to close before market end. Nothing fancy. But it worked. And it replaced a task that had cost him real money twice in the previous month when he forgot to exit positions manually.

This article is the guide I wish existed when I started automating trades two years ago. No theory. No affiliate links. Just the practical breakdown of how to go from zero to a working trading bot using Python and a broker API.

Why Most People Never Get Past the Research Phase

Here is the pattern I see repeatedly. Someone decides they want to automate their trading. They spend a week reading documentation. They get overwhelmed by the differences between brokers. They bookmark fifteen tutorials. They never write a single line of code.

The problem is not complexity. The problem is that most guides start with the wrong question. They ask "which broker has the best API?" when they should ask "which broker will let me run my first bot today?"

Those are very different questions.

The best API on paper means nothing if the authentication flow takes you a week to figure out. The most feature-rich documentation is useless if the sandbox environment does not match production. I have seen developers with years of experience get stuck for days on OAuth token refresh flows that should take twenty minutes.

The Setup I Actually Use (And Why)

I run four trading bots simultaneously on Fyers API. Here is why I chose it, with specific technical details rather than marketing language.

Authentication that does not fight you. Fyers uses a straightforward OAuth2 flow. You get an app_id and secret_key from their developer portal. The access token generation takes one API call. Compare this to brokers where you need to handle TOTP-based two-factor authentication programmatically — that alone can eat an entire afternoon.

One API for everything you need. Historical data, real-time websocket streaming, order placement, and position management — all through a single REST API with consistent response formats. Some brokers split these across different endpoints with different authentication methods. That means maintaining multiple connection handlers in your code. With a unified API, your codebase stays clean.

Rate limits that make sense for retail. Ten requests per second. If you are a retail algo trader running a few strategies, that is more than enough. I run four bots simultaneously and have never hit the ceiling. For context, even a high-frequency scalping strategy at the retail level rarely needs more than two to three requests per second.

Zero cost for API access. You pay standard brokerage on executed trades. The API itself costs nothing. No monthly subscription. No per-call charges. No premium tier you need to unlock to access historical data. This matters more than people realise — I have seen traders pay $50 to $100 per month for API access on international platforms before they have even validated whether their strategy works.

From Zero to First Bot: The 47-Minute Breakdown

Here is exactly how the timeline broke down when I set up my friend that evening.

Minutes 0 to 8: Developer portal setup. Created an app on Fyers API developer portal. Got the app_id and secret_key. This is a one-time setup — you reuse these credentials for every bot.

Minutes 8 to 15: Authentication script. Wrote a Python script to generate the access token. The Fyers Python SDK (fyers-apiv3) handles most of the heavy lifting. Install it, pass your credentials, get a token. Seven minutes including pip install time.

Minutes 15 to 30: The bot logic. His requirement was simple — check all open positions at 3:15 PM and square them off. That is a position fetch call followed by conditional sell orders. The logic itself was about 30 lines of Python. We wrapped it in a scheduled function using Python's schedule library.

Minutes 30 to 40: Testing with paper trades. Fyers allows you to validate order parameters without actually executing. We tested the flow end to end — fetch positions, generate square-off orders, validate them. Fixed two bugs: one where we were not handling the case of zero open positions, and another where the order type parameter was wrong for market orders.

Minutes 40 to 47: Live deployment. Switched from validation mode to live execution. Ran the bot. Watched it sit idle until 3:15 PM on the next trading day, then cleanly close all three open positions.

Total code: under 60 lines of Python. No frameworks. No Docker containers. No cloud deployment. Just a Python script running on his laptop with a cron job.

The Bots I Run Daily (And What They Actually Do)

Over two years, I have built up to four bots running simultaneously. None of them are complex. The power is in consistency, not sophistication.

Bot 1: The Position Closer. Squares off all positions at 3:15 PM. This was the first bot I ever wrote. It has saved me from forgetting to exit positions at least a dozen times. At an average of $200 to $500 per forgotten exit (in slippage and overnight risk), this single bot has probably saved me $3,000 or more.

Bot 2: The Morning Screener. Runs at 9:16 AM (one minute after market open). Scans a predefined watchlist for stocks that gapped up or down more than two percent from previous close. Sends results to my phone via WhatsApp using a simple webhook. I review the list over my morning coffee instead of staring at a screen for twenty minutes.

Bot 3: The SIP Optimizer. This one runs weekly. Instead of fixed-date SIP investments, it checks the Nifty P/E ratio. If the market is trading below historical average P/E, it invests more. If above average, it invests less. A basic value-averaging approach that anyone with a mutual fund account thinks about but nobody does manually because it is tedious. The total difference over eighteen months has been a 2.3% higher return compared to my fixed-date SIP — which translates to roughly $400 extra on a moderate portfolio.

Bot 4: The Trade Journal. Every executed trade gets logged automatically into a Google Sheet with entry price, exit price, P&L, holding duration, and the strategy tag. At the end of the week, a summary lands in my WhatsApp. I used to maintain this journal manually and abandoned it after two weeks every time. The automated version has been running for fourteen months without a single missed entry.

The Mistakes That Cost Me Real Money

I would be dishonest if I presented this as a smooth journey. Here are the expensive lessons.

Mistake 1: Not handling token expiry. Fyers access tokens expire daily. My first bot worked perfectly for one day and then silently failed the next morning because the token had expired. I only noticed when I checked my positions at 3:30 PM and found them still open. Cost: about $180 in overnight slippage. The fix took ten minutes — a token refresh function that runs at 8:30 AM before market open.

Mistake 2: No circuit breaker. My screener bot once sent me forty-seven WhatsApp messages in three minutes during a market-wide gap event. The fix: a simple counter that caps alerts at five per run and aggregates the rest into a single summary message.

Mistake 3: Trusting backtests blindly. I built a momentum strategy that looked incredible in backtesting — 34% annual returns over five years of historical data. In live trading, it lost 8% in the first month. The backtest did not account for slippage, partial fills, or the fact that the stocks it picked were often illiquid. I shut it down, went back to simple automation, and have not tried to build a "strategy" bot since. My bots automate actions, not decisions. That distinction matters.

When You Should NOT Automate Your Trading

This might be the most important section of this article.

Do not automate your trading strategy if you have not traded it manually for at least three months. Automation amplifies whatever you feed it. If your manual strategy loses money, your automated strategy will lose money faster and more consistently.

Do not automate if you cannot explain every line of your bot's code. I have seen people copy trading bots from GitHub, run them with real money, and then panic when something unexpected happens. If you did not write it, you do not understand it. If you do not understand it, you should not trust it with your money.

Do not start with strategy automation. Start with task automation — the boring stuff like position closing, journaling, and screening. These have near-zero financial risk and teach you the entire API workflow. Once you are comfortable with the plumbing, then consider automating decisions. Most people do this backwards.

Getting Started Today

If you have basic Python knowledge and a trading account, you can have your first bot running this evening. Here is the minimal path.

First, pick one repetitive task you do every trading day. Not a strategy. A task. Closing positions, checking prices, logging trades — something mechanical.

Second, set up API access with your broker. If you are in India, Fyers is my recommendation. If you are international, Interactive Brokers or Alpaca both have solid Python SDKs.

Third, write the smallest possible script that does that one task. Do not add features. Do not handle edge cases yet. Get the core loop working.

Fourth, run it in paper or validation mode for one full week. Watch it. Log what it does. Fix what breaks.

Fifth, go live with small positions. Scale up only after you trust it.

The entire process should take one weekend if you focus. Not three days of comparison shopping. One weekend of building.

The Real Value Is Not the Trades

After two years of running trading bots, here is what I have learned: the money saved from automation is real but it is not the main value. The real value is in the discipline it enforces.

My trade journal has fourteen months of unbroken data because a bot fills it in. My SIP adjustments happen consistently because a script makes them. My positions close on time because code does not forget.

Automation does not make you a better trader. It makes you a more consistent one. And in markets, consistency compounds.

Archit Mittal is the founder of Automate Algos. He helps businesses automate chaos using AI agents and custom workflows. Connect with him on LinkedIn @automate-archit.

How I Automated Invoice Processing for a ₹2Cr/Year Business in 3 Days

Archit Mittal — Wed, 08 Apr 2026 04:48:53 +0000

Last month, a textile exporter in Surat reached out to me with a familiar problem: their accounts team of 4 people was spending 6+ hours every day manually matching invoices to purchase orders and bank statements. For a business doing ₹2 crore in annual revenue with 200+ invoices per month, this was eating into their margins badly.

Here's how I automated their entire invoice processing pipeline in just 3 days using Python — and brought that 6-hour daily task down to 15 minutes of human review.

The Problem: Death by Manual Data Entry

Their workflow looked like this:

Receive invoices via email (PDF attachments) and WhatsApp
Manually type invoice details into a Google Sheet
Cross-check each invoice against purchase orders in another sheet
Match payments in their bank statement CSV to invoices
Flag mismatches and follow up with vendors

The error rate was roughly 8-12% — wrong amounts, missed invoices, duplicate entries. Each error meant hours of back-and-forth with vendors and delayed payments.

Cost of the old process:

4 staff × 6 hours/day × ₹15,000/month salary = ₹60,000/month just on invoice processing
Late payment penalties averaging ₹25,000/month
Total: ~₹85,000/month or ₹10.2 lakh/year

The Solution: A 3-Layer Python Pipeline

I built a pipeline with three components: Extract, Match, and Report.

Day 1: Invoice Data Extraction

First, I needed to pull structured data from PDF invoices. I used pdfplumber for text-based PDFs and pytesseract for scanned ones.

import pdfplumber
import re
from dataclasses import dataclass
from typing import Optional

@dataclassclass InvoiceData:
    invoice_number: str
    vendor_name: str
    date: str
    total_amount: float
    gst_amount: float
    line_items: list

def extract_invoice_data(pdf_path: str) -> InvoiceData:
    with pdfplumber.open(pdf_path) as pdf:
        full_text = ""
        for page in pdf.pages:
            full_text += page.extract_text() or ""

    # Extract key fields using regex patterns
    inv_number = re.search(
        r'Invoice\s*#?\s*:?\s*([A-Z0-9-]+)', 
        full_text, re.IGNORECASE
    )
    amount = re.search(
        r'Total\s*:?\s*₹?\s*([\d,]+\.?\d*)', 
        full_text, re.IGNORECASE
    )
    gst = re.search(
        r'GST\s*:?\s*₹?\s*([\d,]+\.?\d*)', 
        full_text, re.IGNORECASE
    )

    return InvoiceData(
        invoice_number=inv_number.group(1) if inv_number else "UNKNOWN",
        vendor_name=extract_vendor_name(full_text),
        date=extract_date(full_text),
        total_amount=float(amount.group(1).replace(',', '')) if amount else 0.0,
        gst_amount=float(gst.group(1).replace(',', '')) if gst else 0.0,
        line_items=extract_line_items(full_text)
    )

For the 30% of invoices that were scanned images, I added an OCR fallback:

import pytesseract
from pdf2image import convert_from_path

def ocr_extract(pdf_path: str) -> str:
    images = convert_from_path(pdf_path, dpi=300)
    text = ""
    for img in images:
        text += pytesseract.image_to_string(img, lang='eng+hin')
    return text

The Hindi language support was critical since many local vendors send bilingual invoices.

Day 2: Smart Matching Engine

The matching logic compares extracted invoice data against purchase orders and bank transactions. I used fuzzy matching because vendor names are never consistent (think "Raj Textiles" vs "Raj Textile Pvt Ltd").

from fuzzywuzzy import fuzz
import pandas as pd

def match_invoice_to_po(invoice: InvoiceData, po_df: pd.DataFrame) -> dict:
    best_match = None
    best_score = 0

    for _, po in po_df.iterrows():
        # Fuzzy match on vendor name
        name_score = fuzz.token_sort_ratio(
            invoice.vendor_name.lower(), 
            po['vendor_name'].lower()
        )

        # Exact or close match on amount (within 1% for rounding)
        amount_diff = abs(invoice.total_amount - po['amount']) / po['amount']
        amount_score = 100 if amount_diff < 0.01 else max(0, 100 - amount_diff * 100)

        # Combined weighted score
        combined = (name_score * 0.4) + (amount_score * 0.6)

        if combined > best_score:
            best_score = combined
            best_match = po

    return {
        'po_number': best_match['po_number'] if best_score > 75 else None,
        'confidence': best_score,
        'status': 'matched' if best_score > 85 else 'review' if best_score > 75 else 'unmatched'
    }

def match_to_bank_statement(invoice: InvoiceData, bank_df: pd.DataFrame) -> dict:
    """Match invoice to bank transactions within a 7-day window"""
    for _, txn in bank_df.iterrows():
        amount_match = abs(txn['amount'] - invoice.total_amount) < 1.0
        date_match = abs((txn['date'] - pd.to_datetime(invoice.date)).days) <= 7

        if amount_match and date_match:
            return {'txn_id': txn['reference'], 'status': 'paid'}

    return {'txn_id': None, 'status': 'unpaid'}

Day 3: Email Monitoring + Dashboard

I set up an email listener to auto-download invoice attachments and a simple Streamlit dashboard for the accounts team:

import imaplib
import email
import os
from pathlib import Path

def fetch_invoice_emails(
    imap_server: str, 
    username: str, 
    password: str,
    download_dir: str = "./invoices"
):
    mail = imaplib.IMAP4_SSL(imap_server)
    mail.login(username, password)
    mail.select('inbox')

    # Search for emails with PDF attachments from last 24 hours
    _, messages = mail.search(None, '(SINCE "08-Apr-2026" SUBJECT "invoice")')

    Path(download_dir).mkdir(exist_ok=True)
    downloaded = []

    for msg_id in messages[0].split():
        _, msg_data = mail.fetch(msg_id, '(RFC822)')
        msg = email.message_from_bytes(msg_data[0][1])

        for part in msg.walk():
            if part.get_content_type() == 'application/pdf':
                filename = part.get_filename()
                filepath = os.path.join(download_dir, filename)

                with open(filepath, 'wb') as f:
                    f.write(part.get_payload(decode=True))
                downloaded.append(filepath)

    mail.logout()
    return downloaded

The Results: ₹8.5 Lakh Annual Savings

After one month of running the system:

Processing time: 6 hours/day → 15 minutes of human review
Error rate: 12% → 0.5% (only edge cases need manual intervention)
Staff reallocation: 3 of 4 accounts staff moved to higher-value work
Late payment penalties: ₹25,000/month → ₹2,000/month
Net savings: ~₹8.5 lakh/year

The total cost of building this? About ₹45,000 for my 3 days of work plus ₹500/month for a basic VPS to run the pipeline. ROI hit positive in the first month itself.

Key Takeaways for Indian Businesses

Start with the most painful manual process — invoice matching was their biggest time sink, not the fanciest problem to solve
Build for bilingual — if you're automating for Indian businesses, Hindi/regional language support isn't optional. pytesseract with language packs handles this well
Keep humans in the loop — the system flags low-confidence matches for review instead of auto-approving everything. This built trust with the accounts team
Use fuzzy matching liberally — Indian business names have many variations. Hard string matching will miss 40%+ of valid matches
Measure in ₹, not in hours — when I told the owner "you'll save ₹8.5 lakh/year," the approval was instant. Saying "you'll save 1,400 hours" wouldn't have had the same impact

Want to Build Something Similar?

The full pipeline is about 400 lines of Python. The key libraries you need:

pdfplumber — PDF text extraction
pytesseract + pdf2image — OCR for scanned documents
fuzzywuzzy — fuzzy string matching
pandas — data manipulation and CSV handling
streamlit — quick dashboard for the review interface
imaplib — email monitoring (built into Python)

The entire stack runs on a ₹500/month DigitalOcean droplet. No expensive SaaS subscriptions needed.

*I'm Archit Mittal — I automate chaos for businesses. Follow me for daily automation content.*thon)

The entire stack runs on a ₹500/month DigitalOcean droplet. No expensive SaaS subscriptions needed.

I'm Archit Mittal — I automate chaos for businesses. Follow me for daily automation content.

Vibe Coding Saved My Client ₹2.4 Lakh — By Replacing a Junior Developer's Typing, Not Their Job

Archit Mittal — Wed, 01 Apr 2026 12:55:02 +0000

A client called me last month with a hiring problem.

His senior developer was drowning. Every new feature followed the same painful loop — write detailed specs, hand them to the junior dev, wait through three review cycles, fix the mistakes, and finally ship two weeks later. The junior developer was essentially a spec-to-code translator. Necessary, but slow.

He was about to post a job listing for a second junior developer. Salary: ₹2.4 lakh for six months. Plus onboarding time. Plus the senior dev spending 30% of their day reviewing beginner-level code.

I told him to wait one weekend.

What Actually Happened That Weekend

The senior developer spent Saturday and Sunday learning vibe coding with Claude Code — Anthropic's terminal-based AI coding assistant. Not watching tutorials. Not reading documentation for hours. Just building.

By Monday, the workflow had completely transformed.

Before vibe coding: Senior dev writes a two-page spec document. Junior dev interprets it (sometimes incorrectly). First draft comes back in 3-4 days. Two rounds of review. Bug fixes. Ship date: 10-14 days per feature.

After vibe coding: Senior dev describes the feature to Claude Code in plain English. Reviews the output. Tweaks the architecture decisions. Ships in 1-2 days.

The same person. The same codebase. The same features. Just a fundamentally different process.

The Part Nobody Talks About

Here is where most "AI will replace developers" articles get it dangerously wrong.

That senior developer did not stop thinking. He did not blindly accept whatever Claude Code generated. In fact, his job got harder in some ways — because now he was reviewing AI-generated code at the speed of AI generation, not at the comfortable pace of a junior developer's output.

Every single line still got reviewed. Bugs that Claude Code missed — and it does miss them — still got caught by a human brain with years of context about the codebase. Architecture decisions that require understanding the business, the users, and the technical debt? Still 100% human.

Vibe coding replaced the junior developer's typing. It did not replace the senior developer's thinking. That distinction matters more than any benchmark or demo.

Why This Changes the Hiring Equation in India

The Indian tech market has a specific pattern. Companies hire junior developers at ₹15,000 to ₹40,000 per month primarily as code translators — someone who takes specs and turns them into working code. The actual engineering decisions happen one level up.

Vibe coding disrupts this exact layer. When a senior developer can describe a feature in natural language and get working code back in minutes, the spec-to-code translation role shrinks dramatically.

This does not mean junior developers become irrelevant. It means the definition of "junior developer" is changing. The ones who will thrive are those who learn to work alongside AI tools early — who treat Claude Code or similar tools as a pair programming partner rather than a threat.

My client's senior developer now ships features at roughly 5x the previous pace. Not because the code quality dropped, but because the iteration loop collapsed. Describe, review, tweak, ship. No waiting for someone else to interpret your vision.

The Numbers That Matter

Let me break down what ₹2.4 lakh over six months actually looks like when you do the math on vibe coding instead.

Cost of hiring a junior developer:

Salary for 6 months: ₹2,40,000 (at ₹40,000/month)
Onboarding time: 2-3 weeks of the senior dev's bandwidth
Review overhead: approximately 30% of senior dev's daily time
Feature delivery speed: 10-14 days per feature

Cost of vibe coding with Claude Code:

Claude Code API usage: roughly ₹3,000 to ₹5,000 per month depending on volume
Learning curve: 1 weekend
Review overhead: still exists, but at the senior dev's pace, not the junior's
Feature delivery speed: 1-2 days per feature

The raw savings on salary alone: over ₹2 lakh in six months. But the real value is in the speed multiplier. Features that took two weeks now take two days. That compounds over an entire product roadmap.

When Vibe Coding Does Not Work

I would be dishonest if I painted this as a universal solution. Vibe coding falls apart in specific situations.

Complex system architecture — Claude Code can write individual features well, but it does not understand how your microservices talk to each other across three years of accumulated technical debt. A human architect is irreplaceable here.

Domain-specific logic — If you are building trading algorithms, medical software, or anything where the business logic is the product, AI-generated code needs significantly more scrutiny. The AI does not understand why a particular edge case matters to your users.

Team knowledge transfer — Junior developers are not just code translators. They are future senior developers. If you eliminate all junior roles, you eventually have no pipeline for senior talent. Smart companies will use vibe coding to augment juniors, not replace them entirely.

The client I mentioned? He is now training his existing junior developer to use Claude Code alongside the senior dev. Instead of firing someone, he is upskilling them. The junior dev writes prompts, reviews AI output, and learns architecture patterns at 3x the normal speed because they see more code iterations per day.

The Real Debate

The question is not "vibe coding versus traditional coding." Anyone framing it that way is selling you something.

The real question is: who learns to work with AI faster?

The senior developer who spent one weekend learning Claude Code now has a permanent productivity multiplier. The companies that figure out how to integrate AI coding tools into their existing teams — without gutting their junior talent pipeline — will ship faster than everyone else.

AI types. It does not think. The thinking is still yours. And that is the most valuable skill you can have in 2026.

Getting Started with Vibe Coding

If you are a developer or engineering lead who wants to try this — start with one feature. Not your most critical one. Pick something from the backlog that has been sitting there for weeks. Describe it to Claude Code in plain English. See what comes back. Review it the way you would review any pull request. Ship it if it passes your standards.

That is it. No complex setup. No three-month "AI transformation" initiative. One feature. One weekend. Then decide if you want to keep going.

Most people who try it do.

Archit Mittal is the founder of Automate Algos. He helps businesses automate chaos using AI agents and custom workflows. Connect with him on LinkedIn @automate-archit.

How I Automated ITR Document Collection and Why Every CA Firm in India Needs This

Archit Mittal — Mon, 30 Mar 2026 12:56:07 +0000

Tax season in India is a special kind of chaos.

Every year, between January and March, chartered accountants across the country enter survival mode. Their phones blow up with the same message from 200 different clients: "I'll send the documents tomorrow." Tomorrow never comes. March 31 does.

My CA called me last week with the usual request — Form 16, AIS data, 12 months of bank statements. The standard package. I told him to check his email because my script had already sent everything.

There was a long pause on the line.

"...what script?"

The Problem Every CA Firm Faces

Let me paint you a picture that every chartered accountant in India will recognise.

It is March 15. You have 200 clients. Each client needs to submit roughly 4-6 documents for their ITR filing. That is 800 to 1,200 individual documents that need to be collected, verified, formatted, and filed — all within about two weeks.

Most of these documents live in different places. Form 16 comes from the employer's HR portal. The Annual Information Statement sits on the income tax portal. Bank statements are scattered across 2-3 different bank websites. Investment proofs are buried in email inboxes.

The traditional process looks like this: the CA sends a WhatsApp message asking for documents. The client says they will send them "by evening." Three days later, the CA follows up. The client sends a blurry photo of their Form 16 taken at an angle. The CA asks for a proper PDF. Another two days pass. Multiply this by 200 clients and you understand why CAs age faster than the rest of us during tax season.

The real cost is not just time. It is the cognitive load of tracking who has sent what, what is still pending, and which documents have errors that need to be re-requested. I have spoken with CA firms that hire temporary staff exclusively for document collection during January-March. One firm I worked with was spending roughly ₹80,000 per quarter on a person whose entire job was to chase clients for PDFs.

What I Built: A 40-Line Document Automation Script

Here is what my Python script does every March, completely hands-free:

Step 1: Pull Form 16 data. The script logs into my employer's portal using stored credentials and downloads the Form 16 PDF. For salaried individuals, this is the single most important document and the one that gets delayed the most because people forget their HR portal passwords.

Step 2: Download AIS from the Income Tax Portal. The Annual Information Statement contains every financial transaction the government already knows about — salary, interest income, stock trades, mutual fund transactions. My script pulls this data programmatically and saves it as a formatted PDF.

Step 3: Fetch 12 months of bank statements. This was the trickiest part. Different banks have different portal structures, different session management, and different export formats. I wrote modular functions for the three banks I use — HDFC, ICICI, and SBI. Each function handles login, navigates to the statement section, sets the date range for the full financial year, and downloads the PDF.

Step 4: Package and email. All documents get collected into a single folder, renamed with a consistent naming convention (Form16_ArchitMittal_FY2526.pdf, AIS_ArchitMittal_FY2526.pdf, etc.), zipped, and emailed to my CA with a summary of what is included.

The entire thing runs as a cron job on a ₹500/month VPS. Every March 1, it executes automatically. By the time my CA starts making his annual round of phone calls, my documents are already sitting in his inbox.

Total setup time: one Sunday afternoon. Total recurring cost: ₹4 per execution in compute and API calls.

Why My CA Asked Me to Build This for His Other 200 Clients

When I told my CA about the script, his first reaction was not "that's cool." His exact words were: "Mere baaki 200 clients ke liye bana de." (Build this for my other 200 clients.)

That single sentence told me everything about the automation opportunity in Indian professional services.

CA firms are not short on intelligence. These are some of the sharpest financial minds in the country. What they lack is time — specifically, time that gets consumed by mechanical, repetitive work that has nothing to do with their actual expertise.

Think about what a CA's real value is: tax planning, compliance strategy, audit oversight, financial advisory. Instead, during the busiest quarter of the year, they spend 60-70% of their time on document collection and formatting. That is like hiring a surgeon and having them spend most of their day filling out admission forms.

The numbers get even more interesting at scale. A mid-sized CA firm with 500 clients spends approximately 1,500-2,000 hours per year on document collection alone. At an average billing rate of ₹800/hour, that is ₹12 to ₹16 lakh in opportunity cost — revenue that could have been earned doing actual advisory work instead of chasing PDFs on WhatsApp.

The Bigger Picture: Why Finance Automation is India's Untapped Gold Mine

Here is what most people in the AI and automation space are missing about India.

Everyone is building tools for tech companies. CRM automation for SaaS startups. Code generation for developers. Marketing copy for D2C brands. Meanwhile, the largest chunk of India's professional services sector — accounting, legal, compliance — is still running on WhatsApp messages and Excel files.

India has over 3.5 lakh practising chartered accountants. Most of them serve 100-500 clients each. The vast majority use Tally for accounting, WhatsApp for client communication, and manual processes for everything in between. There is almost no automation layer connecting these tools.

The opportunities are everywhere once you start looking:

GST reconciliation is a monthly nightmare for businesses with high transaction volumes. The GSTN portal data needs to be matched against purchase registers, and mismatches need to be identified and resolved before filing. I have seen businesses spend 3-4 days per month just on GST reconciliation — a process that a well-written script can do in under 10 minutes.

Invoice processing is another massive time sink. Small businesses receive invoices via email, WhatsApp, courier, and sometimes just as verbal agreements. Extracting structured data from these disparate sources and feeding it into accounting software is exactly the kind of work that AI excels at — pattern recognition across unstructured data.

Bank reconciliation for businesses with multiple accounts across multiple banks involves downloading statements, normalising formats, matching transactions, and identifying discrepancies. Every CA firm does this manually. Every single one.

How to Get Started: A Practical Roadmap

If you are a developer looking to build in this space, or a CA firm wanting to start automating, here is what I recommend.

Start with document collection. It is the lowest-hanging fruit with the highest time savings. Build a simple script that can download Form 16, AIS, and bank statements for a single person. Then generalise it. The technical complexity is moderate — mostly web scraping, session management, and PDF handling — but the time savings are immediate and dramatic.

Talk to your CA. Seriously. Have a conversation about their workflow during tax season. Ask them what takes the most time. You will be surprised at how many problems are solvable with basic Python scripting and API integrations. CAs understand the value of automation intuitively because they deal with numbers all day — they just have not had someone translate their problems into code.

Think in workflows, not tools. The mistake most automation builders make is starting with a tool and looking for problems it can solve. Instead, start with a workflow — the exact sequence of steps a human follows — and then figure out which steps can be automated. Some steps genuinely need human judgment (like deciding whether to claim a specific deduction). Others are purely mechanical (like downloading a PDF from a portal). Automate the mechanical ones ruthlessly. Leave the judgment ones to the humans.

Build the "pause and think" step. From my own experience of over-automating my trading routine, I have learned that the best automations always include a checkpoint where a human reviews the output before it moves forward. In the case of ITR automation, this means the CA should review the collected documents before filing — never auto-file without a human in the loop.

The Bottom Line

March 31 is here. Somewhere right now, a CA is manually downloading their 150th Form 16 of the season while WhatsApp notifications pile up with clients asking "bhaiya, meri filing ho gayi kya?" (brother, is my filing done yet?).

Next year, that CA could have a script doing the mechanical work while they focus on what actually matters — advising their clients on how to save more and comply better.

The best time to automate tax season was last year. The second best time is right now.

Archit Mittal is the founder of Automate Algos. He helps businesses automate chaos using AI agents and custom workflows. Connect with him on LinkedIn @automate-archit.

How I Automated ITR Document Preparation With 40 Lines of Python

Archit Mittal — Fri, 27 Mar 2026 13:01:42 +0000

My chartered accountant called me last week. Five days before March 31.

His voice had that familiar panic — the same tone every CA in India carries between February and March. He needed my ITR documents. Form 16. AIS data. Twelve months of bank statements. The usual March-end package.

I told him to check his email. My script had already sent everything.

There was a long pause on the other end. Then: "What script?"

I explained that I had written a 40-line Python script that automatically pulls my Form 16, downloads my AIS (Annual Information Statement) data, grabs twelve months of bank statements from my bank's portal, formats everything exactly the way he likes it, and emails him the complete package every March. No manual downloads. No PDF renaming. No forgetting that one statement from August.

His response surprised me. He did not say "nice" or "that's cool." He said something far more interesting.

"Can you build this for my other 200 clients?"

That single conversation crystallised something I had been thinking about for months: the biggest automation opportunity in India is not in tech companies. It is in CA firms, brokerages, small finance teams, and the thousands of professionals who are brilliant at their core work but still copy-pasting PDFs at 2 AM during tax season.

The March-End Problem Nobody Talks About

Every year, approximately 7.5 crore (75 million) ITRs are filed in India. Behind each filing is a CA or tax professional who has to collect, verify, and organise documents from their clients. For a mid-sized CA firm handling 200-500 clients, this means:

Sending hundreds of reminder emails and WhatsApp messages asking for documents
Manually downloading Form 16 PDFs that clients forward in various formats
Cross-referencing AIS data with what clients actually reported
Chasing bank statements that always seem to be missing one or two months
Renaming and organising files into client-specific folders
Doing all of this in a 45-day window while also handling GST filings and audits

I have spoken with over a dozen CA firms in the last six months. The average time spent per client just on document collection and organisation is 45-90 minutes. Multiply that by 300 clients and you get 225-450 hours — essentially two to three full-time employees doing nothing but collecting and sorting PDFs for two months.

That is not accounting work. That is data entry disguised as professional service.

What the Script Actually Does

Let me walk through the automation I built, because the simplicity is the entire point.

Step 1: Pull Form 16 Data

Most employers now issue Form 16 through TRACES or their HRMS portals. The script connects to the relevant portal using stored credentials, downloads the latest Form 16 Part A and Part B, and saves them with a standardised naming convention. For salaried individuals with a single employer, this takes exactly one API call.

Step 2: Download AIS Data

The Annual Information Statement from the Income Tax portal contains all reported financial transactions — salary, interest income, dividends, property transactions, high-value purchases. The script pulls this data and converts it into a readable summary. This is critical because AIS mismatches are the number one reason for ITR notices.

Step 3: Fetch Bank Statements

This is where most people lose the most time manually. The script connects to the bank's API (or uses their download portal) to pull twelve months of statements. It handles the date ranges automatically — April to March of the relevant financial year. No more downloading month by month.

Step 4: Format and Package

Every CA has their own preferred format. Some want everything in a single PDF. Some want separate folders. Some want an Excel summary sheet on top. The script formats the output based on a configuration file — change the config once and every client's package follows the same structure.

Step 5: Email the Package

The final step is automatic delivery. The script compiles everything into a ZIP file and emails it to the CA with a checklist summary: which documents are included, which are missing (if any), and whether the AIS data has any discrepancies worth reviewing.

Total execution time: under 3 minutes per client. Compare that to 45-90 minutes of manual work.

The Real Numbers: Why This Matters for CA Firms

Let me lay out the business case with real numbers, because abstract automation talk means nothing without specifics.

A CA firm with 300 clients spends roughly 300 hours on document collection at the conservative end. If a junior accountant costs the firm around ₹25,000 per month (₹150 per hour), that is ₹45,000 worth of labour — every tax season — on a task that adds zero intellectual value.

But the real cost is not the labour. It is the opportunity cost. Those 300 hours are 300 hours that could go towards actual tax planning, advisory work, and the kind of high-value services that clients pay a premium for. A CA billing ₹2,000 per hour for advisory work who spends 100 of those hours on document collection is leaving ₹2,00,000 on the table.

The script I built cost me a Sunday afternoon. The version I am building for CA firms — with a proper dashboard, client management, and multi-bank support — will save the average firm ₹3-5 lakh per tax season in recovered billable hours.

Why CA Firms Are the Perfect Automation Clients

After working with traders, e-commerce businesses, and SaaS companies on automation, I have come to believe that CA firms are the single most underserved market for business automation in India. Here is why:

Their work is highly repetitive. Tax filing follows the same steps for every client, every year. The inputs change but the process does not. This is automation's sweet spot.

They already have the data. Unlike businesses that need to first digitise their operations, CA firms already work with structured digital data — PDFs, Excel sheets, portal downloads. The data is there. It just needs to flow automatically.

The pain is seasonal but intense. March-end is not just busy. It is existentially stressful for most CA firms. Automation that alleviates even 30% of that March crunch is worth significant money to them.

They serve as multipliers. One CA firm automates their workflow and suddenly 300 of their clients benefit from faster, more accurate filings. The ripple effect is massive.

Beyond ITR: The Full CA Automation Stack

Document collection is just the starting point. Once a CA firm sees what automation can do for their ITR workflow, the next questions come naturally:

GST Reconciliation: Matching GSTR-2A with purchase registers is a monthly headache for every firm. A Python script that pulls both datasets and highlights mismatches saves 10-15 hours per month.

TDS Certificate Collection: Chasing Form 16A from multiple deductors for a single client is one of the most frustrating parts of tax practice. Automated tracking and download changes the game.

Client Communication: Automated WhatsApp reminders that go out when documents are missing — not generic blasts, but personalised messages that say "We have your Form 16 but are still waiting for your HDFC Bank statement for October."

Audit Trail Generation: Every download, every email, every document version — automatically logged. When the tax department asks questions two years later, the firm has a complete digital paper trail.

Getting Started: What You Actually Need

You do not need to be a Python developer to begin automating your CA practice. Here is the minimum viable automation stack:

Python 3.x with the requests library for API calls, pandas for data formatting, and smtplib for email automation. That is it. No frameworks, no cloud infrastructure, no monthly subscription.

API access to your clients' financial portals. This is the tricky part — it requires client consent and proper credential management. Start with your own accounts to prove the concept.

A configuration file (even a simple Excel sheet works) that maps each client to their data sources, CA's preferred format, and delivery email.

30 minutes of setup per client the first time. After that, every subsequent tax season is fully automated.

The Bigger Picture

Somewhere in India right now, a CA is manually downloading their 200th Form 16 of the season. They are brilliant at tax law. They could be advising clients on Section 80C optimisation or structuring HUF transactions. Instead, they are renaming PDFs.

This is not a technology problem. Python has been able to do this for over a decade. It is an awareness problem. Most CA firms do not know that a Sunday afternoon of scripting can reclaim hundreds of hours of their practice every year.

The finance automation market in India is not a future opportunity. It is a present one. The tools exist. The data is digital. The pain is real and recurring. The only missing piece is someone to connect the dots.

That is exactly what I do. I automate chaos.

Archit Mittal is the founder of Automate Algos. He helps businesses automate chaos using AI agents and custom workflows. Connect with him on LinkedIn @automate-archit.

Indian Small Businesses Lose ₹50,000 Every Month to Tasks That Could Be Automated for Free

Archit Mittal — Wed, 25 Mar 2026 13:03:05 +0000

I surveyed 20 small business founders in India last week. One simple question: "What's your biggest time drain?"

The answers were painfully consistent. Customer replies, invoice follow-ups, data entry, social media scheduling — the same handful of tasks eating away 20+ hours every week across nearly every business I spoke to.

When I did the math, the number was staggering. Most of these businesses were bleeding ₹50,000 or more per month — not on software, not on infrastructure — on human hours wasted on work that machines should be doing.

Here's the thing: almost none of them knew that these tasks could be fully automated, often for ₹0.

The Hidden Cost of "Just Doing It Manually"

Small business owners in India are some of the hardest-working people I know. But hard work and smart work are two very different things. When you're manually replying to the same 15 customer queries every day, chasing invoices over WhatsApp, or copy-pasting order details from forms into spreadsheets, you're not building your business — you're running on a hamster wheel.

Here's what the 20 founders I surveyed reported as their weekly time drains:

Customer replies: 8 hours per week. Most of these are the same 10-15 questions asked repeatedly — order status, pricing, return policy, payment confirmation. A well-configured auto-reply system or AI chatbot handles 80% of these without human intervention.

Invoice follow-ups: 6 hours per week. Sending reminders, checking payment status, escalating overdue invoices. This is a classic automation candidate — trigger on due date, auto-send a WhatsApp or email reminder, escalate if unpaid after a set number of days.

Data entry from forms: 5 hours per week. Google Form responses, website enquiries, order details — all being manually entered into spreadsheets or accounting software. A simple script or webhook can move this data automatically the moment it arrives.

Social media scheduling: 4 hours per week. Writing captions, finding the right time to post, switching between platforms. Batch your content creation once a week, schedule it with a cron job or a free scheduler, and reclaim those hours.

That's 23 hours per week — nearly three full working days — gone to tasks that a well-designed automation handles in the background with zero ongoing effort.

Why This Problem Is Worse in India

India has a unique automation gap. Large enterprises have dedicated IT teams building internal tools and integrations. But the 63 million+ MSMEs that form the backbone of the Indian economy? Most of them are running on WhatsApp, Tally, Excel, and sheer willpower.

The reasons I've seen after working with hundreds of these businesses:

"Automation is expensive" — This was the most common misconception. Business owners assume automation means buying expensive enterprise software. In reality, a Python script running on a ₹500/month server can replace tasks that cost ₹50,000/month in manual labor. Google Apps Script is completely free and can automate most spreadsheet and email workflows. Even WhatsApp Business API has free tiers for small volumes.

"I don't have a tech team" — You don't need one. Modern AI coding tools like Claude Code and Cursor can generate working automation scripts from plain English descriptions. I've seen business owners with zero coding background set up invoice automation in an afternoon using AI-assisted coding.

"My processes are too unique" — Every business owner thinks their workflow is special. In my experience, 90% of small business operations fall into the same five categories: lead capture, customer communication, invoicing, data management, and reporting. The specifics vary, but the automation patterns are nearly identical.

The Five Automations Every Indian Small Business Should Build First

Based on the patterns I've seen across 10,000+ businesses and traders I've worked with, here are the five highest-ROI automations to start with:

1. Customer Query Auto-Response

Set up a WhatsApp Business API integration that reads incoming messages, matches them against your FAQ database, and sends instant replies. For the 20% of queries that need human judgment, route them to your phone with a priority tag. Time saved: 6-8 hours/week.

The setup is straightforward — a small script that listens for incoming messages via webhook, matches keywords against a JSON file of common questions and answers, and sends the response back via the API. Total cost: ₹0 if you're under the free message limit.

2. Invoice Follow-Up Pipeline

Connect your billing system (Tally, Zoho, or even a Google Sheet) to an automated reminder workflow. When an invoice crosses its due date, the system sends a polite WhatsApp reminder. Three days later, a firmer email. Seven days later, it flags the case for your personal attention. Time saved: 5-6 hours/week.

The key insight here is that 70% of late payments aren't intentional — people just forget. An automated nudge at the right time recovers most of them without any awkward phone calls.

3. Form-to-System Data Bridge

Whether you're collecting leads from a website form, orders from Google Forms, or enquiries from Instagram DMs, the data should flow automatically into your master spreadsheet or CRM. A webhook endpoint that receives form data and appends it to Google Sheets takes about 20 lines of code. Time saved: 4-5 hours/week.

4. Daily Business Summary Report

Instead of manually checking five different dashboards every morning, build a script that pulls yesterday's sales from your POS, pending orders from your sheet, overdue invoices from Tally, and sends you a single WhatsApp message at 8 AM with everything you need to know. Time saved: 3-4 hours/week.

This is the automation that business owners love the most — not because it saves the most time, but because it gives them clarity. You start your day knowing exactly what needs attention.

5. Bank Statement Categorization

If you're still manually categorizing bank transactions for your CA at month-end, stop. A Python script using basic pattern matching (or an AI model for tricky ones) can read your bank statement CSV, categorize each transaction (salary, rent, vendor payment, GST, etc.), and spit out a clean report ready for your accountant. Time saved: 8-10 hours/month.

The ₹0 Automation Stack

You don't need expensive SaaS subscriptions to automate a small business. Here's the stack I recommend to founders who want to start without spending anything:

Google Apps Script — Free, runs on Google's servers, integrates natively with Sheets, Gmail, Calendar, and Forms. Perfect for email automation, data processing, and scheduled reports.

Python + cron on a ₹500 VPS — For anything that needs to run on a schedule — data pulls, report generation, API integrations. A basic DigitalOcean or AWS Lightsail instance handles most small business automation needs.

WhatsApp Business API — Free tier covers up to 1,000 conversations per month. More than enough for most small businesses to automate customer replies and send notifications.

AI coding assistants — Claude Code, Cursor, or GitHub Copilot can write the actual automation scripts for you. Describe what you want in plain English, get working code, deploy it. The barrier to entry has never been lower.

Google Sheets as a database — For businesses that aren't ready for a proper database, Sheets works surprisingly well as a lightweight backend. Combined with Apps Script, it becomes a free automation platform.

The Real ROI: It's Not Just About Money

Yes, automating 23 hours of weekly manual work saves roughly ₹50,000/month in labor costs. But the real return is something bigger — it frees the founder to actually run the business.

Every hour a small business owner spends copying data from one spreadsheet to another is an hour they're not spending on product development, customer relationships, or strategic planning. The businesses that grow are the ones where the founder's time is spent on decisions, not data entry.

As my father always says — "Time waste karna sabse bada loss hai." He's not wrong. And in 2026, wasting time on tasks a script can handle is not just inefficient — it's a competitive disadvantage.

Start With One Thing

If you've read this far and you're thinking "this sounds great but where do I even begin?" — here's my advice: pick one task. Just one. The most repetitive, soul-crushing task in your week.

Then automate it. Use AI to write the script if you need to. Deploy it on a free server. Watch it run.

Once you see that first automation working — handling something that used to eat hours of your week — you'll never look at manual work the same way again.

Archit Mittal is the founder of Automate Algos. He helps businesses automate chaos using AI agents and custom workflows. Connect with him on LinkedIn @automate-archit.

How I Saved My Mom's Small Business ₹1,50,000/Year With a Free WhatsApp Automation

Archit Mittal — Mon, 23 Mar 2026 12:56:01 +0000

₹1,50,000 per year.

That's what my mom's small business was spending on a person whose only job was to read WhatsApp orders and type them into a register. Not a spreadsheet. A physical register.

Last month, I sat with her for 2 hours and built a simple workflow that completely eliminated that cost. The tools were free. The setup was straightforward. And the next morning, she called me and said — "Beta, vo 3 ghante mein karta tha, ye 3 second mein ho gaya."

Translation: "Son, what used to take 3 hours now happens in 3 seconds."

This isn't a story about replacing people. She used the money she saved to hire a delivery person instead. More jobs, not fewer. That's the real automation story nobody talks about.

Here's exactly how I built it — and how you can do the same for any small business in India.

The Problem: Manual WhatsApp Order Entry

If you run or know a small business in India, you've seen this workflow:

Customer sends a WhatsApp message — "2 kg atta, 1 kg sugar, deliver by 5 PM"
Someone reads the message, opens a register or Excel sheet, and types it in manually
They send a reply — "Order received, will deliver by 5 PM"
They repeat this 30-50 times a day

My mom's business was getting 40+ orders daily on WhatsApp. The person handling this spent 3 hours every morning just entering data and replying. Three hours of repetitive, error-prone work that a machine can do in seconds.

The cost breakdown was painful: ₹12,500/month salary for a task that added zero creative or strategic value to the business. Over a year, that's ₹1,50,000 spent on copy-pasting messages into a sheet.

The Solution: n8n + WhatsApp + Google Sheets

I used n8n — an open-source workflow automation tool — to build the entire pipeline. Here's what the workflow does:

Step 1: Capture incoming WhatsApp messages

Using the WhatsApp Business API (via a provider like Twilio or the official WhatsApp Cloud API), every incoming message triggers an n8n webhook. The message content, sender's phone number, and timestamp all flow into the workflow automatically.

Step 2: Parse the order

This is where it gets clever. I connected a simple AI node (Claude API) that reads the raw WhatsApp message and extracts structured data — item names, quantities, delivery time, and any special instructions. Indian customers write orders in a mix of Hindi, English, and Hinglish. The AI handles all three without breaking a sweat.

A message like "bhai 2 packet atta aur 1 kg cheeni, 6 baje tak bhej dena" gets parsed into:

Item	Quantity	Delivery Time
Atta	2 packets	6:00 PM
Sugar	1 kg	6:00 PM

Step 3: Write to Google Sheets

The parsed order data gets written into a Google Sheet — one row per order with columns for customer name, phone number, items, quantities, delivery time, and status. This sheet becomes the live order dashboard that anyone in the business can access from their phone.

Step 4: Send an automated confirmation

The workflow sends a WhatsApp reply back to the customer confirming their order with the exact items and delivery time. If the AI couldn't parse something (maybe a new product name it hasn't seen), it flags the message for a human to review instead of guessing.

Why n8n and Not Zapier?

This is a question I get constantly. The answer comes down to cost and control.

Zapier would cost ₹12,000-15,000/year for this kind of workflow with 40+ daily triggers. For a small business that was already spending ₹1,50,000/year on manual labor, adding another subscription defeats part of the purpose.

n8n is open-source. You can self-host it on a ₹500/month VPS (or even a Raspberry Pi sitting in your shop) and run unlimited workflows with unlimited triggers. The total infrastructure cost for my mom's setup is roughly ₹6,000/year — a 96% reduction from the original ₹1,50,000.

Here's the honest comparison:

Factor	Zapier	n8n
Monthly cost (this workflow)	₹1,000-1,250	₹500 (VPS hosting)
Annual cost	₹12,000-15,000	₹6,000
Trigger limits	Capped by plan	Unlimited
Self-hosting	No	Yes
WhatsApp integration	Limited	Full API access
Learning curve	Lower	Slightly higher

For someone who's never built a workflow before, Zapier is easier to start with. But for any Indian small business watching costs carefully, n8n pays for itself in the first month.

The Results After 30 Days

The numbers speak louder than any pitch:

Time saved: 3 hours/day → approximately 90 hours/month of manual work eliminated
Error rate: Down from roughly 8-10 wrong entries/week to near zero
Response time: Customer replies went from 15-30 minutes (human delay) to under 5 seconds
Cost: ₹12,500/month → ₹500/month (96% reduction)
Side benefit: The Google Sheet doubles as an inventory tracker — she can now see which products sell most and when

But the number that matters most? My mom used the ₹1,50,000/year she saved to hire a delivery person. The business grew because automation freed up capital that went right back into operations.

How to Build This for Your Business (Quick Start)

If you want to replicate this, here's the simplified roadmap:

Phase 1 — Set up infrastructure (1 hour)

Get a VPS from any Indian cloud provider (DigitalOcean, Hetzner, or even AWS Lightsail). Install n8n using their Docker setup — it takes about 15 minutes if you follow their documentation. Set up WhatsApp Business API access through Meta's Cloud API (free tier covers up to 1,000 conversations/month).

Phase 2 — Build the workflow (1 hour)

Create a webhook trigger in n8n. Connect it to your WhatsApp Business API. Add an AI node for message parsing (Claude API's Haiku model costs fractions of a paisa per message). Connect Google Sheets as the output destination. Add a WhatsApp reply node for confirmations.

Phase 3 — Test and go live (30 minutes)

Send test messages from different phone numbers. Check that orders parse correctly in Hindi, English, and Hinglish. Verify Google Sheet entries are accurate. Set up an error notification (Telegram bot works great for this) so you know immediately if something fails.

The total setup time is about 2-3 hours for someone comfortable with basic tech tools. If you're a developer, you can probably do it in under an hour.

The Bigger Picture: Why This Matters for Indian Small Businesses

India has over 63 million MSMEs. Most of them run critical business operations through WhatsApp. And most of them are paying real money — or spending valuable hours — on tasks that automation handles for free.

The tools exist today. n8n is free. The WhatsApp API has a generous free tier. Google Sheets is free. The only investment is a few hours of setup time.

The businesses that figure this out in 2026 will have a massive cost advantage over those that don't. And it's not about cutting jobs — it's about redirecting human effort from data entry to work that actually grows the business.

My mom's delivery person is busier than ever. Her customers get faster replies. Her order accuracy went up. Everyone won.

That's what good automation looks like.

Archit Mittal is the founder of Automate Algos. He helps businesses automate chaos using AI agents, n8n, and custom workflows. Connect with him on LinkedIn @automate-archit.

How I Saved a Client ₹85,000/Month on AI API Costs — A Practical Breakdown

Archit Mittal — Sat, 21 Mar 2026 12:48:11 +0000

Originally shared on LinkedIn where it reached 10,000+ professionals. Expanded with technical details and actionable strategies here.

A client was burning through ₹85,000/month on AI API calls.

In one weekend, we cut that to under ₹12,000.

I'm not exaggerating. This is real money saved by a real company that had no idea they were hemorrhaging cash on AI infrastructure.

The worst part? They thought that's just "the cost of doing AI."

It's not.

If you're using AI APIs in production—Claude, GPT-4, Gemini, whatever—there's a 90% chance you're overspending. This article walks through exactly how we diagnosed the problem and fixed it.

The Problem: Why Your AI Bill Looks Like a Mortgage Payment

Before the audit, here's what the client was doing:

Using Opus (₹15/1M tokens) for simple tasks — asking GPT-4-level models to classify customer emails or generate summaries when Haiku (₹0.80/1M tokens) would work fine.
Zero prompt caching — sending the same 50KB system prompt with every API call. That's like shipping the same dictionary with every word lookup.
No batch processing — every request hit the API in real-time, even for non-urgent tasks that could run at night at 50% discount.
Redundant API calls — the app was calling the same input multiple times within seconds because there was no response caching. Imagine asking your friend the same question twice instead of remembering the answer.
Token bloat — prompts weren't optimized. XML wrappers, unnecessary examples, verbose instructions—all padding the token count.

The client thought they needed the "best" model for everything. In reality, they needed the right model for each task.

The Audit: Finding Your Money Leaks

Here's the systematic process we followed:

Step 1: Collect Everything

We enabled detailed logging on all API calls:

import json
from datetime import datetime

def log_api_call(model, input_tokens, output_tokens, task_type, prompt_hash):
    log_entry = {
        "timestamp": datetime.now().isoformat(),
        "model": model,
        "input_tokens": input_tokens,
        "output_tokens": output_tokens,
        "task_type": task_type,
        "prompt_hash": prompt_hash,  # To detect redundancy
        "total_cost_usd": calculate_cost(model, input_tokens, output_tokens)
    }
    with open("api_audit.jsonl", "a") as f:
        f.write(json.dumps(log_entry) + "\n")

One week of logs told us everything.

Step 2: Categorize by Task Type

We grouped calls into buckets:

Email classification — 12,000 calls/week (should be Haiku)
Content summarization — 4,000 calls/week (Sonnet max)
Complex research synthesis — 800 calls/week (Opus only)
Code review — 2,200 calls/week (Sonnet)
Prompt engineering iteration — 3,500 calls/week (varies, but lots of waste here)

Step 3: Match Model to Complexity

This is where the magic happens. Not every task needs Opus.

Task Type	Current Model	Optimal Model	Annual Savings
Email classification	GPT-4 (₹12/1M in)	Claude Haiku (₹0.80/1M in)	₹42,000+
Customer support QA	GPT-4	Claude Sonnet (₹3/1M in)	₹28,000+
Content summarization	GPT-4 Turbo	Claude Sonnet	₹18,500+
Complex research	GPT-4 Turbo	Claude Opus (₹15/1M)	₹0 (necessary)
Prompt iteration	GPT-4	Claude Haiku	₹8,500+

Step 4: Spot Redundancy

Using the prompt hash from our logs, we found:

Same system prompt sent 47,000 times in one month. With caching, that would be 1 full call + 46,999 cached calls (90% cost reduction on those).
Same user inputs processed multiple times (within seconds). A simple (input_hash, output) cache would eliminate this.
Retry loops without exponential backoff — failed calls being retried immediately, multiplying tokens wasted.

The 5 Optimization Strategies That Worked

1. Model Matching (30% savings)

Simple rule: Use the simplest model that works for your task.

Haiku — Classification, formatting, extraction, simple routing (₹0.80/1M input)
Sonnet — Summarization, content generation, moderate reasoning (₹3/1M input)
Opus — Complex multi-step reasoning, code review, research synthesis (₹15/1M input)

We moved 60% of the client's workload from Opus/GPT-4 to Haiku/Sonnet.

Testing: Don't guess. Run a small batch through each model and measure latency + quality. Usually Haiku is 10% quality loss with 50-90% cost reduction.

2. Prompt Caching (45% savings)

Claude's prompt caching feature is a game-changer. It works like this:

First call: Send full prompt. (₹15 per 1M tokens)
Next 5,000+ calls: Send only the new query part. (₹0.30 per 1M tokens cached)

import anthropic

client = anthropic.Anthropic()

# Static system prompt (gets cached)
SYSTEM_PROMPT = """You are a customer support email classifier.
Categories: billing, technical_support, feature_request, complaint, other.
Respond with JSON: {"category": "...", "confidence": 0.95, "reasoning": "..."}"""

# This prompt gets cached on first call
response = client.messages.create(
    model="claude-opus-4-1-20250805",
    max_tokens=200,
    system=[
        {
            "type": "text",
            "text": SYSTEM_PROMPT,
            "cache_control": {"type": "ephemeral"}  # Cache for 5 mins
        }
    ],
    messages=[
        {"role": "user", "content": "Can you help me reset my password?"}
    ]
)

print(response.usage)
# usage.cache_read_input_tokens > 0 means caching worked

For the client:

50KB system prompt × 30,000 calls/month = 1.5B cached tokens
Cached tokens cost 90% less
Monthly savings: ₹18,000+

3. Batch Processing (35% savings for async tasks)

Not every API call needs to be real-time. Use the batch API for non-urgent tasks:

Normal API: ₹15/1M input tokens
Batch API: ₹5/1M input tokens (50% discount, 24-hour turnaround)

import anthropic
import json

client = anthropic.Anthropic()

# Prepare batch requests
batch_requests = []
for email in emails_to_classify:  # 10,000 emails
    batch_requests.append({
        "custom_id": f"email-{email['id']}",
        "params": {
            "model": "claude-opus-4-1-20250805",
            "max_tokens": 200,
            "system": "Classify this email...",
            "messages": [
                {"role": "user", "content": email['text']}
            ]
        }
    })

# Submit batch
batch = client.beta.messages.batches.create(
    requests=batch_requests
)

print(f"Batch ID: {batch.id}")
# Process results later

For the client's non-urgent tasks (nightly reports, weekly summaries), batch processing cut costs in half.

4. Response Caching (20% savings)

Don't ask the API the same question twice:

import hashlib

cache = {}  # Or Redis for production

def get_classification(text, model):
    # Create deterministic hash of input
    input_hash = hashlib.sha256(text.encode()).hexdigest()

    # Check cache first
    if input_hash in cache:
        return cache[input_hash]

    # Call API
    response = client.messages.create(
        model=model,
        messages=[{"role": "user", "content": text}]
    )

    result = response.content[0].text
    cache[input_hash] = result
    return result

# First call: hits API
result1 = get_classification("Can I reset my password?", "claude-haiku-4-5-20251001")

# Second call: same input, returns from cache instantly
result2 = get_classification("Can I reset my password?", "claude-haiku-4-5-20251001")

The client had duplicate email classifications happening within seconds. A simple cache (Redis, in-memory, doesn't matter) eliminated ~20% of redundant calls.

5. Token Optimization (15% savings)

Smaller prompts = fewer tokens = lower costs.

Before:

You are an expert customer service AI. Your role is to take customer emails
and classify them into one of several predefined categories. Please read
the email carefully and determine which category it belongs to.

Categories:
1. Billing & Payments
2. Technical Support & Bugs
3. Feature Requests
4. Complaints & Escalations
5. Other

Please respond in JSON format with the following structure:
{
  "category": "...",
  "confidence": 0.0-1.0,
  "reasoning": "..."
}

Here's the email:

After:

Classify the email into: billing, technical, feature_request, complaint, other.
Response: {"category": "...", "confidence": 0.0-1.0}

Email:

Same output, 60% fewer tokens.

The Results: Before & After

Metric	Before	After	Savings
Monthly API cost	₹85,000	₹12,000	₹73,000 (86%)
Avg tokens/call	2,840	1,100	61% reduction
API calls/month	340,000	280,000	18% fewer (redundancy removed)
Latency (p95)	850ms	420ms	50% faster (cache hits)
System accuracy	94%	94.2%	+0.2% (better model matching)

The real win? The client now has better performance AND lower costs. That's the point of optimization—efficiency compounds.

Your Turn: The Checklist

You can apply this to any AI project. Here's what to do Monday morning:

Week 1: Audit

[ ] Enable detailed logging on all API calls (model, tokens, task type)
[ ] Collect one week of data
[ ] Categorize tasks by complexity
[ ] Calculate per-task costs

Week 2: Low-Hanging Fruit

[ ] Downgrade non-critical tasks to cheaper models (test quality first)
[ ] Implement response caching if you have duplicate inputs
[ ] Optimize prompts (remove verbosity, examples, unnecessary structure)

Week 3: Advanced Optimizations

[ ] Set up prompt caching for static system prompts
[ ] Migrate non-urgent tasks to batch processing
[ ] Implement request deduplication

Week 4: Measure & Iterate

[ ] Compare new costs vs. baseline
[ ] Monitor quality metrics (didn't go down, right?)
[ ] Automate the audit—keep logging, check monthly

Tools & Resources

Logging & Analytics:

Python anthropic SDK (built-in logging)
langsmith.com (trace API calls across frameworks)
Datadog / Elastic (if you're at scale)

Caching:

Redis (production caching)
LRU cache (Python functools.lru_cache for testing)
Claude prompt caching (native, no setup)

Batch Processing:

Claude Batch API (native)
OpenAI Batch API

Cost Calculators:

anthropic.com/pricing (Claude)
openai.com/pricing (GPT models)
Build your own: (input_tokens × input_rate + output_tokens × output_rate) / 1_000_000

The Bigger Picture

This client went from thinking "AI is expensive" to building a sustainable, cost-efficient AI infrastructure.

The same principles apply whether you're:

Building an AI chatbot for customer support
Automating content generation at scale
Running batch analysis on document collections
Fine-tuning models for specific tasks

The key insight: Every ₹ you save on API costs is ₹1 that can go toward better infrastructure, faster iteration, or hiring more engineers.

Start with the audit. Everything else follows.

About the Author

I'm Archit Mittal (@automate-archit), an automation engineer helping companies save money and time with AI workflows. I've helped 30+ clients optimize their AI spending, cut API costs by 50-85%, and build sustainable automation architectures.

If you're dealing with similar cost problems or want to discuss AI automation strategies, let's connect:

LinkedIn: @automate-archit
Twitter/X: @automate_archit
1-on-1 consultations: topmate.io/automate_archit

Feel free to share this with your team. Cost optimization benefits everyone.