Forem: Archit Mittal

I Built a Claude Code Sub-Agent That Processes 2,000 Invoices a Day — Here's the Exact Setup

Archit Mittal — Mon, 20 Apr 2026 04:43:56 +0000

A small Gurgaon-based CA firm came to me last month with a recurring nightmare: 2,000+ vendor invoices landing in a shared Drive folder every day. Three junior accountants spending six hours each manually keying them into Tally. That's ~₹1.8L/month in salary cost for pure data entry.

They asked if an AI agent could handle it.

Short answer: yes. And not just "handle" — Claude Code sub-agents turned out to be the cleanest way I've seen to structure this kind of multi-step workflow. Here's exactly how I built it, plus the code you can fork today.

Why Claude Code sub-agents

If you haven't touched sub-agents yet: they're specialized Claude instances you can spawn from a main agent to handle a scoped task. Each has its own context window, its own system prompt, and its own toolset. You define them as markdown files in .claude/agents/ — no framework, no DAG, no visual editor to learn.

The killer feature for this workflow is context isolation. A 50-page invoice PDF doesn't bloat the main agent's context. Extraction happens in a sub-agent, and only the structured JSON result comes back.

Three other reasons I reached for sub-agents here:

Per-agent model selection. Validation runs on Haiku for pennies. Extraction runs on Sonnet for accuracy.
Tight tool scopes. The writer agent can touch the Tally bridge; the extractor cannot. Blast radius stays small.
Independent prompt versioning. Each .md file lives in git. When accuracy dips, git diff tells you why.

The architecture

For this case I used three sub-agents orchestrated by a tiny Python loop:

pdf-extractor — pulls vendor name, GSTIN, line items, totals
tally-validator — checks GST math, flags anomalies, matches against vendor master
tally-writer — pushes validated records into Tally via its ODBC bridge

Main orchestrator handles retries, quarantining, and Postgres logging.

Sub-agent #1: the PDF extractor

File: .claude/agents/pdf-extractor.md

---
name: pdf-extractor
description: "Extract structured invoice data from Indian GST invoice PDFs. Returns JSON with vendor, GSTIN, line items, and totals."
tools: Read, Bash
model: sonnet
---

You extract structured data from Indian GST invoices.

For each PDF the user names:
1. Read the PDF contents.
2. Identify: vendor name, GSTIN, invoice number, invoice date, line items (with HSN codes), CGST, SGST, IGST, total.
3. Return a single JSON object. No prose. No markdown fences.

If GSTIN is missing or fails the 15-character format check, return {"error": "invalid_gstin"}.

That's the whole prompt — under 15 lines. The magic is in the description field: the main agent uses it to decide when to delegate.

Sub-agent #2: the validator

---
name: tally-validator
description: Validate extracted invoice JSON against GST rules and vendor master. Returns pass/fail with reasons.
tools: Read, Bash
model: haiku
---

Input: invoice JSON from the pdf-extractor agent.

Check:
- GSTIN passes the Modulus-36 checksum.
- CGST + SGST equals IGST-equivalent for intra-state invoices; IGST-only for inter-state.
- Line item totals sum to invoice total within a ±₹1 tolerance.
- Vendor GSTIN exists in /data/vendor_master.csv.

Return {"valid": true} or {"valid": false, "reasons": [...]}.

I put this one on Haiku. It's deterministic validation — no reasoning required, just arithmetic and lookups. Cost per invoice dropped from ₹0.40 to ₹0.06 when I moved validation off Sonnet.

Sub-agent #3: the writer

---
name: tally-writer
description: Post a validated invoice JSON into Tally via the ODBC bridge. Returns the Tally voucher number on success.
tools: Bash
model: haiku
---

Input: validated invoice JSON.

Call /usr/local/bin/tally-push with the JSON on stdin. If exit code 0, return {"posted": true, "voucher": <stdout>}. Else return {"posted": false, "error": <stderr>}.

Do not retry. Do not modify the JSON. Do not summarise.

Boring on purpose. This agent should feel like a shell command.

The Python orchestrator

import subprocess
import json
from pathlib import Path

INBOX = Path("/srv/invoices/inbox")
DONE = Path("/srv/invoices/processed")
FAILED = Path("/srv/invoices/failed")

def run_claude(prompt: str) -> dict:
    result = subprocess.run(
        ["claude", "-p", prompt, "--output-format", "json"],
        capture_output=True, text=True, timeout=120,
    )
    if result.returncode != 0:
        raise RuntimeError(result.stderr)
    return json.loads(json.loads(result.stdout)["result"])

def process(pdf_path: Path) -> dict:
    prompt = (
        f"Use the pdf-extractor sub-agent on {pdf_path}, "
        f"then pass the result to tally-validator. "
        f"If valid, use tally-writer to post it. "
        f"Return the final status JSON only."
    )
    return run_claude(prompt)

for pdf in INBOX.glob("*.pdf"):
    try:
        result = process(pdf)
        dest = DONE if result.get("posted") else FAILED
        pdf.rename(dest / pdf.name)
    except Exception as e:
        (FAILED / f"{pdf.stem}.error").write_text(str(e))
        pdf.rename(FAILED / pdf.name)

Drop it on cron every 15 minutes:

*/15 * * * * cd /srv/invoices && python3 run.py >> /var/log/invoices.log 2>&1

Done.

Numbers from week one

2,047 invoices/day average throughput
94.3% auto-posted without human touch
5.7% kicked to an exception queue (mostly scanned PDFs with poor OCR)
Compute cost: ~₹840/day across all three sub-agents
Replaced roughly ₹1.8L/month of manual effort
Payback period: about 2 weeks

The 5.7% exception rate is the number I'd watch. Two weeks in, a quick tweak to the extractor's prompt around handwritten delivery challans dropped it to 3.1%.

Three things I'd tell past-me

1. Version your sub-agent prompts from day one. Commit the .claude/agents/ folder to the project repo. When accuracy dips after a model update, git diff tells you which prompt tweak broke it.

2. Log the JSON, not the prose. My first version captured the full agent transcript. Useless for debugging at 2 AM. Now I log only the structured JSON each sub-agent returns, plus the prompt and timestamp.

3. Don't over-orchestrate. My initial design had five sub-agents. Three was plenty. If two stages always run together and never branch, they should be one agent. Sub-agents are a scoping tool, not a UML diagram.

Try it this week

If you want to kick the tires on sub-agents, here's a 90-second starter:

mkdir -p .claude/agents
cat > .claude/agents/summarizer.md <<'EOF'
---
name: summarizer
description: Summarize a file in 3 bullet points. Use when the user asks for a quick file summary.
tools: Read
---
Read the file the user mentions. Return exactly 3 bullets. No preamble.
EOF

claude -p "Use the summarizer sub-agent on README.md"

That's it. From there, copy the invoice pattern above — one agent per scoped task, tight tool lists, clear descriptions.

The real unlock isn't Claude being clever. It's the boring discipline of splitting work into agents small enough that each one can be reasoned about in isolation. Everything else is plumbing.

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

Week in AI Recap: 7 Shifts That Actually Matter for Indian Developers (April 2026)

Archit Mittal — Sun, 19 Apr 2026 04:43:45 +0000

I spend my weeks watching AI news for one reason: I automate workflows for Indian businesses, and the ground shifts under my feet every Monday. Most of what trends on X this week isn't useful. A few things are. Here's the signal, filtered for developers in India who ship real work.

1. Agent frameworks are consolidating — pick one and move on

The "which agent framework" debate is finally cooling. Three winners keep showing up in production code reviews: the Claude Agent SDK for operator-style tasks, LangGraph for stateful pipelines, and plain function calling on top of OpenAI / Anthropic / Gemini APIs for the 80% of jobs that don't need a framework at all.

My take: if you're building internal ops tooling — GST reconciliation, vendor onboarding, invoice triage — skip the framework. A 60-line Python script with tool definitions outperforms most "agent platforms" by six months. Here's the shape I use:

import anthropic

client = anthropic.Anthropic()

TOOLS = [
    {
        "name": "fetch_gst_status",
        "description": "Fetch GST filing status for a GSTIN",
        "input_schema": {
            "type": "object",
            "properties": {"gstin": {"type": "string"}},
            "required": ["gstin"],
        },
    }
]

def run(user_msg):
    messages = [{"role": "user", "content": user_msg}]
    while True:
        resp = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=TOOLS,
            messages=messages,
        )
        if resp.stop_reason == "end_turn":
            return resp.content[-1].text
        # handle tool_use blocks, append tool_result, loop

Start here. Add complexity only when you can name the specific failure you're fixing.

2. Long context is cheap enough to abuse

Token prices for 200K+ context windows dropped again this week. For Indian teams dealing with PDF-heavy workflows — RERA filings, Income Tax orders, CBDT circulars — this changes the math. You no longer need RAG for a 300-page document. You paste it in, you ask the question, you're done — for roughly ₹3–5 per query on Sonnet-class models.

Does this kill RAG? No. For a 50,000-document corpus it's still essential. But for the common "make sense of this one fat PDF" case, vector databases have been over-engineered for two years.

3. Voice agents stopped being demos

Real production deployments I saw this week: a Pune-based clinic chain running outbound appointment reminders in Marathi and Hindi on a voice stack that costs under ₹2/minute. An edtech in Bangalore is using real-time voice for spoken English practice — latency under 400ms, good enough that kids don't game it.

The stack that shows up most often: Deepgram or Sarvam for ASR (Sarvam wins on Indic languages by a wide margin), a small LLM for routing, ElevenLabs or Bhashini for TTS. If you've been waiting for "voice AI is ready" — it's ready. Not for every use case, but the ones that work, work well.

4. Coding agents moved from autocomplete to delegation

The shift I watched this week in team Slacks: developers stopped saying "Copilot suggested" and started saying "I gave the agent the ticket." The mental model is different. You hand over a scoped task with acceptance criteria, you go make chai, you come back to a diff.

This isn't free. It works when:

The task has clear input/output contracts
Tests exist or can be written first
The code review discipline is still tight

It falls apart when teams treat agent output as trusted. I've seen two production incidents this quarter caused by unreviewed agent-written DB migrations. Review the diff. Always.

5. India's public AI stack shipped real things

The DPI + AI crossover keeps quietly shipping. Bhashini added better code-mixed Hinglish handling. ONDC's search layer gained semantic understanding for product descriptions. UPI's fraud detection got a visible accuracy bump — small merchants I talk to noticed fewer false declines this month.

If you build for Bharat, plug into these layers instead of building parallel ones. The cost math on a startup trying to replicate Indic NLP from scratch doesn't work.

6. Evals are the new moat

Every serious AI team I talked to this week was investing in evals, not prompts. The pattern: write 50–200 real examples with expected outputs, run your pipeline, score with a judge model, track drift over deploys.

Minimum viable eval in Python:

import json, anthropic

client = anthropic.Anthropic()
cases = json.load(open("evals.json"))

def judge(expected, got):
    prompt = (
        f"Expected:\n{expected}\n\n"
        f"Got:\n{got}\n\n"
        "Is this correct? Reply PASS or FAIL with a one-line reason."
    )
    r = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=100,
        messages=[{"role": "user", "content": prompt}],
    )
    return r.content[0].text.strip()

passed = 0
for c in cases:
    got = run_your_pipeline(c["input"])
    verdict = judge(c["expected"], got)
    if verdict.startswith("PASS"):
        passed += 1
    else:
        print(f"FAIL: {c['input'][:60]}  ->  {verdict}")

print(f"{passed}/{len(cases)} passed")

Run this before every deploy. You'll catch 80% of regressions that would otherwise ship.

7. The "AI doing accounting" story is real, and boring

I'll close on the topic I spend most of my time on. Last week I helped a mid-sized D2C brand cut their monthly reconciliation from 14 person-days to under 2. Nothing glamorous — a Python pipeline that pulls Razorpay settlements, tallies against Shopify orders, flags mismatches, and writes a Tally-compatible CSV. Savings: roughly ₹85,000/month in ops cost.

This is where AI is quietly winning in India. Not chatbots. Not "AI-powered" products. Just ordinary automation where one of the steps happens to call an LLM because regex would have taken three weeks to write.

If you're a developer looking for paid work in 2026, this is the niche. Every SME in Tier 1 and Tier 2 has reconciliation, vendor onboarding, compliance filing, or customer support workflows that are one weekend of focused work away from a 70% time reduction. The businesses don't know it. You can tell them.

What I'm watching next week

Pricing from the newest Indic-language foundation models
Whether updated DPDP rules change what data can flow through foreign-hosted LLMs
Real benchmarks (not vibes) on code-gen for Python-heavy automation

That's the signal. Everything else this week was noise — keep your head down and ship.

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

Weekend Project: Build a ₹0 Amazon India Price Tracker in 50 Lines of Python

Archit Mittal — Sat, 18 Apr 2026 04:43:35 +0000

Saturday afternoon. You've been eyeing that ₹45,000 laptop on Amazon India for three weeks. Does it dip during the Great Indian Sale? Does it spike on weekends? Nobody knows — because nobody is watching.

Today we'll fix that with ~50 lines of Python. No paid APIs, no ₹499/month SaaS, no Chrome extensions that sell your data. Just a weekend project you can finish before dinner.

What we're building

A tiny script that:

Visits an Amazon India product URL.
Scrapes the current price.
Logs it to a CSV with a timestamp.
Pings you on Telegram if the price drops below a target.

Total build time: ~45 minutes. Total cost: ₹0.

Step 1 — Install the basics

You need Python 3.9+ and two libraries:

pip install requests beautifulsoup4

That's it. No Selenium, no headless Chrome, no scraping service.

Step 2 — The scraper

Amazon blocks bare requests calls, so we send a real browser's User-Agent and accept-language header. This works 90% of the time for public product pages; if you hit a CAPTCHA, just wait an hour and try again.

import requests
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 13_5) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/124.0.0.0 Safari/537.36"
    ),
    "Accept-Language": "en-IN,en;q=0.9",
}

def get_price(url: str) -> tuple[str, int]:
    r = requests.get(url, headers=HEADERS, timeout=20)
    r.raise_for_status()
    soup = BeautifulSoup(r.text, "html.parser")

    title = soup.select_one("#productTitle").get_text(strip=True)
    price_el = soup.select_one(".a-price .a-offscreen")
    if not price_el:
        raise RuntimeError("Price element not found — page layout changed.")

    # "₹45,999.00" -> 45999
    raw = price_el.get_text(strip=True).replace("₹", "").replace(",", "")
    rupees = int(float(raw))
    return title, rupees

Two things worth noting:

The CSS selectors (#productTitle, .a-price .a-offscreen) are stable on Amazon India as of 2026, but Amazon rotates layouts. If your script breaks, right-click the price → Inspect → copy a fresh selector.
Always check raise_for_status(). A 503 usually means you hit Amazon's rate limit — back off, don't hammer it.

Step 3 — The logger

CSV is fine. You don't need a database for a personal price tracker.

import csv
from datetime import datetime
from pathlib import Path

LOG = Path("prices.csv")

def log_price(title: str, rupees: int) -> None:
    new = not LOG.exists()
    with LOG.open("a", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        if new:
            w.writerow(["timestamp", "title", "rupees"])
        w.writerow([
            datetime.now().isoformat(timespec="seconds"),
            title,
            rupees,
        ])

After a week of data you'll have a CSV you can open in Excel or pandas. Plot it. Watch the weekend dips.

Step 4 — The Telegram alert

Create a Telegram bot via @botfather, note the token, and message your bot once so it knows your chat ID (fetch it from https://api.telegram.org/bot<TOKEN>/getUpdates).

import os

BOT_TOKEN = os.environ["TG_BOT_TOKEN"]
CHAT_ID = os.environ["TG_CHAT_ID"]

def ping(msg: str) -> None:
    requests.post(
        f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
        data={"chat_id": CHAT_ID, "text": msg},
        timeout=10,
    )

Environment variables, not hardcoded tokens. Always.

Step 5 — Tie it together

PRODUCTS = [
    ("https://www.amazon.in/dp/B0CHX1W1XY", 45000),  # (url, target_rupees)
    ("https://www.amazon.in/dp/B0BDHWDR12", 12000),
]

def main():
    for url, target in PRODUCTS:
        try:
            title, price = get_price(url)
            log_price(title, price)
            if price <= target:
                ping(f"💸 {title[:60]} is ₹{price:,} (target ₹{target:,})\n{url}")
            print(f"OK ₹{price:,} — {title[:60]}")
        except Exception as e:
            print(f"FAIL {url[:60]} — {e}")

if __name__ == "__main__":
    main()

That's the full 50 lines. Save it as price_tracker.py.

Step 6 — Schedule it

On macOS or Linux, cron runs it every 6 hours:

0 */6 * * * cd /home/you/tracker && /usr/bin/python3 price_tracker.py >> tracker.log 2>&1

On Windows, Task Scheduler does the same. On a Raspberry Pi? Even better — your tracker runs 24/7 on ₹200/year of electricity.

What you'll notice after 2 weeks

Running this on 5–10 products for two weeks taught me three things I didn't know:

Amazon India prices move daily, not seasonally. Same laptop: ₹45,999 on Tuesday, ₹43,499 on Saturday, ₹46,499 on Monday.
"Deals of the Day" aren't usually the lowest price that month. The real dip often happens the week after a sale ends.
Pin codes matter. A product shown at ₹1,299 in Mumbai can be ₹1,399 in a Tier-2 pin code — the script above uses whatever pin code Amazon defaults to. Add a ?pincode=110001 variant if you want consistency.

Ways to extend it this weekend

If you finish early, three upgrades worth ~30 min each:

Flipkart support — different selectors, same pattern. You now track both in one CSV.
7-day rolling min/max — load the CSV with pandas, alert only when price hits a new 7-day low.
Chart generator — a weekly email with a matplotlib PNG of every product you're tracking.

A small warning

Scraping at human-level frequency (every few hours, a handful of products) is fine. Scraping 10,000 URLs every 60 seconds will get your IP blocked and is against Amazon's ToS. Be a good citizen. If you need scale, pay for a proper scraping API — but for personal use, this script is plenty.

That's the whole weekend project. Clone, customize, commit. By Sunday evening you'll have a working tracker and a week of data starting to pile up.

Ping me on Dev.to if you ship it — I read every reply.

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

How I Built an Automated PDF Invoice Parser in 75 Lines of Python

Archit Mittal — Thu, 16 Apr 2026 04:51:41 +0000

Last month, a CA firm in Pune asked me to look at their invoice processing workflow. Their team of 3 was spending 15+ hours every week manually copying data from PDF invoices into Tally and Excel sheets. Vendor name, GSTIN, line items, totals, tax breakdowns — all done by hand.

I built them an automated parser in 75 lines of Python. It now processes 200+ invoices per day with 95% accuracy. Here is exactly how I did it.

The Problem: Death by Data Entry

Here is what the workflow looked like before automation:

Download PDF invoices from email (50-80 per day)
Open each PDF manually
Squint at the layout, find the vendor name, GSTIN, invoice number
Copy line items one by one into Excel
Calculate tax totals and verify against the PDF
Paste into Tally for accounting

Average time per invoice: 4-5 minutes. That is 4+ hours daily for one person. Three people were doing this.

The firm was paying roughly Rs 45,000/month in salaries just for data entry. The error rate hovered around 8% — because humans get tired after the 30th invoice.

The Tech Stack

I kept it dead simple. No fancy ML models, no cloud APIs, no expensive OCR services.

pdfplumber — extracts text and tables from PDFs (free, open source)
pandas — structures the extracted data into clean DataFrames
re (regex) — pattern matching for GSTIN, invoice numbers, dates
openpyxl — exports results to Excel files

Total cost: Rs 0. All open-source libraries.

pip install pdfplumber pandas openpyxl

The Code: 75 Lines That Replace 3 People

Here is the complete script. I will walk through each section below.

import pdfplumber
import pandas as pd
import re
import os
from datetime import datetime

# Regex patterns for Indian invoices
GSTIN_PATTERN = r'\d{2}[A-Z]{5}\d{4}[A-Z]{1}[A-Z\d]{1}[Z]{1}[A-Z\d]{1}'
INVOICE_PATTERN = r'(?:Invoice\s*(?:No|Number|#)?[\s:]*)([\w\-/]+)'
DATE_PATTERN = r'\d{2}[/-]\d{2}[/-]\d{4}'
AMOUNT_PATTERN = r'(?:Total|Grand\s*Total|Net\s*Amount)[\s:]*(?:Rs\.?|INR)?\s*([\d,]+\.?\d*)'

def extract_invoice_data(pdf_path):
    """Extract structured data from a single PDF invoice."""
    data = {
        'file': os.path.basename(pdf_path),
        'vendor_gstin': None,
        'invoice_no': None,
        'date': None,
        'total_amount': None,
        'line_items': []
    }

    with pdfplumber.open(pdf_path) as pdf:
        full_text = ''
        for page in pdf.pages:
            full_text += page.extract_text() or ''

            # Extract tables for line items
            tables = page.extract_tables()
            for table in tables:
                if len(table) > 1:  # Has header + data
                    for row in table[1:]:
                        cleaned = [str(cell).strip() if cell else '' for cell in row]
                        if any(cleaned):
                            data['line_items'].append(cleaned)

        # Extract fields using regex
        gstin_matches = re.findall(GSTIN_PATTERN, full_text)
        if gstin_matches:
            data['vendor_gstin'] = gstin_matches[0]

        inv_match = re.search(INVOICE_PATTERN, full_text, re.IGNORECASE)
        if inv_match:
            data['invoice_no'] = inv_match.group(1)

        date_matches = re.findall(DATE_PATTERN, full_text)
        if date_matches:
            data['date'] = date_matches[0]

        amount_match = re.search(AMOUNT_PATTERN, full_text, re.IGNORECASE)
        if amount_match:
            data['total_amount'] = float(amount_match.group(1).replace(',', ''))

    return data

def process_invoice_folder(folder_path, output_file='parsed_invoices.xlsx'):
    """Process all PDFs in a folder and export to Excel."""
    results = []
    pdf_files = [f for f in os.listdir(folder_path) if f.lower().endswith('.pdf')]

    print(f'Found {len(pdf_files)} PDF invoices to process...')

    for i, filename in enumerate(pdf_files, 1):
        filepath = os.path.join(folder_path, filename)
        try:
            invoice = extract_invoice_data(filepath)
            results.append({
                'File': invoice['file'],
                'Vendor GSTIN': invoice['vendor_gstin'],
                'Invoice No': invoice['invoice_no'],
                'Date': invoice['date'],
                'Total Amount': invoice['total_amount'],
                'Line Items Count': len(invoice['line_items'])
            })
            print(f'  [{i}/{len(pdf_files)}] Parsed: {filename}')
        except Exception as e:
            print(f'  [{i}/{len(pdf_files)}] FAILED: {filename} - {e}')
            results.append({'File': filename, 'Error': str(e)})

    df = pd.DataFrame(results)
    df.to_excel(output_file, index=False)
    print(f'\nDone! Results saved to {output_file}')
    print(f'Successfully parsed: {len([r for r in results if "Error" not in r])}/{len(results)}')
    return df

# Usage
if __name__ == '__main__':
    df = process_invoice_folder('./invoices')

Breaking Down the Key Parts

GSTIN Extraction

The GSTIN (Goods and Services Tax Identification Number) follows a fixed 15-character format across India. The regex \d{2}[A-Z]{5}\d{4}[A-Z]{1}[A-Z\d]{1}[Z]{1}[A-Z\d]{1} matches this pattern reliably. First two digits are state code, next 10 characters are PAN, and the rest are entity-specific.

Table Extraction with pdfplumber

This is where pdfplumber really shines. Instead of trying to parse free-form text line by line, page.extract_tables() detects table boundaries in the PDF and returns structured 2D arrays. For most GST invoices, line items sit in a table with columns like Description, HSN Code, Quantity, Rate, and Amount.

The Fallback Strategy

Not every invoice is perfectly formatted. Some are scanned images (which need OCR — a story for another day). Some have weird layouts. The try/except block ensures one bad PDF does not crash the entire batch. Failed files get logged so you can handle them manually.

Results After 30 Days

Here is what changed after deploying this script:

Processing time: 15+ hours/week dropped to about 20 minutes (the script runs in under 2 minutes, plus 15-18 minutes for human review of flagged items)
Error rate: 8% dropped to under 2% (most remaining errors are from badly scanned PDFs)
Monthly savings: Roughly Rs 35,000/month in reduced data entry labour
Staff redeployment: 2 of the 3 data entry staff now handle client communication and follow-ups instead

The script paid for itself on day one.

Making It Production-Ready

For the actual deployment, I added a few extras that pushed it beyond 75 lines:

1. Email integration — A simple IMAP script that auto-downloads PDF attachments from specific senders.

2. Confidence scoring — Each extracted field gets a confidence score. If the GSTIN regex matches but the checksum fails, it gets flagged for human review.

3. Tally XML export — Instead of Excel, the final version exports directly to Tally-compatible XML, cutting out another manual step.

4. Watchdog monitoring — Uses Python's watchdog library to monitor a folder. Drop a PDF in, get structured data out in seconds.

Try It Yourself

Here is a quick way to test this on your own invoices:

mkdir invoice_parser && cd invoice_parser
pip install pdfplumber pandas openpyxl

Save the script above as parser.py, drop some PDF invoices into an invoices/ folder, and run:

python parser.py

You will get a clean parsed_invoices.xlsx with all extracted data.

What I Learned

Start with regex, not ML. For structured documents like Indian GST invoices, regex handles 90% of cases. ML is overkill until you hit that last 10%.
pdfplumber beats PyPDF2 for tables. I wasted a day with PyPDF2 before switching. pdfplumber's table detection is significantly better.
Always build in human review. Automation does not mean zero humans. The sweet spot is automating the boring 95% and letting humans handle the interesting edge cases.
Measure before and after. The Rs 35,000/month savings number sold the client on expanding automation to other workflows. Without that number, it is just a cool script.

What Is Next

I am currently building v2 that adds OCR support for scanned invoices using pytesseract, and a simple web dashboard using Streamlit where the CA firm's team can upload invoices and download results. That will be next week's article.

If you are dealing with similar document processing problems — whether it is invoices, purchase orders, bank statements, or any structured PDF — the approach is the same: extract text, match patterns, structure data, export.

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

Have a workflow that is eating your team's time? Drop a comment below — I might build it and write about it next.

How I Automated Invoice Processing for a ₹3 Crore Business — Saved 120 Hours/Month

Archit Mittal — Wed, 15 Apr 2026 04:51:39 +0000

Last year, a textile trading firm in Surat approached me with a problem that's painfully common across Indian SMBs: their accounts team of 4 people was spending 6 hours every single day manually matching purchase invoices against delivery challans and bank statements.

That's 120 hours a month — burnt on copy-pasting numbers between Excel sheets and Tally.

Here's how I automated the entire pipeline with Python, saving them ₹2.4 lakh/month in operational costs and reducing errors to near-zero.

The Problem: Death by Manual Reconciliation

This ₹3 crore/year business processes roughly 800 invoices per month from 60+ suppliers. Every invoice had to be:

Downloaded from email or WhatsApp
Manually entered into an Excel tracker
Cross-checked against the delivery challan
Matched with the corresponding bank payment
Flagged if any amount didn't match

The team was drowning. Invoices got missed, duplicate payments happened twice in Q3, and month-end closing took 5 extra days.

The Solution: A 3-Stage Python Pipeline

I built a lightweight automation system using Python — no expensive ERP, no SaaS subscription. Just clean code running on a ₹30,000 mini-PC sitting in their office.

Stage 1: Invoice Extraction with PDF Parsing

import pdfplumber
import re
from pathlib import Path

def extract_invoice_data(pdf_path: str) -> dict:
    """Extract key fields from a supplier invoice PDF."""
    with pdfplumber.open(pdf_path) as pdf:
        full_text = ""
        for page in pdf.pages:
            full_text += page.extract_text() or ""

    # Extract invoice number
    inv_match = re.search(
        r'Invoice\s*#?\s*:?\s*([A-Z0-9\-/]+)',
        full_text, re.IGNORECASE
    )

    # Extract total amount (handles Rs. and INR formats)
    amt_match = re.search(
        r'(?:Total|Grand\s*Total|Net\s*Amount)\s*:?\s*(?:Rs\.?|INR)\s*([\d,]+\.?\d*)',
        full_text, re.IGNORECASE
    )

    # Extract date
    date_match = re.search(
        r'Date\s*:?\s*(\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4})',
        full_text, re.IGNORECASE
    )

    # Extract GSTIN
    gst_match = re.search(
        r'\d{2}[A-Z]{5}\d{4}[A-Z]{1}[A-Z\d]{1}[Z]{1}[A-Z\d]{1}',
        full_text
    )

    return {
        "invoice_number": inv_match.group(1) if inv_match else None,
        "amount": float(amt_match.group(1).replace(",", "")) if amt_match else None,
        "date": date_match.group(1) if date_match else None,
        "gstin": gst_match.group(0) if gst_match else None,
        "source_file": Path(pdf_path).name
    }

# Process all invoices in a folder
invoice_folder = Path("./invoices/april_2025")
results = []
for pdf_file in invoice_folder.glob("*.pdf"):
    data = extract_invoice_data(str(pdf_file))
    results.append(data)
    print(f"Extracted: {data['invoice_number']} | Amount: {data['amount']}")

This script processes 800 PDFs in under 3 minutes. The old manual process? 4 people x 2 hours = 8 person-hours.

Stage 2: Smart Matching Engine

import pandas as pd
from difflib import SequenceMatcher

def fuzzy_match_score(str1: str, str2: str) -> float:
    """Calculate similarity between two strings."""
    if not str1 or not str2:
        return 0.0
    return SequenceMatcher(None, str1.upper(), str2.upper()).ratio()

def reconcile_invoices(
    invoices: pd.DataFrame,
    challans: pd.DataFrame,
    tolerance: float = 100.0
) -> pd.DataFrame:
    """Match invoices against delivery challans."""
    matched = []
    unmatched_invoices = []

    for _, inv in invoices.iterrows():
        best_match = None
        best_score = 0

        for _, challan in challans.iterrows():
            amount_diff = abs(inv["amount"] - challan["amount"])
            if amount_diff > tolerance:
                continue

            name_score = fuzzy_match_score(
                inv.get("supplier", ""),
                challan.get("supplier", "")
            )

            score = (1 - amount_diff / max(inv["amount"], 1)) * 0.6 + name_score * 0.4

            if score > best_score:
                best_score = score
                best_match = challan

        if best_match is not None and best_score > 0.75:
            matched.append({
                "invoice_no": inv["invoice_number"],
                "challan_no": best_match["challan_number"],
                "invoice_amt": inv["amount"],
                "challan_amt": best_match["amount"],
                "difference": inv["amount"] - best_match["amount"],
                "confidence": round(best_score * 100, 1),
                "status": "MATCHED"
            })
        else:
            unmatched_invoices.append({
                "invoice_no": inv["invoice_number"],
                "invoice_amt": inv["amount"],
                "status": "UNMATCHED - NEEDS REVIEW"
            })

    return pd.DataFrame(matched + unmatched_invoices)

The key insight: Indian invoices frequently have small rounding differences (a few rupees on GST calculations). The tolerance parameter handles this gracefully instead of flagging false mismatches.

Stage 3: Daily Report Generation

from datetime import datetime

def generate_daily_report(reconciled: pd.DataFrame, output_dir: str = "./reports"):
    """Generate a summary report for the accounts team."""
    today = datetime.now().strftime("%Y-%m-%d")

    total_invoices = len(reconciled)
    matched = reconciled[reconciled["status"] == "MATCHED"]
    unmatched = reconciled[reconciled["status"] != "MATCHED"]

    total_matched_value = matched["invoice_amt"].sum()
    total_discrepancy = matched["difference"].abs().sum()

    report_lines = [
        f"DAILY RECONCILIATION REPORT - {today}",
        "=" * 45,
        f"Total Invoices Processed  : {total_invoices}",
        f"Successfully Matched      : {len(matched)} ({len(matched)/total_invoices*100:.1f}%)",
        f"Needs Manual Review       : {len(unmatched)}",
        f"Total Matched Value       : INR {total_matched_value:,.2f}",
        f"Total Discrepancies       : INR {total_discrepancy:,.2f}",
        "",
        "TOP UNMATCHED INVOICES:"
    ]

    for _, row in unmatched.head(10).iterrows():
        report_lines.append(f"  - {row['invoice_no']}: INR {row['invoice_amt']:,.2f}")

    report = "\n".join(report_lines)
    report_path = f"{output_dir}/reconciliation_{today}.txt"
    with open(report_path, "w") as f:
        f.write(report)

    print(f"Report saved: {report_path}")
    return report_path

The Results: 4 Months Later

Here's what changed after deploying this system:

Time saved: 120 hours/month reduced to 8 hours/month (only manual review of flagged items)

Cost saved: Approximately 2.4 lakh per month (3 team members redeployed to higher-value work)

Error rate: Dropped from around 5% to 0.3%

Month-end closing: From 5 extra days down to same-day

Duplicate payments: Zero since deployment

The ROI? The entire project cost 1.8 lakh (my fee + hardware). It paid for itself in 23 days.

Why This Matters for Indian Businesses

India has 63 million+ MSMEs. Most run their back-office on Excel + Tally + WhatsApp. The opportunity to automate isn't just about saving money — it's about freeing up humans to do work that actually needs a brain.

You don't need a 50 lakh ERP implementation. A focused Python script running on a cheap mini-PC can transform operations for businesses doing 1-10 crore annually.

What You Can Automate Today

If you're a developer looking to build automation solutions for Indian businesses, start here:

Invoice processing (PDF to structured data)
Bank statement reconciliation (CSV parsing + matching)
GST return preparation (aggregation + formatting)
Inventory alerts (threshold monitoring + WhatsApp notifications)
Payment follow-ups (aging analysis + automated reminders)

Each of these is a 50K-2L project for a freelance automation developer.

Try It Yourself

Clone the extraction script above, point it at a folder of invoice PDFs, and see what it pulls out. You'll be surprised how much structure exists in "unstructured" documents.

The full pipeline code (with CSV export, email integration, and WhatsApp alerts) is on my GitHub. Drop a comment if you want the link.

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

7 AI Developments From This Week That Developers Should Actually Care About (April 2026)

Archit Mittal — Sun, 12 Apr 2026 04:50:57 +0000

Every week in AI feels like a month used to. Here's what actually happened in the week of April 4–11, 2026 — and more importantly, what it means for you as a developer.

1. Meta Drops "Muse Spark" — AI Coming to Every Meta App

Meta announced Muse Spark, their new AI model rolling out across Facebook, Instagram, WhatsApp, Messenger, and Ray-Ban Meta AI glasses.

The real headline? Meta is spending $115–135 billion on AI capex in 2026 — nearly double last year. That's not R&D money. That's infrastructure. When a company spends that much on GPUs, they're planning to make AI the default interface for everything.

What this means for developers: If you're building anything that integrates with Meta's ecosystem, expect AI-first APIs. Start thinking about how your apps will interact with AI intermediaries, not just human users.

2. Google Open-Sources Gemma 4 — Reasoning Models for Everyone

Google released Gemma 4 under the Apache 2.0 license. These models are specifically built for advanced reasoning and agentic workflows, and Google claims unprecedented intelligence-per-parameter.

Here's a quick way to try it locally:

# Install and run Gemma 4 locally with Ollama
import subprocess
import requests

# Pull the model
subprocess.run(["ollama", "pull", "gemma4"])

# Simple inference
response = requests.post("http://localhost:11434/api/generate", json={
    "model": "gemma4",
    "prompt": "Write a Python function to detect anomalies in time-series data using z-scores",
    "stream": False
})

print(response.json()["response"])

Why it matters: Open-source models matching commercial quality means you can run production-grade AI without API costs. For Indian startups watching their burn rate, this is massive.

3. Anthropic Reveals Claude Mythos Preview — And It Found Zero-Days

The most technically striking development was Anthropic's discussion of an unreleased model called Claude Mythos Preview. This model demonstrated strong capabilities in identifying and exploiting zero-day vulnerabilities — and these capabilities emerged surprisingly quickly during training.

Alongside this, Anthropic launched Project Glasswing, a defensive collaboration framework for cybersecurity.

Developer takeaway: AI-powered security scanning is becoming real. If you're not already using AI tools in your CI/CD security pipeline, you're falling behind.

# Example: Simple AI-assisted dependency vulnerability check
import json
import subprocess

def scan_dependencies():
    """Run safety check and parse results"""
    result = subprocess.run(
        ["pip-audit", "--format", "json"],
        capture_output=True, text=True
    )

    vulns = json.loads(result.stdout)

    critical = [v for v in vulns if v.get("severity") == "critical"]

    if critical:
        print(f"🚨 Found {len(critical)} critical vulnerabilities!")
        for vuln in critical:
            print(f"  - {vuln['name']} {vuln['version']}: {vuln['description']}")
    else:
        print("✅ No critical vulnerabilities found")

    return vulns

# Run as part of your CI pipeline
scan_dependencies()

4. The Anti-Distillation Coalition Is Here

OpenAI, Anthropic, and Google announced a joint effort to detect and counter unauthorized model distillation. This is aimed at labs (some Chinese, specifically named) that allegedly use outputs from frontier models to train cheaper alternatives.

What developers should know: If you're fine-tuning models using outputs from GPT, Claude, or Gemini, read the updated Terms of Service carefully. The line between "using an API" and "distilling a model" is getting legally interesting.

5. Google's TurboQuant Slashes KV-Cache Memory at ICLR 2026

Google's research team unveiled TurboQuant at ICLR 2026. It significantly reduces the memory overhead caused by the KV cache — one of the biggest bottlenecks when running large models locally.

Why you should care: If you've ever tried running a 70B model locally and watched your GPU memory explode, TurboQuant addresses exactly that. Expect this to land in vLLM and llama.cpp within weeks.

# Monitor your GPU memory during inference
import subprocess
import json

def check_gpu_memory():
    """Quick GPU memory check — useful before loading large models"""
    result = subprocess.run(
        ["nvidia-smi", "--query-gpu=memory.used,memory.total,memory.free", 
         "--format=csv,nounits,noheader"],
        capture_output=True, text=True
    )

    used, total, free = map(int, result.stdout.strip().split(", "))
    usage_pct = (used / total) * 100

    print(f"GPU Memory: {used}MB / {total}MB ({usage_pct:.1f}% used)")
    print(f"Free: {free}MB")

    if free < 4000:
        print("⚠️ Low GPU memory — consider quantized models")

    return {"used": used, "total": total, "free": free}

check_gpu_memory()

6. MCP Crosses 97 Million Installs

Anthropic's Model Context Protocol (MCP) crossed 97 million installs in March 2026. Every major AI provider now ships MCP-compatible tooling.

This is no longer experimental — MCP is foundational infrastructure for building AI agents. If you're building developer tools or AI integrations, MCP compatibility isn't optional anymore.

7. Agentic AI Is Now the Default Paradigm

Every major model release in April 2026 emphasizes agentic capabilities. Computer-use (AI operating actual software interfaces) is becoming standard. Open models from Mistral, Meta (Llama 4), and DeepSeek now match commercial models on many benchmarks.

The shift is clear: we're moving from chatbots to AI employees that can break down goals, execute across systems, and adapt when things go wrong.

Practical next step for developers:

# Skeleton for a simple AI agent loop
import time

def agent_loop(task: str, max_steps: int = 10):
    """Basic agent loop pattern — the foundation of agentic AI"""

    context = {"task": task, "steps": [], "status": "running"}

    for step in range(max_steps):
        # 1. Plan next action based on context
        action = plan_next_action(context)

        # 2. Execute the action
        result = execute_action(action)

        # 3. Update context with results
        context["steps"].append({
            "action": action,
            "result": result,
            "timestamp": time.time()
        })

        # 4. Check if task is complete
        if is_task_complete(context):
            context["status"] = "completed"
            break

        # 5. Handle errors and adapt
        if result.get("error"):
            context["steps"].append({
                "action": "error_recovery",
                "result": handle_error(result["error"]),
                "timestamp": time.time()
            })

    return context

# This pattern powers everything from Claude's computer-use
# to AutoGPT to custom business automation agents

The Bottom Line

April 2026 is confirming a few clear trends:

Open models are catching up fast — Gemma 4 and Llama 4 are closing the gap with commercial offerings
Agentic AI is the new normal — every release emphasizes autonomous, multi-step capability
Security is the next frontier — both offensive and defensive AI capabilities are accelerating
Infrastructure costs are dropping — TurboQuant and quantization improvements make local deployment more practical every month

The developers who thrive in this environment are the ones who stop watching from the sidelines and start building with these tools today. Pick one thing from this list and try it this week.

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

[Boost]

Archit Mittal — Sat, 11 Apr 2026 14:38:26 +0000

Persistent memory for 17,000+ models via MLH

MLH Team for Major League Hacking (MLH)

Apr 9

The "Stateless" AI Era is a Massive Engineering Tax

#ai #architecture #llm #softwareengineering

Comments 9

2 min read

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.