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

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']}")

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)

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