DEV Community: Archit Mittal

Build a Bulk PDF Invoice Renamer in 55 Lines of Python

Archit Mittal — Fri, 01 May 2026 12:53:58 +0000

Last month, my CA messaged me at 11pm: "Bhai, send all April invoices in a single zip, named properly." I had 47 PDF invoices in my Downloads folder, all with names like Invoice (3).pdf, download.pdf, and INV_FINAL_FINAL_v2.pdf.

Two hours of manual renaming wasn't on my agenda. So I wrote a Python script. By the time my chai was done, the script was done. 47 invoices renamed, audit-ready.

Here's the entire thing — 55 lines, no fluff.

What it does

The script scans a folder of PDF invoices and renames each file to a clean, sortable format:

2026-04-15_AcmeServices_INV-1042_15000.pdf

It pulls four things from each invoice: the invoice date, vendor name (from the GSTIN line), invoice number, and total amount in ₹. If a field is missing, it falls back to a placeholder so nothing gets lost.

The Code

import re
import sys
from pathlib import Path
from datetime import datetime
import pdfplumber

DATE_RE = re.compile(r"(\d{1,2})[\-/\s]([A-Za-z]{3,9}|\d{1,2})[\-/\s](\d{2,4})")
GSTIN_RE = re.compile(r"\b\d{2}[A-Z]{5}\d{4}[A-Z][A-Z\d]Z[A-Z\d]\b")
INV_RE = re.compile(r"(?:Invoice\s*(?:No\.?|#|Number)\s*[:\-]?\s*)([A-Z0-9\-/]+)", re.I)
AMT_RE = re.compile(r"(?:Total|Grand\s*Total|Amount\s*Payable)[^\d₹]{0,15}₹?\s*([\d,]+\.?\d{0,2})", re.I)

def parse_date(text):
    m = DATE_RE.search(text)
    if not m: return None
    raw = m.group(0)
    for fmt in ("%d-%m-%Y", "%d/%m/%Y", "%d %b %Y", "%d %B %Y", "%d-%b-%Y"):
        try:
            return datetime.strptime(raw, fmt).strftime("%Y-%m-%d")
        except ValueError:
            continue
    return None

def vendor_from_gstin(text):
    m = GSTIN_RE.search(text)
    if not m: return None
    line = next((l for l in text.splitlines() if m.group(0) in l), "")
    parts = [p.strip() for p in line.split(m.group(0)) if p.strip()]
    return re.sub(r"[^A-Za-z0-9]+", "", parts[0])[:20] if parts else None

def extract(pdf_path):
    with pdfplumber.open(pdf_path) as pdf:
        text = "\n".join((p.extract_text() or "") for p in pdf.pages[:2])
    inv = INV_RE.search(text)
    amt = AMT_RE.search(text)
    return {
        "date": parse_date(text) or "NoDate",
        "vendor": vendor_from_gstin(text) or "UnknownVendor",
        "invoice": (inv.group(1) if inv else "NoInv").replace("/", "-"),
        "amount": (amt.group(1).replace(",", "").split(".")[0] if amt else "0"),
    }

def safe_rename(src, new_name):
    dest = src.with_name(f"{new_name}.pdf")
    n = 1
    while dest.exists() and dest != src:
        dest = src.with_name(f"{new_name}_{n}.pdf")
        n += 1
    src.rename(dest)
    return dest.name

def main(folder):
    folder = Path(folder)
    for pdf in folder.glob("*.pdf"):
        try:
            f = extract(pdf)
            new = f"{f['date']}_{f['vendor']}_{f['invoice']}_{f['amount']}"
            renamed = safe_rename(pdf, new)
            print(f"OK {pdf.name} -> {renamed}")
        except Exception as e:
            print(f"FAIL {pdf.name}: {e}")

if __name__ == "__main__":
    main(sys.argv[1] if len(sys.argv) > 1 else ".")

How it works

Four regexes do most of the heavy lifting.

The date regex matches common Indian invoice formats: 15/04/2026, 15-Apr-2026, 15 April 2026. The parser tries five strptime formats and keeps the first that sticks.

The GSTIN regex matches the 15-character GST identifier (state code + PAN + entity code + Z + checksum). Once found, the script grabs the text on the same line and assumes that's the vendor name. Crude but works in 90% of real invoices I've seen.

The invoice number regex looks for "Invoice No", "Invoice #", or "Invoice Number" followed by an alphanumeric token. The amount regex scans for "Total", "Grand Total", or "Amount Payable" followed by a ₹ value, then strips commas and decimals so file sorting works.

pdfplumber only reads the first two pages of each PDF — invoice headers and totals almost always appear there, and skipping deeper pages keeps it fast. On my 47-file folder it finished in 8 seconds.

Running it

pip install pdfplumber
python rename_invoices.py ~/Downloads/april_invoices

Output:

OK Invoice (3).pdf -> 2026-04-15_AcmeServices_INV-1042_15000.pdf
OK download.pdf -> 2026-04-18_TataCloud_TC-2026-099_47200.pdf
OK INV_FINAL_FINAL_v2.pdf -> 2026-04-22_FreshworksIndia_FW8821_8400.pdf

Edge cases I hit (and you will too)

Scanned PDFs. pdfplumber returns empty text for image-only PDFs. The try/except in main skips them without crashing — but you'll need OCR (Tesseract via pytesseract) to actually read them. I keep a separate folder for scanned ones.

Multi-page invoices with the total on page 3+. Rare in B2B India, but if you hit it, change pdf.pages[:2] to pdf.pages — slower but complete.

Vendors without GSTIN. International vendors won't have one. The fallback "UnknownVendor" gets used; you can extend vendor_from_gstin to also scan the first line of the document.

Duplicate filenames. safe_rename adds a _1, _2 suffix instead of overwriting. I learned this the hard way after losing a Tata Cloud invoice to a clash.

Why this format

Sorting by filename gives you a chronological audit trail. Your CA can scan a folder and see April's invoices in date order without opening anything. The amount in the filename is a sanity check — quick visual confirmation when reconciling with bank statements.

Where to go from here

A few extensions I've layered on top of this base script:

Pipe the extracted data straight into a Google Sheet for monthly P&L
Move processed PDFs into year/month subfolders
Flag any invoice where the GSTIN checksum doesn't validate (there's a published algorithm)
Send a Telegram alert if any single invoice crosses a threshold

55 lines was the goal. Fancier tooling can wait until the basics work.

Follow me on Twitter @automate_archit for daily AI automation tips.

Build a GST Invoice PDF Extractor in 53 Lines of Python

Archit Mittal — Wed, 29 Apr 2026 12:52:54 +0000

If you run a small business in India, you've felt this pain: a folder full of PDF invoices from different vendors, every one formatted slightly differently, and somebody has to type GSTIN, invoice number, date, and total amount into a spreadsheet. I built a single-file Python script that processes the whole folder in seconds and validates GSTINs along the way.

Total: 53 lines including imports and CLI plumbing. Here's the whole thing.

What it does

Walks a folder of PDF invoices
Pulls out GSTINs (vendor + buyer) and validates the 15-character format
Grabs invoice number, date, and total amount with regex
Writes a clean CSV you can paste into Tally, Zoho Books, or any ledger

The code

# invoice_extractor.py
import re, sys, csv
from pathlib import Path
import pdfplumber

GSTIN_RE   = re.compile(r'\b(\d{2}[A-Z]{5}\d{4}[A-Z][A-Z\d]Z[A-Z\d])\b')
INV_NUM_RE = re.compile(r'Invoice\s*(?:No\.?|Number|#)\s*[:\-]?\s*([A-Z0-9\-/]+)', re.I)
DATE_RE    = re.compile(r'(\d{2}[\-/]\d{2}[\-/]\d{4})')
AMOUNT_RE  = re.compile(r'(?:Grand\s*Total|Total|Amount)[^\d]*(?:Rs\.?|INR)?\s*([\d,]+\.\d{0,2})', re.I)

def is_valid_gstin(g: str) -> bool:
    if len(g) != 15:
        return False
    state = int(g[:2])
    return 1 <= state <= 38

def extract_from_pdf(path: Path) -> dict:
    text = ""
    with pdfplumber.open(path) as pdf:
        for page in pdf.pages:
            text += (page.extract_text() or "") + "\n"
    gstins  = [g for g in GSTIN_RE.findall(text) if is_valid_gstin(g)]
    inv     = INV_NUM_RE.search(text)
    date    = DATE_RE.search(text)
    amounts = [float(a.replace(",", "")) for a in AMOUNT_RE.findall(text)]
    return {
        "file":         path.name,
        "vendor_gstin": gstins[0] if gstins else "",
        "buyer_gstin":  gstins[1] if len(gstins) > 1 else "",
        "invoice_no":   inv.group(1) if inv else "",
        "date":         date.group(1) if date else "",
        "total_inr":    max(amounts, default=0.0),
    }

def main(folder: str) -> None:
    rows = [extract_from_pdf(p) for p in sorted(Path(folder).glob("*.pdf"))]
    if not rows:
        print("No PDFs found."); return
    out = Path(folder) / "invoices_extracted.csv"
    with out.open("w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=rows[0].keys())
        w.writeheader(); w.writerows(rows)
    print(f"Processed {len(rows)} invoices then wrote {out}")

if __name__ == "__main__":
    main(sys.argv[1] if len(sys.argv) > 1 else ".")

Save it as invoice_extractor.py, drop a folder of PDFs next to it, then:

pip install pdfplumber
python invoice_extractor.py ./invoices

You'll get an invoices_extracted.csv with one row per PDF.

How the GSTIN regex works

A valid GSTIN is exactly 15 characters laid out like this:

2-digit state code
5-letter PAN prefix
4-digit PAN middle
1-letter PAN suffix
1 entity number (alphanumeric)
Literal Z
1 checksum character (alphanumeric)

The regex captures that shape and is_valid_gstin adds a sanity check on the state code (1 through 38 covers every state and union territory). The 15th character is technically a mod-36 checksum, so you can layer that in if you want bulletproof matching. For 95 percent of accounting cleanup, the format check is enough.

Why the amount regex uses `max(amounts)`

Indian invoices repeat amounts everywhere: subtotal, CGST, SGST, IGST, taxable value, grand total. Taking the largest match from anything that follows "Total", "Grand Total" or "Amount" almost always lands on the grand total. If your vendors have weirder layouts, tighten the regex to require "Grand Total" specifically and skip "Total" alone.

A real example

I tested this on 47 PDF invoices from one quarter of vendor bills (electricity, internet, three SaaS subscriptions, freight, the works). It processed them in 6.2 seconds on an M1 Air. Two had no extractable text because they were scans, which is the OCR case I describe below. The other 45 came out clean and tied to the Tally ledger on the first try.

Sample output row:

file=ApolloPharmacy_Mar2026.pdf
vendor_gstin=29AABCA1234B1Z7
buyer_gstin=29AAACS5678E1ZR
invoice_no=AP/2526/00412
date=18-03-2026
total_inr=14237.50

Common edge cases and how to handle them

Scanned PDFs. pdfplumber only extracts embedded text. If a vendor sends you a scan, extract_text() returns empty. Add a pytesseract fallback that runs OCR when the text count is below a threshold.

Multi-page invoices. Already handled. The loop concatenates every page before regex runs.

Wrong amount picked up. Happens when the invoice has a "Late fee total" line above the grand total. Fix by requiring "Grand Total" or by sorting by position rather than value.

Date in DD-MMM-YYYY format. The regex matches numeric dates only. Add an alternation for \d{2}[\-/\s][A-Za-z]{3}[\-/\s]\d{4} if your vendors use month names.

What I would add next

Tally XML export instead of CSV (one extra function, maps the dict to Tally's voucher schema)
Dedup detection by (vendor_gstin, invoice_no) to catch double entries before they hit the books
Date normalization to ISO so it sorts in Excel
OCR fallback with pytesseract for scanned PDFs
Batch upload to a Google Sheet using the Sheets API instead of writing a local CSV

The bigger point

The whole script is one file. No frameworks, no databases, no scheduler dependency. Drop it in a cron job or a Windows Task Scheduler entry and your books update themselves at midnight before you get to the office.

If you have ever paid a junior accountant for two hours a day to do data entry on PDFs, this is the kind of automation that recovers that cost in a week. At even a conservative 200 invoices a month at 3 minutes each, you are looking at 10 hours per month, every month, that goes back into work that actually moves the business.

Steal the code. Tweak the regex for whatever your vendors do. Ship it.

Follow me on Twitter @automate_archit for daily AI automation tips.

Build a UPI Transaction Reconciliation Tool in 52 Lines of Python

Archit Mittal — Mon, 27 Apr 2026 12:53:44 +0000

I track every UPI transaction across PhonePe, Google Pay, and Paytm. Three apps, three different CSV exports, and a tax season that looks like a hostage negotiation.

Last weekend I got tired of opening three spreadsheets side by side and built one Python script to merge, deduplicate, and categorize every UPI transaction into a single reconciled Excel file. The whole thing is 52 lines.

Here's what it does:

Reads CSV exports from any of the three UPI apps
Normalizes the wildly different column names each app uses
Detects duplicates (the same payment showing up in two apps)
Categorizes transactions by merchant keywords (food, fuel, rent, bills, shopping)
Exports a clean Excel file with a transactions sheet and a monthly category pivot in ₹

The Code

import pandas as pd
from pathlib import Path
from datetime import datetime

SCHEMA = {
    "phonepe": {"date": "Transaction Date", "amount": "Amount (INR)", "party": "Merchant", "ref": "UTR"},
    "gpay":    {"date": "Date",             "amount": "Amount",       "party": "To",       "ref": "Transaction ID"},
    "paytm":   {"date": "Txn Date",         "amount": "Amount(₹)",    "party": "Payee",    "ref": "Order ID"},
}

CATEGORIES = {
    "food":  ["zomato", "swiggy", "dominos", "kfc", "mcdonald"],
    "fuel":  ["hpcl", "iocl", "bpcl", "petrol", "indian oil"],
    "rent":  ["rent", "landlord", "housing"],
    "bills": ["airtel", "jio", "vi ", "tata power", "electricity"],
    "shop":  ["amazon", "flipkart", "myntra", "blinkit", "zepto"],
}

def categorize(party: str) -> str:
    p = (party or "").lower()
    for cat, keywords in CATEGORIES.items():
        if any(k in p for k in keywords):
            return cat
    return "other"

def load(path: Path, app: str) -> pd.DataFrame:
    df = pd.read_csv(path)
    cols = SCHEMA[app]
    out = pd.DataFrame({
        "date":   pd.to_datetime(df[cols["date"]], errors="coerce"),
        "amount": pd.to_numeric(df[cols["amount"]].astype(str).str.replace("[₹,]", "", regex=True), errors="coerce"),
        "party":  df[cols["party"]].astype(str),
        "ref":    df[cols["ref"]].astype(str),
        "app":    app,
    })
    out["category"] = out["party"].apply(categorize)
    return out.dropna(subset=["date", "amount"])

def reconcile(folder: Path) -> pd.DataFrame:
    frames = [load(p, app) for app in SCHEMA for p in folder.glob(f"{app}*.csv")]
    if not frames:
        raise SystemExit("No UPI CSVs found.")
    combined = pd.concat(frames, ignore_index=True).sort_values("date")
    combined["minute"] = combined["date"].dt.floor("min")
    combined = combined.drop_duplicates(subset=["minute", "amount", "party"], keep="first").drop(columns="minute")
    combined["month"] = combined["date"].dt.to_period("M").astype(str)
    return combined

def export(df: pd.DataFrame, out_path: Path) -> None:
    monthly = df.pivot_table(index="month", columns="category", values="amount", aggfunc="sum", fill_value=0)
    with pd.ExcelWriter(out_path, engine="openpyxl") as xl:
        df.to_excel(xl, sheet_name="transactions", index=False)
        monthly.to_excel(xl, sheet_name="monthly_by_category")
    print(f"Saved {len(df)} transactions to {out_path}")

if __name__ == "__main__":
    df = reconcile(Path("./statements"))
    export(df, Path(f"upi_reconciled_{datetime.now():%Y_%m_%d}.xlsx"))

How it works

The schema dict. PhonePe calls the date column "Transaction Date." GPay calls it "Date." Paytm calls it "Txn Date." Same data, three names. The SCHEMA dict maps each app's column names to a standard set so the rest of the code never has to care which app a row came from. Adding a new app means one more entry in SCHEMA and zero changes anywhere else.

Amount cleanup. Paytm sneaks the ₹ symbol into the amount column. PhonePe uses comma-formatted numbers. The str.replace("[₹,]", "", regex=True) strips both before pd.to_numeric, and errors="coerce" turns any unparseable cell into NaN so the final dropna can sweep it out.

The deduplication trick. When the same UPI transaction shows up in two apps (which happens when you screenshot a payment and Paytm catalogs it from your gallery, or when GPay picks up an SMS confirmation Paytm has already logged), the timestamps usually differ by a few seconds. Floor the timestamp to the minute, drop_duplicates on (minute, amount, party), and you keep one copy of each real transaction. After three months of data this cut my row count by about 18 percent.

Categorization. A simple substring match on the merchant name. Add your own keywords to CATEGORIES. After three months of running this, my "food" category alone has 47 distinct merchant strings (different Zomato franchise codes, mis-spellings, you name it) that all map to the same bucket.

The export. Two sheets in one Excel file. transactions has every reconciled row. monthly_by_category pivots them into a grid you can paste straight into your CA's template at year-end.

How I actually use it

I export CSVs from each app on the first weekend of every month and drop them in a statements/ folder named like phonepe_april.csv, gpay_april.csv, paytm_april.csv. Run the script, get a single Excel file. The whole reconciliation that used to eat my Sunday morning now takes twelve seconds.

The categorization saved me during my GST filing for Q4 — I could see immediately that I'd spent ₹38,000 on shopping vs the ₹12,000 I'd loosely budgeted. Painful but useful. It also caught a ₹1,499 recurring charge from a streaming service I'd cancelled in November but was still being billed for. That one find paid for the entire weekend project.

Where to take it next

Three things I added after the first draft:

A --month CLI flag that filters to a single month — useful when slicing a quarter for tax filing.
A manual_overrides.csv so I can tag a specific UTR with the right category without polluting the keyword list. The override file gets joined on the ref column and wins over the keyword match.
A simple matplotlib bar chart of category totals, saved as a PNG, dropped into my monthly review note.

If you want the version with all three additions, ping me — happy to share. The base script lives in my python-automation-starter repo on GitHub.

A note on edge cases: refunds show up as positive amounts in PhonePe but negative in GPay. If you care about net spend, multiply PhonePe rows where the merchant string contains "refund" by -1 before reconciling. I do this in a tiny preprocessor function I left out of the 52-line version for brevity — it's three lines and you'll know where to put it.

Twelve seconds. Three apps. One Excel file. Worth a Sunday afternoon.

Follow me on Twitter @automate_archit for daily AI automation tips.

Build a GST Invoice Generator in 80 Lines of Python

Archit Mittal — Sun, 26 Apr 2026 04:12:47 +0000

If you're a freelancer, consultant, or small business owner in India, you've probably paid ₹500–₹2000/month for invoicing software you barely use. After helping a CA friend automate his client billing last week, I wrote a clean GST invoice generator in 80 lines of Python. It handles HSN codes, CGST/SGST split for intra-state, IGST for inter-state, and outputs a professional PDF — all from a simple dictionary input.

This is the same script I now use to invoice my own automation consulting clients. Total cost: zero. Total time saved: about three hours per month.

What it does

Pass in your business details, the buyer's GSTIN, line items, and tax rates. The script:

Auto-detects whether the transaction is intra-state (split into CGST + SGST) or inter-state (single IGST line).
Computes line-level taxable amount, tax, and total.
Generates a clean A4 PDF with your branding, HSN codes, and the mandatory GST breakdown.
Names the file with the invoice number so it's audit-ready.

The full script

You'll need one library:

pip install reportlab

Here's the entire generator. Save it as gst_invoice.py:

from reportlab.lib.pagesizes import A4
from reportlab.lib import colors
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
from reportlab.lib.styles import getSampleStyleSheet
from datetime import date

def generate_gst_invoice(seller, buyer, items, invoice_no, inv_date=None):
    inv_date = inv_date or date.today().isoformat()
    same_state = seller["state_code"] == buyer["state_code"]
    rows = [["#", "Description", "HSN", "Qty", "Rate", "Taxable", "Tax%", "Tax", "Total"]]
    sub_total = total_tax = grand_total = 0

    for i, it in enumerate(items, 1):
        taxable = round(it["qty"] * it["rate"], 2)
        tax = round(taxable * it["gst"] / 100, 2)
        line_total = round(taxable + tax, 2)
        sub_total += taxable
        total_tax += tax
        grand_total += line_total
        rows.append([i, it["desc"], it["hsn"], it["qty"],
                     f"{it['rate']:.2f}", f"{taxable:.2f}",
                     f"{it['gst']}%", f"{tax:.2f}", f"{line_total:.2f}"])

    if same_state:
        tax_rows = [["CGST", f"{total_tax/2:.2f}"], ["SGST", f"{total_tax/2:.2f}"]]
    else:
        tax_rows = [["IGST", f"{total_tax:.2f}"]]
    tax_rows.append(["Grand Total (INR)", f"{grand_total:.2f}"])

    filename = f"Invoice_{invoice_no}.pdf"
    doc = SimpleDocTemplate(filename, pagesize=A4, title=f"Invoice {invoice_no}")
    styles = getSampleStyleSheet()
    story = []

    story.append(Paragraph(f"<b>{seller['name']}</b>", styles["Title"]))
    story.append(Paragraph(f"{seller['address']}<br/>GSTIN: {seller['gstin']}", styles["Normal"]))
    story.append(Spacer(1, 12))
    story.append(Paragraph(f"<b>Tax Invoice #{invoice_no}</b>   Date: {inv_date}", styles["Heading3"]))
    story.append(Paragraph(f"<b>Bill To:</b> {buyer['name']}<br/>{buyer['address']}<br/>GSTIN: {buyer['gstin']}", styles["Normal"]))
    story.append(Spacer(1, 12))

    item_table = Table(rows, repeatRows=1, hAlign="LEFT")
    item_table.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#1f2937")),
        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
        ("GRID", (0, 0), (-1, -1), 0.4, colors.grey),
        ("FONTSIZE", (0, 0), (-1, -1), 9),
        ("ALIGN", (3, 1), (-1, -1), "RIGHT"),
    ]))
    story.append(item_table)
    story.append(Spacer(1, 12))

    summary = Table(tax_rows, hAlign="RIGHT", colWidths=[140, 90])
    summary.setStyle(TableStyle([
        ("FONTNAME", (0, -1), (-1, -1), "Helvetica-Bold"),
        ("LINEABOVE", (0, -1), (-1, -1), 0.8, colors.black),
        ("ALIGN", (1, 0), (1, -1), "RIGHT"),
    ]))
    story.append(summary)
    story.append(Spacer(1, 18))
    story.append(Paragraph("<i>This is a computer-generated invoice and does not require a signature.</i>", styles["Italic"]))

    doc.build(story)
    return filename


if __name__ == "__main__":
    seller = {"name": "Mittal Automation Studio", "address": "Sector 62, Noida, UP",
              "gstin": "09ABCDE1234F1Z5", "state_code": "09"}
    buyer  = {"name": "Acme Retail Pvt Ltd", "address": "Bandra West, Mumbai, MH",
              "gstin": "27FGHIJ5678K2Z9", "state_code": "27"}
    items = [
        {"desc": "Workflow automation setup", "hsn": "998313", "qty": 1, "rate": 45000, "gst": 18},
        {"desc": "Monthly support retainer",   "hsn": "998313", "qty": 3, "rate": 12000, "gst": 18},
    ]
    out = generate_gst_invoice(seller, buyer, items, "INV-2026-014")
    print(f"Generated: {out}")

How it works, in plain English

The state-code check is the entire trick. Indian GST law splits tax based on whether buyer and seller are in the same state — if yes, you charge CGST + SGST (each half the rate); if no, you charge IGST (full rate). Here we read the first two digits of the GSTIN (which encode the state) and branch accordingly.

The line-item loop computes taxable value, tax, and total per row, then accumulates the grand total. Everything else is layout — the seller block on top, the bill-to in the middle, line items in a dark-header table, and a right-aligned summary with the legally required tax breakdown.

Extending it

A few easy upgrades I've added in production:

Numbers in words. GST law requires the total amount to be spelled out. Add num2words(grand_total, lang="en_IN") and append it to the summary.
QR code. RBI now requires a UPI/payment QR on B2B invoices over ₹500 crore turnover. Generate one with qrcode and embed it via Image from reportlab.
Bulk run. Wrap generate_gst_invoice in a loop over a CSV. I produce 40 client invoices on the 1st of every month with a single command.
Email send. Pipe the PDF into smtplib and you've replaced a ₹1500/month invoicing tool entirely.

Why this beats SaaS for solo operators

The real win isn't the ₹18,000/year you save. It's that the invoice template, the numbering scheme, and the data layout all live in your repo. When your CA asks for a year's worth of invoices in a specific format, it's a ten-second loop, not a support ticket.

If you're billing fewer than 200 invoices a month and your needs are reasonably stable, an 80-line script will outlast three SaaS subscription cycles.

Follow me on Twitter @automate_archit for daily AI automation tips. Code for this project: github.com/automate-archit/python-automation-starter

Build Your First AI Agent in 60 Lines of Python — No Framework Needed

Archit Mittal — Sat, 25 Apr 2026 01:44:03 +0000

Everyone's talking about AI agents, but most tutorials start with heavyweight frameworks, API keys, and 500+ lines of boilerplate.

What if you could build a functional AI agent in just 60 lines of pure Python?

No LangChain. No CrewAI. No framework at all.

Let's do it.

What We're Building

A simple AI agent that can:

Take a goal as input
Break it into subtasks
Execute each subtask using tools
Return a final result

Think of it as the minimal viable agent — the skeleton you can extend into anything.

The Architecture

Our agent follows the classic Observe → Think → Act loop:

┌─────────────┐
│   USER GOAL │
└──────┬──────┘
       │
       ▼
┌──────────────┐
│  THINK (LLM) │◄──────┐
└──────┬───────┘       │
       │               │
       ▼               │
┌──────────────┐       │
│  ACT (Tool)  │───────┘
└──────┬───────┘
       │
       ▼
┌──────────────┐
│    RESULT    │
└──────────────┘

The Code (60 Lines)

import json
import os
from anthropic import Anthropic

client = Anthropic()

# Define tools the agent can use
tools = [
    {
        "name": "calculator",
        "description": "Performs arithmetic calculations",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression to evaluate"}
            },
            "required": ["expression"]
        }
    },
    {
        "name": "search_notes",
        "description": "Search through local notes/files",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"}
            },
            "required": ["query"]
        }
    }
]

def execute_tool(name, input_data):
    if name == "calculator":
        try:
            return str(eval(input_data["expression"]))
        except:
            return "Error: Invalid expression"
    elif name == "search_notes":
        # Simulate search — replace with real implementation
        return f"Found 3 notes matching '{input_data['query']}'"
    return "Unknown tool"

def run_agent(goal, max_steps=5):
    messages = [{"role": "user", "content": goal}]
    system = "You are an AI agent. Use the provided tools to accomplish the user's goal. When done, provide a final answer."

    for step in range(max_steps):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=system,
            tools=tools,
            messages=messages
        )

        # Check if agent wants to use a tool
        if response.stop_reason == "tool_use":
            tool_block = next(b for b in response.content if b.type == "tool_use")
            result = execute_tool(tool_block.name, tool_block.input)
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": [{"type": "tool_result", "tool_use_id": tool_block.id, "content": result}]})
            print(f"Step {step+1}: Used {tool_block.name} → {result}")
        else:
            # Agent is done
            final = next(b.text for b in response.content if hasattr(b, "text"))
            print(f"\nAgent Result: {final}")
            return final

    return "Max steps reached"

# Run it
run_agent("What is 15% of 847, then round to nearest integer?")

How It Works

Lines 1-4: Import dependencies. We only need the Anthropic SDK.

Lines 6-30: Define tools as JSON schemas. Claude understands these natively — no wrapper needed.

Lines 32-40: Tool execution. Dead simple if/else. Replace with real implementations (API calls, database queries, file operations).

Lines 42-65: The agent loop. This is the core. Send messages → check if Claude wants a tool → execute → feed result back → repeat.

Why This Matters

Every "agent framework" is essentially wrapping this exact loop with abstractions. Understanding the raw pattern means:

You debug faster — no framework magic to untangle
You extend easier — add tools by adding elif blocks
You own the code — no dependency updates breaking your agent

What to Build Next

From this 60-line skeleton, you can build:

A personal assistant — add calendar, email, and file tools
A code reviewer — add git diff and lint tools
A content pipeline — add publishing APIs as tools (I use this exact pattern to automate my content across 6 platforms)
A data analyst — add SQL and chart tools

The Takeaway

You don't need a framework to build AI agents. You need:

An LLM that supports tool use (Claude, GPT-4, etc.)
A loop that feeds tool results back
Tools defined as JSON schemas

That's it. 60 lines. No magic.

I'm Archit — I automate chaos. Follow me for more practical AI automation tutorials.

Currently building a system that runs scheduled AI agents across 6 platforms daily with zero human intervention. More on that soon.

How I Saved a Mumbai CA Firm ₹18 Lakh/Year by Automating GST Invoice Reconciliation

Archit Mittal — Wed, 22 Apr 2026 04:57:08 +0000

Last month, I worked with a mid-sized CA firm in Andheri, Mumbai. They had 4 junior accountants whose full-time job was reconciling GSTR-2B data with purchase invoices for 80+ clients. Each reconciliation took 6-8 hours per client per month.

The math was brutal: 4 accountants × ₹35,000/month × 12 months = ₹16.8 lakh/year in salaries, plus ₹1.2 lakh in infrastructure and overhead. Total: ₹18 lakh/year of manual work that a 200-line Python script could replace.

Here is exactly how I did it.

The Problem

Every month, Indian businesses running on GST deal with two data sources:

GSTR-2B JSON from the GST portal — purchases reported by your suppliers.
Purchase register exported from Tally, Zoho Books, Busy, or plain Excel.

An accountant then matches invoice numbers, GSTIN, taxable values, and tax amounts row by row. Mismatches — wrong GSTIN, missing invoices, ITC eligibility flags — get flagged manually. It is tedious, error-prone, and scales linearly with client count.

The firm's owner told me plainly: "We quote ₹5,000/client for monthly reconciliation. We spend ₹8,000 worth of accountant hours on it. Every new client makes us less profitable."

That was the unit economics problem I needed to fix.

The Solution: A 3-Part Python Pipeline

I built a three-step pipeline that runs in about 4 minutes per client instead of 8 hours.

Step 1: Parse GSTR-2B JSON

The JSON from the GST portal is nested. Flatten it into a reconciliation-ready DataFrame:

import json
import pandas as pd
from pathlib import Path

def parse_gstr2b(json_path: Path) -> pd.DataFrame:
    """Flatten GSTR-2B JSON into a reconciliation-ready DataFrame."""
    with open(json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    rows = []
    b2b_section = data.get('data', {}).get('docdata', {}).get('b2b', [])

    for supplier in b2b_section:
        gstin = supplier.get('ctin', '')
        supplier_name = supplier.get('trdnm', '')

        for invoice in supplier.get('inv', []):
            rows.append({
                'supplier_gstin': gstin,
                'supplier_name': supplier_name,
                'invoice_no': invoice.get('inum', '').strip().upper(),
                'invoice_date': invoice.get('dt', ''),
                'taxable_value': float(invoice.get('val', 0)),
                'igst': float(invoice.get('iamt', 0)),
                'cgst': float(invoice.get('camt', 0)),
                'sgst': float(invoice.get('samt', 0)),
                'itc_eligible': invoice.get('itcavl', 'Y') == 'Y',
            })

    return pd.DataFrame(rows)

Step 2: Normalize the Purchase Register

Client data comes in 15 different formats. Column names are inconsistent across Tally, Zoho, Busy, and handcrafted Excel sheets. I normalize everything to the same schema before reconciling:

def load_purchase_register(file_path: Path) -> pd.DataFrame:
    """Handle Tally exports, Zoho CSVs, and client Excel files."""
    if file_path.suffix == '.csv':
        df = pd.read_csv(file_path)
    else:
        df = pd.read_excel(file_path, sheet_name=0)

    # Column aliases seen across 80+ clients
    alias_map = {
        'GSTIN': 'supplier_gstin',
        'Party GSTIN': 'supplier_gstin',
        'Vendor GSTIN': 'supplier_gstin',
        'Invoice Number': 'invoice_no',
        'Bill No': 'invoice_no',
        'Bill Number': 'invoice_no',
        'Taxable Amount': 'taxable_value',
        'Basic Amount': 'taxable_value',
        'IGST Amount': 'igst',
        'CGST Amount': 'cgst',
        'SGST Amount': 'sgst',
    }

    df = df.rename(columns={k: v for k, v in alias_map.items() if k in df.columns})
    df['invoice_no'] = df['invoice_no'].astype(str).str.strip().str.upper()

    numeric_cols = ['taxable_value', 'igst', 'cgst', 'sgst']
    for col in numeric_cols:
        if col in df.columns:
            df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)

    return df

Step 3: Reconcile and Flag Mismatches

This is the heart of the script. Outer-join both datasets on GSTIN and invoice number, then tag every row with a reconciliation status:

def reconcile(gstr2b: pd.DataFrame, purchase: pd.DataFrame, tolerance: float = 1.0) -> pd.DataFrame:
    """Match on GSTIN + invoice_no. Flag tax differences above tolerance."""
    merged = gstr2b.merge(
        purchase,
        on=['supplier_gstin', 'invoice_no'],
        how='outer',
        suffixes=('_2b', '_book'),
        indicator=True,
    )

    def classify(row):
        if row['_merge'] == 'left_only':
            return 'MISSING_IN_BOOKS'
        if row['_merge'] == 'right_only':
            return 'MISSING_IN_2B'

        diff_igst = abs(row.get('igst_2b', 0) - row.get('igst_book', 0))
        diff_cgst = abs(row.get('cgst_2b', 0) - row.get('cgst_book', 0))
        diff_sgst = abs(row.get('sgst_2b', 0) - row.get('sgst_book', 0))

        if max(diff_igst, diff_cgst, diff_sgst) > tolerance:
            return 'TAX_MISMATCH'

        diff_taxable = abs(
            row.get('taxable_value_2b', 0) - row.get('taxable_value_book', 0)
        )
        if diff_taxable > tolerance:
            return 'VALUE_MISMATCH'

        return 'MATCHED'

    merged['status'] = merged.apply(classify, axis=1)
    return merged

The Orchestrator

A small driver wraps everything into an Excel report the accountant can email to the client:

def run_reconciliation(client_code: str, month: str):
    base = Path(f'/clients/{client_code}/{month}')

    gstr2b = parse_gstr2b(base / 'gstr2b.json')
    purchase = load_purchase_register(base / 'purchase_register.xlsx')
    result = reconcile(gstr2b, purchase)

    summary = result['status'].value_counts().to_dict()
    output_path = base / f'reco_{client_code}_{month}.xlsx'

    with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
        result.to_excel(writer, sheet_name='Full_Reconciliation', index=False)
        for status in ['MISSING_IN_BOOKS', 'MISSING_IN_2B', 'TAX_MISMATCH']:
            subset = result[result['status'] == status]
            subset.to_excel(writer, sheet_name=status, index=False)

    print(f'{client_code} {month}: {summary}')
    return output_path

Drop this into a cron job, point it at a folder structure like /clients/ABC123/2026-03/, and you have a nightly reconciliation run for every client.

The Results — 60 Days Later

After running this pipeline across all 80 clients for two months:

Metric	Before	After
Hours per client / month	7 hrs	15 min
Accountants needed	4	1 (review only)
Monthly labour cost	₹1.4 lakh	₹45,000
Error rate	4-6%	under 0.5%
Client turnaround	3-5 days	Same day

Three of the four junior accountants were not laid off — they were redeployed to higher-value advisory work (ITR-3 filings, tax planning, GST notice responses) at ₹60,000/month. A real upgrade for them, and higher revenue per head for the firm.

Annual savings: approximately ₹18 lakh. Script cost: one weekend of my time, plus ₹0/month in infra (it runs on their existing laptop via a Windows Task Scheduler job).

Gotchas I Hit

A few things that tripped me up the first time and are worth calling out:

Invoice number normalization is the hardest part. Suppliers write "INV-001", "INV/001", "Inv 001", and "invoice 1" for the same bill. On top of the .strip().upper() normalization, I added a difflib.SequenceMatcher fuzzy-match layer with a 0.85 cutoff for leftover unmatched rows. It caught another 3% of matches that would otherwise have been false negatives.
Rounding differences in CGST/SGST. Tally and the GST portal occasionally round in opposite directions. A ₹0.50 tolerance on tax heads removes about 90% of false mismatches.
Credit notes live in a different JSON section. They are under cdnr (credit/debit notes for registered) inside GSTR-2B, not b2b. Parse them separately and flip the sign.
ITC ineligibility flags under Rule 42/43 are not always set correctly by suppliers. The script flags these for human review rather than auto-accepting — human judgment still matters here.

Who Can Use This Today

If you run or work at a CA firm, a tax consultancy, or any business with 20+ vendor invoices per month, this pipeline pays for itself in week one. The full production script is around 200 lines. Swap pandas for polars if you are processing 100,000+ rows per month.

The pattern generalizes. Any reconciliation that compares two structured data sources is a 1-2 day Python project that can eliminate a full-time role:

Bank statements vs. books of accounts
Payroll register vs. PF/ESI challans
Sales register vs. e-way bills
Shopify/Amazon settlement reports vs. GSTR-1

India has roughly 1.4 million CA firms and tax consultants. Most of them are still doing this by hand. The tooling gap is staggering — and the ROI on closing it is immediate.

If you try this and run into trouble, the three places things usually break are: invoice number cleaning, JSON schema drift when the GSTN portal updates, and the pd.read_excel engine choice for large files (use openpyxl for .xlsx, xlrd==1.2.0 for legacy .xls).

Ship it on Monday. Save ₹1 lakh by Friday.

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

Automate Your UPI Transaction Tracking: 60 Lines of Python (Free, Works Offline)

Archit Mittal — Tue, 21 Apr 2026 04:54:29 +0000

UPI processes over 16 billion transactions a month in India. If you are like most people, you pay through PhonePe for groceries, GPay for cabs, Paytm for utilities, and your bank app for rent. At every month-end, reconciling spending across all those apps is a nightmare.

I built a Python script that reads exported SMS transaction alerts from my phone, parses them into a clean pandas DataFrame, categorises spending, and prints a monthly breakdown — all in 60 lines, offline, at zero cost.

Here is exactly how it works.

The Problem: Five Apps, Zero Consolidated View

My typical month looks like this:

Groceries: PhonePe (about ₹8,000)
Food delivery: GPay (about ₹3,500)
Cabs: Paytm (about ₹2,200)
Rent: HDFC app (₹28,000)
Bills: Multiple apps (about ₹6,500)

No single app shows everything. Export is locked behind paid "Pro" tiers. Third-party aggregators want permission to read every SMS on my phone. I did not want to hand my financial history to yet another vendor.

SMS is the answer. Every UPI transaction sends a bank-originated SMS. If I can export SMS and parse them locally, I own the data.

Step 1: Export SMS to CSV

Android phones can export SMS via "SMS Backup & Restore" or similar apps. You get an XML or CSV file. Drop it into a folder like ~/upi-data/sms.csv.

The file looks like:

date,address,body
2026-04-15,HDFCBK,"Rs.450.00 debited from A/c XX1234 on 15-APR for UPI/412839-BIGBASKET"
2026-04-15,AXISBK,"INR 120 spent on UPI to OLA-CABS ref 339400 on 15-Apr"

Step 2: The Python Script

import pandas as pd
import re

# UPI transaction regex patterns for major Indian banks
PATTERNS = {
    'hdfc':  r'Rs\.?([\d,]+\.?\d*)\s+debited.*UPI[/-]\w+.*-(\w+)',
    'axis':  r'INR\s+([\d,]+\.?\d*)\s+spent.*UPI\s+to\s+([\w-]+)',
    'sbi':   r'Rs\.?([\d,]+\.?\d*)\s+transferred.*UPI.*to\s+(\w+)',
    'icici': r'Rs\.?([\d,]+\.?\d*)\s+debited.*UPI.*?(\w+)$',
}

CATEGORIES = {
    'BIGBASKET': 'Groceries', 'GROFERS': 'Groceries', 'ZEPTO': 'Groceries',
    'SWIGGY': 'Food', 'ZOMATO': 'Food', 'DOMINOS': 'Food',
    'OLA': 'Transport', 'UBER': 'Transport', 'RAPIDO': 'Transport',
    'NETFLIX': 'Entertainment', 'SPOTIFY': 'Entertainment', 'HOTSTAR': 'Entertainment',
    'AIRTEL': 'Utilities', 'JIO': 'Utilities', 'ELECTRICITY': 'Utilities',
}

def parse_transaction(body, sender):
    bank = (sender or '').lower()[:4]
    for key, pattern in PATTERNS.items():
        if key in bank:
            match = re.search(pattern, body, re.IGNORECASE)
            if match:
                amount = float(match.group(1).replace(',', ''))
                merchant = match.group(len(match.groups())).upper()
                return amount, merchant
    return None, None

def categorize(merchant):
    if not merchant:
        return 'Other'
    for keyword, category in CATEGORIES.items():
        if keyword in merchant.upper():
            return category
    return 'Uncategorized'

def build_report(csv_path):
    df = pd.read_csv(csv_path)
    df['date'] = pd.to_datetime(df['date'])

    rows = []
    for _, row in df.iterrows():
        amount, merchant = parse_transaction(row['body'], row['address'])
        if amount:
            rows.append({
                'date': row['date'],
                'amount': amount,
                'merchant': merchant,
                'category': categorize(merchant)
            })

    report = pd.DataFrame(rows)
    monthly = report.groupby([
        report['date'].dt.to_period('M'),
        'category'
    ])['amount'].sum().unstack(fill_value=0)

    print("\n=== Monthly UPI Spending Report ===")
    print(monthly.round(0).to_string())
    print(f"\nTotal transactions: {len(report)}")
    print(f"Total spent: Rs.{report['amount'].sum():,.0f}")
    return report

if __name__ == "__main__":
    report = build_report('sms.csv')
    report.to_csv('upi_report.csv', index=False)

Step 3: Run It

pip install pandas
python upi_tracker.py

Sample output against my March–April 2026 data:

=== Monthly UPI Spending Report ===
category         Food  Groceries  Transport  Utilities  Uncategorized
date
2026-03          3240       8450       2180       1890           5420
2026-04          2890       7920       1670       1890           4100

Total transactions: 84
Total spent: Rs.42,760

I went from "no idea where the money goes" to a clean monthly breakdown in under 30 seconds.

Why This Beats Third-Party Apps

Data stays on your machine. No SMS permissions granted to random apps. No servers uploading your transaction history.

Fully customisable. Do not like my categories? Edit the CATEGORIES dict. Want a chart? Three lines of matplotlib. Want to track only food spend? One filter.

Zero cost. Commercial expense trackers charge ₹200–500/month. This is free forever.

Scales well. I parsed three years of SMS (2,400+ transactions) in under four seconds on a 2019 MacBook Air.

Extensions I Layered On

After the base 60 lines, I added:

Matplotlib chart — saves a PNG bar chart of category-wise monthly spend.
SQLite cache — stores parsed transactions so re-runs are instant.
Telegram bot — sends a weekly summary to my phone via a free bot token.
Business-expense tag — marks GST-relevant transactions for year-end filing.

Each extension added about 15 lines of Python. The whole script is now ~150 lines and has replaced a ₹499/month expense-tracking app I was paying for.

Honest Limitations

SMS format changes. When a bank updates its template, the regex breaks. I add new patterns every 6–8 months.

Not every transaction triggers SMS. Some UPI auto-pay and recurring flows can be silent. I reconcile quarterly against the bank statement.

Bank-specific regex. I have patterns for HDFC, Axis, SBI, and ICICI. Other banks need 10 minutes of custom regex each.

What You Can Build Next

A full personal-finance dashboard (Streamlit is perfect).
ML-based merchant classification with scikit-learn on a few hundred labelled rows.
A rules engine — "alert me if food spend crosses ₹5,000 in a week".
Cross-reference with Zerodha or Upstox P&L for combined wealth tracking.

The core idea — your data, parsed by your own code, on your own machine — applies far beyond UPI. Start with 60 lines. Add what you actually need.

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

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.

DEV Community: Archit Mittal

Build a Bulk PDF Invoice Renamer in 55 Lines of Python

What it does

The Code

How it works

Running it

Edge cases I hit (and you will too)

Why this format

Where to go from here

Build a GST Invoice PDF Extractor in 53 Lines of Python

What it does

The code

How the GSTIN regex works

Why the amount regex uses max(amounts)

A real example

Common edge cases and how to handle them

What I would add next

The bigger point

Build a UPI Transaction Reconciliation Tool in 52 Lines of Python

The Code

How it works

How I actually use it

Where to take it next

Build a GST Invoice Generator in 80 Lines of Python

What it does

The full script

How it works, in plain English

Extending it

Why this beats SaaS for solo operators

Build Your First AI Agent in 60 Lines of Python — No Framework Needed

What We're Building

The Architecture

The Code (60 Lines)

How It Works

Why This Matters

What to Build Next

The Takeaway

How I Saved a Mumbai CA Firm ₹18 Lakh/Year by Automating GST Invoice Reconciliation

The Problem

The Solution: A 3-Part Python Pipeline

Step 1: Parse GSTR-2B JSON

Step 2: Normalize the Purchase Register

Step 3: Reconcile and Flag Mismatches

The Orchestrator

The Results — 60 Days Later

Gotchas I Hit

Who Can Use This Today

Automate Your UPI Transaction Tracking: 60 Lines of Python (Free, Works Offline)

The Problem: Five Apps, Zero Consolidated View

Step 1: Export SMS to CSV

Step 2: The Python Script

Step 3: Run It

Why This Beats Third-Party Apps

Extensions I Layered On

Honest Limitations

What You Can Build Next

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

Why Claude Code sub-agents

The architecture

Sub-agent #1: the PDF extractor

Sub-agent #2: the validator

Sub-agent #3: the writer

The Python orchestrator

Numbers from week one

Three things I'd tell past-me

Try it this week

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

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

2. Long context is cheap enough to abuse

3. Voice agents stopped being demos

4. Coding agents moved from autocomplete to delegation

5. India's public AI stack shipped real things

6. Evals are the new moat

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

What I'm watching next week

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

What we're building

Step 1 — Install the basics

Step 2 — The scraper

Step 3 — The logger

Why the amount regex uses `max(amounts)`