DEV Community: Archit Mittal

The ₹0 Automation Stack: Enterprise-Grade Workflows Without Paying for SaaS

Archit Mittal — Sun, 21 Jun 2026 08:04:38 +0000

₹37,500 per month. That was the SaaS bill a Jaipur-based textile exporter was paying for automating invoices, GST reconciliation, and shipping notifications across three platforms. Three dashboards, three logins, three support tickets every time something broke.

I replaced all of it with Python scripts running on a ₹500/month VPS. The recurring cost dropped to effectively zero — and the workflows actually became more reliable.

This isn't a hypothetical framework. This is the exact stack I've deployed across 11 Indian businesses over the past 18 months, from CA firms filing ITR returns to stock traders screening 150+ equities before market open. Every tool in this stack is free. Every workflow runs in production today.

Why Indian Businesses Overpay for Automation

Most business owners discover automation through SaaS marketing. The pitch is compelling: drag-and-drop workflows, no coding required, instant results. What the pricing page doesn't tell you is that the "Starter" plan handles 100 tasks per month, and your GST reconciliation alone burns through that in three days.

The real cost isn't the subscription — it's the upgrade treadmill. You start at ₹2,000/month, hit the task limit by week two, upgrade to ₹8,000/month, then discover that the webhook integration you need is locked behind the "Business" tier at ₹25,000/month.

For businesses processing under 10,000 transactions monthly — which includes the vast majority of Indian SMBs, freelancers, and professional firms — a Python-based stack isn't just cheaper. It's more flexible, more transparent, and entirely under your control.

The Stack: Seven Layers, Zero Recurring Cost

Here's every component of the automation stack I deploy for clients. Each layer is free, battle-tested, and replaceable without rebuilding the entire system.

Layer 1 — Logic & Scripting: Python 3.11+
The backbone of every automation. Handles API calls, data transformation, conditional logic, and error handling. Free forever, runs anywhere.

Layer 2 — Data Processing: Pandas + OpenPyXL
Reads Excel sheets, CSVs, and bank statements. Cleans, matches, and transforms data. This single library replaces most of what businesses pay ₹10,000+/month for in data integration tools.

Layer 3 — Database: SQLite (small) or PostgreSQL (scale)
SQLite ships with Python — zero setup. For anything above 50,000 records or multi-user access, PostgreSQL (free, open-source) handles it. Supabase offers free-tier hosted PostgreSQL if you don't want to manage a database server.

Layer 4 — Scheduling: cron + Python schedule library
cron handles time-based triggers on Linux. The Python schedule library handles interval-based logic within scripts. Together they replace paid workflow schedulers entirely.

Layer 5 — Notifications: Telegram Bot API + Gmail SMTP
Telegram bots are free, instant, and support rich formatting (tables, buttons, file attachments). Gmail SMTP handles email alerts up to 500/day. WhatsApp Business API is free under 1,000 messages/month.

Layer 6 — Web Scraping & Browser Automation: Selenium + BeautifulSoup
For workflows that need to interact with websites that don't offer APIs — government portals, legacy ERP dashboards, bank statement downloads. Free, mature, well-documented.

Layer 7 — Hosting: VPS (₹500/month) or Home Server (₹0)
A basic VPS from providers like Hetzner or DigitalOcean runs the entire stack. For truly zero cost, an old laptop running Ubuntu works — I have a client whose stock screener runs on a repurposed 2018 ThinkPad.

Real Numbers: SaaS vs. ₹0 Stack

Here's the cost comparison from three actual client deployments. These aren't projections — these are real invoices I've seen versus the cost of what replaced them.

Workflow	SaaS Cost (Monthly)	₹0 Stack Cost (Monthly)	Annual Savings
Invoice processing + GST filing	₹18,000	₹0	₹2,16,000
Bank reconciliation (3 accounts)	₹12,000	₹0	₹1,44,000
Stock screening + WhatsApp alerts	₹47,000 (advisory fee)	₹0	₹5,64,000
Daily MIS report generation	₹8,500	₹0	₹1,02,000

Total annual savings across these four workflows: ₹10,26,000. The one-time setup cost for all four was ₹1,45,000. Payback period: under 2 months.

The Trade-Off Nobody Talks About

I'd be dishonest if I said this stack has no downsides. It does. The primary trade-off is setup time and maintenance ownership.

A SaaS tool gives you a working automation in 20 minutes. A Python script takes 2-8 hours to build, test, and deploy. If something breaks at 2 AM, there's no support chat — you debug it yourself, or your automation consultant does.

This matters. For a solopreneur who needs a quick Slack-to-email bridge, paying ₹2,000/month for a SaaS tool makes perfect sense. The ₹0 stack wins when you have workflows that are core to your business operations, when the SaaS bill has crossed ₹10,000/month, or when you need customisation that no drag-and-drop builder can handle.

How to Start: The First Workflow to Automate

If you've never built a ₹0 automation before, start with the workflow that causes the most daily friction. For most Indian businesses, that's one of these three: bank statement download and matching, invoice data extraction from PDFs, or daily/weekly report generation from spreadsheets.

Pick one. Build a Python script that handles the happy path — the 80% case where everything works normally. Add error handling and a Telegram notification for failures. Run it manually for a week to build trust. Then schedule it with cron and forget about it.

That single workflow will teach you more about automation than any SaaS trial. And once it's running, it runs forever — no subscription renewal, no "your plan has been downgraded," no surprise pricing changes.

The Reliability Question

Skeptics ask: "Is a free stack reliable enough for production?" Fair question. My answer: a CA firm has been running Python-based ITR automation through two consecutive filing seasons — over 1,200 returns processed, zero missed deadlines. The scripts have error handling, retry logic, and instant Telegram alerts if anything fails. That's more observability than most SaaS dashboards provide.

Reliability isn't about how much you pay. It's about how well you handle failures. A ₹0 script with proper logging and alerting beats a ₹20,000/month SaaS tool where failures disappear into a "contact support" black hole.

What's Next

In upcoming articles, I'll walk through specific implementations: automated bank reconciliation with Python and Pandas, stock screening bots that replace expensive advisory services, and GST reconciliation pipelines that file-ready returns without manual intervention.

Every implementation will follow the same philosophy: zero recurring cost, production-grade reliability, and real rupee numbers from real Indian businesses.

How a Weekend Python Script Saved a CA Firm 209 Hours During ITR Season

Archit Mittal — Sun, 21 Jun 2026 07:59:28 +0000

₹3,12,000. That's what Rajesh Sharma's CA firm in Jaipur spent every ITR season hiring three temporary data entry operators for two months. They'd sit in a back room extracting numbers from Form 16 PDFs, cross-checking PAN details against the income tax portal, and pre-filling ITR forms — one cell at a time, one return at a time, 340 returns total.

Last July, a single Python script replaced that entire process. Built in one weekend. Running cost: ₹0. Time saved across the season: 209 hours.

This is not a theoretical tutorial. This is what actually happened, with real numbers, real friction, and the parts that almost went wrong.

The Problem: ITR Season Is a Two-Month Data Entry Marathon

If you've never worked inside a CA firm during July-September, here's what it looks like. Clients send Form 16 PDFs over WhatsApp — sometimes as photos, sometimes as scanned copies with coffee stains. The firm's staff manually opens each PDF, types salary figures into a master Excel sheet, cross-references PAN numbers on the income tax portal, and fills in the ITR form fields one by one.

Rajesh's firm handled 340 individual ITRs last year. Each return took an average of 38 minutes of pure data processing before a CA even looked at it for deductions and exemptions. That's 215 hours of someone staring at PDFs and typing numbers into boxes.

The three temporary hires cost ₹1,04,000 each for the season — ₹3,12,000 total. And they still made errors. Rajesh's senior CA spent another 40+ hours catching and fixing data entry mistakes.

"Har saal yahi hota tha. Teen log hire karo, train karo, phir unki galtiyan dhundo. It felt like we were paying people to create problems we'd solve ourselves." (Every year the same thing. Hire three people, train them, then find their mistakes.)

The Script: What It Actually Does

I didn't build Rajesh an AI platform. I didn't sell him a subscription. I built a Python script that does three things — and does them well.

Stage 1: PDF Text Extraction

The script uses an open-source PDF library to read every Form 16 PDF in a folder. It extracts employer name, PAN, salary breakdowns (basic, HRA, special allowance), TDS deducted, and Section 80C/80D declarations. For scanned or photo PDFs — which made up about 30% of the documents — it falls back to OCR using Tesseract, another free tool.

This stage alone eliminated about 70% of the manual typing.

Stage 2: Validation and Cross-Check

Every extracted PAN is validated against a checksum algorithm (PAN numbers follow a specific format — the script catches typos instantly). Salary totals are cross-checked: does basic + HRA + special allowance + other components equal gross salary? If not, the return gets flagged for manual review instead of silently carrying an error forward.

This is where the script outperformed humans consistently. The temporary hires caught about 60% of calculation mismatches. The script catches 100% — because it doesn't get tired at 4 PM on a Thursday.

Stage 3: Pre-Filled Output

The script generates a structured spreadsheet with every field mapped to the ITR form layout. Rajesh's CAs open the sheet, review the numbers, apply their professional judgment on deductions and exemptions, and file. The 38-minute-per-return data processing step dropped to about 6 minutes of review.

The Numbers:
Before: 38 min/return x 340 returns = 215 hours of data processing
After: 6 min/return x 340 returns = 34 hours of CA review
Net saving: ~209 hours (after accounting for the 28 returns flagged for manual processing)
Cost saving: ₹3,12,000 in seasonal hiring — replaced by a script with ₹0 running cost

What Almost Went Wrong

I'd be lying if I said the script worked perfectly from day one. Two things nearly derailed it.

The first problem was PDF variety. Indian employers don't follow a standard Form 16 template. Some PDFs had salary components in tables, others in plain text paragraphs, and a few used formats I'd never seen — with Devanagari headers mixed into English content. The first version of the script handled about 75% of PDFs correctly. I spent the second day of that weekend writing fallback extraction logic for edge cases. By the end, it handled 92% automatically — the remaining 8% (28 returns) got flagged for manual processing.

The second problem was trust. Rajesh didn't trust the script's output initially — and he shouldn't have. We ran a parallel test: his staff processed the first 50 returns manually while the script processed the same 50. We compared outputs line by line. The script matched human output on 47 returns and was actually more accurate on the other 3 (the staff had made small transcription errors).

That parallel test took an extra day but bought something no amount of demos could: Rajesh's confidence that the numbers were right.

"Jab tak maine apni aankhon se comparison nahi dekha, mujhe yakeen nahi aaya. But the numbers don't lie." (Until I saw the comparison with my own eyes, I didn't believe it. But the numbers don't lie.)

Why This Matters Beyond One CA Firm

India has over 3.5 lakh practising Chartered Accountants. The vast majority of small and mid-size firms still process ITRs the way Rajesh used to — manually, with seasonal hires, under deadline pressure that leads to errors and late nights.

The automation here isn't complicated. It's not an AI model that needs training data or a cloud platform that costs ₹50,000/month. It's a Python script using free libraries, running on the same laptop the CA already owns. The total infrastructure cost is zero.

What it requires is someone who understands both the accounting workflow and the code — or a CA willing to work with someone who does. That intersection is where the real value lives. Not in the technology itself, but in knowing which 80% of the process is pure data movement and which 20% genuinely needs a Chartered Accountant's brain.

If you're a CA firm owner reading this: you don't need to learn Python. You need to find someone who can spend a weekend understanding your Form 16 processing workflow and write a script tailored to it. The ROI pays for itself before August.

And if you're a developer looking for freelance projects: ITR season starts in July. CA firms start panicking in June. That's your window. The ones who've done it manually for 20 years are the ones most ready to try something different — they just need someone to show them it works.

Claude Code vs Cursor vs Copilot: An Honest Review After 40 Production Automations

Archit Mittal — Sun, 21 Jun 2026 07:56:41 +0000

₹40,000 to ₹70,000 — that's the extra monthly capacity my consulting practice has picked up since switching my primary dev loop to Claude Code six months ago. Forty production automations shipped in that window: bank reconciliation pipelines, stock screeners, ITR-prep bots, expense categorizers, GST filing helpers, a couple of trading systems I still babysit.

This post is the scorecard. What Claude Code gets right, where it still breaks, and how I decide when to reach for it versus Cursor versus plain GitHub Copilot. No sponsored angle, no affiliate link. I pay for all three out of pocket. What follows is what I'd tell a friend over chai.

The Context — Who This Review Is For

I'm not a web app engineer. I build finance and trading automations in Python, glue them to broker APIs and Google Sheets, and ship scripts that run on cron jobs or Railway containers. If you build similar back-end, script-first work, this review will transfer cleanly. If you're writing React all day, your mileage will differ.

The bar I measure against is brutal. A client automation has to work on day one against real production data, handle every edge case a CA firm can dream up, and be debuggable by me at 11 PM when a trade doesn't fire. No tolerance for "it worked on my machine."

What Claude Code Gets Right — The Four Wins That Actually Matter

1. Multi-file reasoning at a level nothing else touches

Most AI coding assistants play well inside a single file. Claude Code holds an entire repo in its head. I asked it to refactor a bank-reconciliation project that spans eleven modules and 2,300 lines — it traced every call site, flagged one circular import I'd never noticed, and proposed a clean split in a single turn. Cursor starts to struggle past six or seven files. Copilot gives up around two.

2. It asks the right questions before writing code

This surprised me. When I told Claude Code to "add retry logic to the Zerodha order function," it didn't just write it. It asked whether the retry should respect the broker's rate limits, what to do on partial fills, and whether idempotency keys were available. Those are the questions a senior engineer would ask. The answers shape whether the automation is safe for real money or a ticking time bomb.

3. Long-running tasks stay coherent

I regularly hand Claude Code a task that takes 20-40 minutes — "refactor the GST prep pipeline, add test coverage, run the suite, fix any regressions." It plans, executes, self-corrects, and comes back with a diff that's ready to review. The agentic loop is tight. No hallucinated file paths. No code that assumes packages that don't exist.

4. It respects the code that's already there

Copilot rewrites style aggressively. Claude Code reads the file, matches existing conventions, and produces diffs that don't feel foreign two weeks later. For a consulting practice where I hand off code to clients' in-house teams, that matters more than it sounds.

Where Claude Code Still Breaks

Honest time. Three real failure modes I've hit.

1. Indian fintech APIs are still weak ground

Ask Claude Code about the Zerodha Kite Connect SDK and it gets 80% right. The last 20% — ticker formats for F&O, post-2024 margin changes, specific error codes — is where it hallucinates plausibly. I always double-check anything broker-specific against the official docs. For one client I caught it confidently using a parameter name that was deprecated nine months ago. The test suite caught it before production did. Barely.

2. Long debug sessions can loop

If the first three fixes don't resolve an issue, it sometimes cycles — tries approach A, moves to B, comes back to A wrapped in a helper. I've learned to stop the loop manually, paste the stack trace into a fresh context, and state the constraint explicitly ("do not change the signature of X"). The second attempt almost always lands.

3. Cost at scale needs discipline

Unconstrained, a single long agentic task can burn through tokens fast. For a big refactor I'll sometimes spend the equivalent of a cheap dinner in one session. That's still trivial against the time saved, but only if you're measuring. The techniques in how I cut a client's AI API bill from ₹85K to ₹12K/month apply here too — set bounded budgets, use smaller models for simple sub-tasks, and don't let agentic loops run without a ceiling.

Claude Code vs Cursor vs Copilot — When I Use Each

Simple rule of thumb, from six months of real use:

Task Type	My Pick	Why
New automation from scratch	Claude Code	Plans across files, asks clarifying questions
Single-file editing at speed	Cursor	Faster inline completions, tight editor loop
Boilerplate-heavy typing	Copilot	Cheapest, good at the obvious stuff
Large refactor across 10+ files	Claude Code	Nothing else holds this much context
Working in a legacy repo I don't know	Claude Code	Reads and understands before writing
Pair-programming over screen-share	Cursor	Inline suggestions are less disruptive

All three stay installed. Picking the right one is like picking the right screwdriver — the mistake is treating one tool as the answer to every problem.

The Rupee Impact — What 40 Automations Looks Like in Numbers

A summary from my consulting log since switching:

Build time: 38% lower than my pre-Claude baseline on average.
Client revisions: Down by roughly half — better first drafts mean fewer "can you also..." cycles.
Debugging time: Up slightly, because I now take on projects I wouldn't have before.
Capacity: ₹40,000-₹70,000 of extra billable capacity per month. Over six months, a real second income line without hiring anyone.

The Non-Obvious Tip Most Teams Miss

The setting that changed my workflow most: a CLAUDE.md file at the root of every project. Claude Code reads it automatically. I put project context, naming conventions, the specific broker API version we're using, and our testing rules. It's the difference between getting a generic Python suggestion and getting a suggestion that knows we use Pandas 2.2, pytest, and a specific way of mocking Kite Connect.

If you skip this step, you're using maybe 60% of the tool. I've seen teams adopt Claude Code, get indifferent results, and blame the model. Nine times out of ten, the CLAUDE.md was missing or empty.

Should You Switch?

If you're already on Cursor and happy, don't rip it out. Layer Claude Code on top for planning and large refactors and see how the split feels for a month. If you're still on Copilot-only and doing anything more complex than boilerplate, the jump to Claude Code is the single highest-ROI tooling change I've made as an automation consultant this year.

"Jo tool sahi kaam karta hai, wohi chuno." (Pick the tool that does the actual job.)

Not everything should be automated, and not every process should be shipped with an AI pair programmer either. For production automations where quality and context matter more than keystroke speed, Claude Code is the best tool I've used. The ceiling is high. The floor is higher than any other assistant I've tried.

Which AI coding tool are you reaching for most right now — and for what kind of work?

The CFO's AI Playbook: 5 Finance Automations Every Indian Business Should Run in 2026

Archit Mittal — Sun, 21 Jun 2026 07:53:49 +0000

Over 60% of APAC finance leaders say AI-led automation is their top priority for 2026. For Indian businesses, that stat hides a quieter truth: most SMBs have no idea which automation to start with.

I've built finance automations for CA firms, D2C brands, trading desks, family-run manufacturers, and a few fintech startups. The pattern is always the same. Five finance processes eat the most hours, hide the most errors, and respond best to a simple Python layer on top of whatever ledger you already use.

This is the playbook. No enterprise suite. No subscriptions you don't need.

1. Bank Reconciliation — The Single Biggest Time Sink

Every finance team I meet has the same nightmare. Statements from three or four banks. Tally or Zoho on the other side. An Excel sheet in the middle. Eight hours a month — sometimes more — matching rows.

We replaced it with a Python script that pulls statements from email attachments, categorizes transactions using keyword rules, cross-references entries with Tally, and flags only the mismatches. Eight hours dropped to fifteen minutes of review.

"Tu 2 saal pehle kyu nahi mila?" (Why didn't I meet you two years ago?)

2. Cash Application — Matching Payments to Invoices

In India, money arrives in more shapes than most tools expect: UPI, NEFT, RTGS, IMPS, cheques, partial payments, grouped settlements where one transfer covers four invoices.

I build a three-layer pipeline. Layer one parses payment references. Layer two tries deterministic matches. Layer three hands ambiguous ones to a lightweight AI model that suggests matches with a confidence score.

A D2C brand went from a seven-day receivables gap to same-day application. Their working capital position shifted by roughly ₹14 lakhs.

3. Real-Time P&L Reporting

Most Indian SMB founders see their P&L twenty days after the month ends. A scheduled Python script pulls trial balance data overnight, categorizes new entries, and renders a dashboard with revenue, gross margin, operating expenses and EBITDA as of yesterday.

You stop making capital decisions on twenty-day-old data. For a business doing ₹30L/month, a single well-timed cut based on real-time numbers can move EBITDA by 2-3 percentage points.

4. GST Filing Prep

GSTR-1, GSTR-3B, and the quarterly reconciliations. I build GST prep bots that run on the 28th of every month. They pull sales and purchase data, compute filing figures, pull vendor GSTR-2A data via the GSTN API, flag reconciliation mismatches, and produce a filing-ready summary.

A small manufacturing client went from three anxious days a month to a two-hour review window.

5. Expense Categorization

Miscategorized expenses are a silent killer in Indian SMB P&Ls. Expense categorization automation uses an AI model trained on your own chart of accounts. High-confidence entries auto-categorize. The ambiguous 10-15% goes to a review queue.

For a client with ~800 expense entries a month, this shifted their finance lead's time from 6 hours of categorization to 45 minutes of review. Accuracy went from ~82% to 97%.

The Five Automations at a Glance

Automation	Time Saved / Month	Typical Rollout
Bank reconciliation	6-10 hours	2-4 weekends
Cash application	15-25 hours	3-6 weeks
Real-time P&L	8-12 hours + faster decisions	1-2 weeks
GST filing prep	12-20 hours	3-5 weeks
Expense categorization	4-8 hours	1-2 weeks

Stack all five and you're recovering 45-75 hours of skilled finance time every month.

Where to Start

Do not try to build all five at once. Start with bank reconciliation — bounded, high-ROI, and an immediate win. Once it's running reliably for two months, pick the next one.

"Jo kaam AI se ho sakta hai, AI kare. Jo judgment se hota hai, woh humans ke paas rahe." (Let AI do what AI can do. Let judgment stay with humans.)

Which of these five is eating the most hours in your finance team right now?

Stock Screener Automation: How a Trader Replaced ₹47K/Month Advisory with a Python Script

Archit Mittal — Sun, 21 Jun 2026 07:46:15 +0000

₹47,000 every month. That's what my friend Rohit was paying a fund advisory service to tell him which stocks matched his criteria. Six filters — RSI below 40, volume spike above 200% of 20-day average, 200-DMA crossover, sector rotation signals, delivery percentage above 60%, and promoter holding changes in the last quarter.

One Sunday afternoon, a Python script, and a free broker API later — Rohit doesn't pay that ₹47,000 anymore. "Bhai, pehle 2 ghante screening mein jaate the. Ab chai peete peete list aa jaati hai."

This is the story of how a retail trader replaced an expensive advisory with a script that costs literally nothing to run — and why this pattern applies to far more than just stock screening.

The Problem: 2 Hours Every Morning, Staring at Screens

Rohit is a swing trader based in Pune. He's been trading for seven years, and his edge has always been discipline — he never enters a trade without all six of his filters confirming. The problem was execution speed. Every morning before market open, he'd manually check 150+ stocks across three different screening tools, cross-reference the results, and build his watchlist.

Two hours. Every single trading day. That's roughly 500 hours a year spent on a task that follows the exact same logic every time.

The advisory service he subscribed to ran similar filters, but their shortlist arrived at 9:30 AM — 15 minutes after market open. By then, the best entry prices on momentum stocks were already gone.

The Solution: A Python Script That Runs Before You Wake Up

The script connects to Rohit's broker API at 9:15 AM — one minute before market opens. It pulls the previous day's closing data for all NSE-listed stocks (roughly 2,000 symbols). Then it runs six filters in sequence.

The entire filtering process takes about 12 seconds. By 9:16 AM, Rohit receives a WhatsApp message with a shortlist of 5-12 stocks that passed all six filters.

The numbers that matter: 2 hours/day reduced to 0 active time. ₹47,000/month advisory cancelled. Total recurring cost: ₹0.

Why This Works Better Than an Advisory Service

Speed. An automated script delivers results in seconds. A team of analysts takes 30-45 minutes. In momentum trading, those minutes are the difference between a 2% gain and a missed entry.

Customisation. Rohit's six filters are specific to his trading style. The advisory service overlapped about 70% with what he wanted. That remaining 30% mismatch meant he was still doing manual screening on top of the advisory's shortlist.

Adaptability. When Rohit wanted to add a seventh filter last month (institutional buying from bulk deal data), it was live by Saturday evening. Try asking an advisory service to customise their methodology for one subscriber.

The Cost Breakdown: ₹5.64L/Year Saved

Item	Advisory Service	Python Script
Monthly cost	₹47,000	₹0
Annual cost	₹5,64,000	₹2,000 (one-time API fee)
Delivery time	9:30 AM (15 min after open)	9:16 AM (before open)
Customisation	Fixed filters	Fully custom
Manual screening still needed	Yes	No

What You Actually Need to Build This

You need Python 3.x with Pandas, a broker API account (Kite Connect from Zerodha at ₹2,000 one-time, or Fyers API v3 which is completely free), a server or always-on machine, and the WhatsApp Business API for notifications.

If you've ever written an IF statement in Excel, you can understand the logic behind a stock screener script.

The Bigger Lesson

Rohit's story isn't really about stock screening. It's about a pattern: the most expensive services are often the ones running the simplest logic on publicly available data.

The sweet spot for automation is repetitive tasks with clear rules and expensive human execution. Before you automate anything, ask yourself: Is the logic explicit enough to explain to a 10-year-old? Does the task repeat on a predictable schedule? Is the current cost of doing it manually more than the one-time cost of building the script?

If all three answers are yes, you've found your next automation project.

What Happened After

Six months in, Rohit's trading performance improved — not because the script picked better stocks, but because it freed his morning for what actually matters: reading quarterly results, analysing management commentary, and making judgment calls.

That's what good automation does. It doesn't replace your expertise. It removes the mechanical layer so you can spend 100% of your time on the work that actually moves the needle.

Why I Tell Clients NOT to Automate Everything — The Over-Automation Trap

Archit Mittal — Sun, 21 Jun 2026 07:44:43 +0000

₹1,20,000. That's how much a client spent building an automated follow-up system I had to tell him to rip out thirty days later.

I'm an automation consultant. My entire business depends on people wanting to automate things. And yet, the most valuable advice I give — the advice clients actually remember — is telling them what not to automate.

This might sound counterintuitive. But after building automation systems for CA firms, traders, e-commerce brands, and service businesses across India, I've developed a rule: the best automation experts say "no" more often than they say "yes."

The ₹1.2 Lakh Mistake That Changed How I Consult

A client ran a high-ticket consulting practice. His close rate was exceptional — north of 40% — because every prospect felt personally attended to. He'd send WhatsApp voice notes, check in on their business unprompted, and remember details from conversations months earlier.

He came to me wanting to "scale" his follow-ups. We built a 4-touchpoint automated sequence: personalised messages triggered by pipeline stage, scheduled over 14 days. It was technically beautiful.

His conversion rate dropped 40% in the first month.

"Bhai, mere automation ne tera business slow kar diya." That's what I had to tell him. My automation slowed down his business.

The problem wasn't the technology. The problem was the assumption. His prospects weren't buying his service — they were buying him. The personal touch wasn't a nice-to-have; it was the entire value proposition.

We ripped it out. Went back to manual follow-ups. Conversions recovered within two weeks.

That experience taught me something I now share with every new client: before you automate any customer-facing process, ask one question — "Does my customer want speed, or do they want ME?"

The Four Processes You Should Never Automate

After making this mistake and watching dozens of other businesses make similar ones, I've identified four categories of work where automation consistently backfires.

1. Relationship-Driven Interactions

If your customer is paying a premium because they trust you personally, automating your communication tells them they aren't worth your time. This applies to consulting, wealth management, legal advisory, and any high-ticket service where the relationship IS the product.

2. Processes That Change Every Quarter

Automation works best on stable, repeatable workflows. If your process shifts every few months — because of regulatory changes, seasonal cycles, or evolving business models — you'll spend more time maintaining the automation than doing it manually.

I had a client in the import-export space whose customs documentation process changed with every new trade circular. We built an automation. It broke within six weeks. We rebuilt it. It broke again. Eventually, the honest answer was: this process isn't stable enough to automate profitably.

3. High-Exception Workflows

Some workflows look simple on a whiteboard but have fifty edge cases in practice. ITR filing, for instance, has a core process that's highly automatable — but the exceptions require human judgment. The trick is automating the 80% that's mechanical and leaving the 20% for human expertise.

4. When Maintenance Costs Exceed Manual Costs

Every automation system has a maintenance burden. I use a simple calculation: if the annual maintenance cost is more than 60% of the manual effort it replaces, I advise against building it.

The STAR Framework

Before greenlighting any automation project, I run it through the STAR test:

Stable: Has the process been the same for at least 6 months? If not, wait.

Transferable: Can you explain the process to a new hire in under 30 minutes with zero ambiguity? If not, it has hidden complexity that will haunt the automation.

Arithmetic: Does the math work? Calculate: (hours saved × hourly rate) minus (build cost amortized over 12 months + monthly maintenance). If negative, don't build it.

Replaceable: Is the human element genuinely replaceable, or is it the reason the customer pays? If a bot can do it without the customer noticing — automate away. If they'd notice and care — stop.

The Real Skill Is Knowing Where to Draw the Line

The automation industry has a bias problem. Every tool vendor, every course, every consultant has an incentive to say "yes, automate it." The revenue model rewards building, not advising against building.

But the consultants who build lasting client relationships are the ones who occasionally say: "Don't automate this. Here's why. Here's what to do instead."

The best automation isn't about replacing everything. It's about knowing which 80% to automate so you can be 100% present for the 20% that actually matters.

"Jo har cheez automate karta hai, wo kisi cheez mein mahir nahi hota." — The one who automates everything masters nothing.

Next time you're tempted to automate a process, run it through the STAR test first. You might save yourself ₹1.2 lakh and a very awkward phone call to your client.

Build a GST Invoice Parser in 70 Lines of Python

Archit Mittal — Sat, 20 Jun 2026 03:41:45 +0000

If you run a small business in India, you know the monthly ritual: a folder full of vendor invoice PDFs, and a spreadsheet that needs GSTIN, invoice number, date, taxable value, and GST amounts pulled out of every single one. Doing it by hand takes hours. Let's automate it in about 70 lines of Python.

What we're building

A script that:

Scans a folder of invoice PDFs
Extracts GSTIN, invoice number, date, taxable value, CGST/SGST/IGST, and total
Validates the GSTIN format (including the checksum-style structure)
Writes everything to a clean CSV you can import into Tally or Excel

Setup

pip install pdfplumber

That's the only dependency. pdfplumber handles text extraction from digitally generated PDFs (which most GST invoices are).

The code

import csv
import re
import sys
from pathlib import Path

import pdfplumber

# GSTIN: 2-digit state code + 10-char PAN + entity code + 'Z' + check char
GSTIN_RE = re.compile(r"\b\d{2}[A-Z]{5}\d{4}[A-Z]\d[A-Z]\d\b")
INV_NO_RE = re.compile(r"(?:Invoice\s*(?:No|Number|#)\.?\s*[:\-]?\s*)([A-Z0-9\/\-]+)", re.I)
DATE_RE = re.compile(r"\b(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})\b")
AMOUNT_RE = re.compile(r"(?:\u20b9|Rs\.?|INR)\s*([\d,]+\.?\d*)")

LABELS = {
    "taxable": re.compile(r"taxable\s*(?:value|amount)\s*[:\-]?\s*(?:\u20b9|Rs\.?|INR)?\s*([\d,]+\.?\d*)", re.I),
    "cgst":    re.compile(r"CGST[^\d]*([\d,]+\.\d{2})", re.I),
    "sgst":    re.compile(r"SGST[^\d]*([\d,]+\.\d{2})", re.I),
    "igst":    re.compile(r"IGST[^\d]*([\d,]+\.\d{2})", re.I),
    "total":   re.compile(r"(?:grand\s*total|total\s*amount|amount\s*payable)\s*[:\-]?\s*(?:\u20b9|Rs\.?|INR)?\s*([\d,]+\.?\d*)", re.I),
}

STATE_CODES = {f"{i:02d}" for i in range(1, 39)}

def valid_gstin(gstin: str) -> bool:
    return bool(GSTIN_RE.fullmatch(gstin)) and gstin[:2] in STATE_CODES

def to_float(s: str) -> float:
    try:
        return float(s.replace(",", ""))
    except ValueError:
        return 0.0

def parse_invoice(pdf_path: Path) -> dict:
    with pdfplumber.open(pdf_path) as pdf:
        text = "\n".join(page.extract_text() or "" for page in pdf.pages)

    gstins = [g for g in GSTIN_RE.findall(text) if valid_gstin(g)]
    inv_no = INV_NO_RE.search(text)
    date = DATE_RE.search(text)

    row = {
        "file": pdf_path.name,
        "vendor_gstin": gstins[0] if gstins else "NOT FOUND",
        "invoice_no": inv_no.group(1) if inv_no else "NOT FOUND",
        "date": date.group(1) if date else "NOT FOUND",
    }
    for field, pattern in LABELS.items():
        m = pattern.search(text)
        row[field] = to_float(m.group(1)) if m else 0.0

    # Sanity check: taxable + taxes should roughly equal total
    expected = row["taxable"] + row["cgst"] + row["sgst"] + row["igst"]
    row["mismatch"] = "YES" if row["total"] and abs(expected - row["total"]) > 1 else ""
    return row

def main(folder: str):
    pdfs = sorted(Path(folder).glob("*.pdf"))
    if not pdfs:
        sys.exit(f"No PDFs found in {folder}")

    rows = [parse_invoice(p) for p in pdfs]
    out = Path(folder) / "invoices_extracted.csv"
    with out.open("w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=rows[0].keys())
        writer.writeheader()
        writer.writerows(rows)
    print(f"Parsed {len(rows)} invoices -> {out}")
    flagged = sum(1 for r in rows if r["mismatch"])
    if flagged:
        print(f"Warning: {flagged} invoice(s) have tax totals that don't add up — check manually.")

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

Running it

python gst_parser.py ~/Downloads/vendor-invoices/

Output:

Parsed 23 invoices -> invoices_extracted.csv
Warning: 2 invoice(s) have tax totals that don't add up — check manually.

That mismatch flag is my favourite part. It catches data-entry errors on the vendor's side and extraction failures on ours — anything where taxable value + CGST + SGST + IGST doesn't land within ₹1 of the stated total gets flagged for a human look.

Why regex and not AI?

For digitally generated invoices, regex is faster, free, and deterministic. A month of invoices parses in under two seconds with zero API costs. Where this approach breaks down is scanned/photographed invoices — for those, add an OCR step with pytesseract before the regex pass, or hand the text to an LLM for extraction.

Three upgrades worth making

Vendor name capture. Most invoices put the vendor name within a couple of lines of the GSTIN. Grab the surrounding lines and you can auto-fill the vendor column too.

GSTIN verification. The format check above catches typos, but the government's GST portal can confirm a GSTIN is actually registered. Useful before claiming input tax credit.

HSN code extraction. If you need item-level detail for GSTR filings, pdfplumber's extract_tables() handles the line-item tables most invoice formats use.

Wrap-up

Seventy lines, one dependency, and the monthly invoice grind becomes a two-second script run. The same pattern — extract text, regex the fields you care about, validate, write CSV — works for bank statements, salary slips, and purchase orders too.

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

Build a GST Invoice Generator in 87 Lines of Python

Archit Mittal — Sat, 20 Jun 2026 03:40:49 +0000

If you freelance or run a small business in India, you have probably paid for invoicing software that does one thing: multiply numbers and put them in a PDF. Today we will build that ourselves — a GST-compliant tax invoice generator that reads line items from a CSV and produces a clean PDF, in 87 lines of Python.

It handles the part everyone gets wrong: the CGST/SGST vs IGST split. Intra-state sales split the tax into equal CGST and SGST halves; inter-state sales charge a single IGST. Our script decides automatically by comparing the first two digits of the buyer's and seller's GSTINs (those digits are the state code).

What you'll need

One dependency:

pip install fpdf2

fpdf2 is a maintained, pure-Python PDF library — no system packages, works the same on Windows, Mac, and Linux.

The input format

Keep your line items in a plain CSV. Anyone on your team can edit this in Excel:

description,hsn,qty,rate,gst_pct
Website development,998314,1,45000,18
Annual hosting,998315,1,12000,18
SSL certificate,998316,2,1500,18

The full code

"""GST invoice generator — reads line items from CSV, outputs a PDF invoice."""
import csv
import sys
from datetime import date
from fpdf import FPDF

SELLER = {
    "name": "Acme Tech Services Pvt Ltd",
    "address": "221 MG Road, Bengaluru, KA 560001",
    "gstin": "29ABCDE1234F1Z5",
    "state_code": "29",
}


def load_items(path):
    with open(path, newline="") as f:
        return [
            {
                "desc": r["description"],
                "hsn": r["hsn"],
                "qty": float(r["qty"]),
                "rate": float(r["rate"]),
                "gst_pct": float(r["gst_pct"]),
            }
            for r in csv.DictReader(f)
        ]


def compute_totals(items, interstate):
    rows, subtotal, tax_total = [], 0.0, 0.0
    for it in items:
        taxable = it["qty"] * it["rate"]
        tax = taxable * it["gst_pct"] / 100
        subtotal += taxable
        tax_total += tax
        rows.append((it, taxable, tax))
    return rows, subtotal, tax_total


def build_pdf(rows, subtotal, tax_total, buyer, interstate, out_path):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Helvetica", "B", 16)
    pdf.cell(0, 10, "TAX INVOICE", align="C", new_x="LMARGIN", new_y="NEXT")
    pdf.set_font("Helvetica", size=10)
    pdf.cell(0, 6, f"{SELLER['name']} | GSTIN: {SELLER['gstin']}",
             new_x="LMARGIN", new_y="NEXT")
    pdf.cell(0, 6, SELLER["address"], new_x="LMARGIN", new_y="NEXT")
    pdf.cell(0, 6, f"Invoice date: {date.today():%d-%m-%Y}  |  Bill to: "
             f"{buyer['name']} (GSTIN: {buyer['gstin']})",
             new_x="LMARGIN", new_y="NEXT")
    pdf.ln(4)
    pdf.set_font("Helvetica", "B", 9)
    widths = (70, 20, 15, 25, 15, 25)
    for w, h in zip(widths, ("Description", "HSN", "Qty", "Rate (Rs)",
                             "GST %", "Amount (Rs)")):
        pdf.cell(w, 7, h, border=1)
    pdf.ln()
    pdf.set_font("Helvetica", size=9)
    for it, taxable, _ in rows:
        cells = (it["desc"], it["hsn"], f"{it['qty']:g}",
                 f"{it['rate']:,.2f}", f"{it['gst_pct']:g}", f"{taxable:,.2f}")
        for w, v in zip(widths, cells):
            pdf.cell(w, 7, str(v), border=1)
        pdf.ln()
    pdf.ln(3)
    pdf.set_font("Helvetica", "B", 10)
    pdf.cell(0, 6, f"Taxable value: Rs {subtotal:,.2f}",
             new_x="LMARGIN", new_y="NEXT")
    if interstate:
        pdf.cell(0, 6, f"IGST: Rs {tax_total:,.2f}",
                 new_x="LMARGIN", new_y="NEXT")
    else:
        pdf.cell(0, 6, f"CGST: Rs {tax_total / 2:,.2f}   SGST: "
                 f"Rs {tax_total / 2:,.2f}", new_x="LMARGIN", new_y="NEXT")
    pdf.cell(0, 8, f"Grand total: Rs {subtotal + tax_total:,.2f}",
             new_x="LMARGIN", new_y="NEXT")
    pdf.output(out_path)


if __name__ == "__main__":
    csv_path = sys.argv[1] if len(sys.argv) > 1 else "items.csv"
    buyer = {"name": "Globex Retail LLP", "gstin": "27PQRSX5678G1Z3"}
    interstate = buyer["gstin"][:2] != SELLER["state_code"]
    rows, subtotal, tax_total = compute_totals(load_items(csv_path), interstate)
    build_pdf(rows, subtotal, tax_total, buyer, interstate, "invoice.pdf")
    print(f"invoice.pdf written - grand total Rs {subtotal + tax_total:,.2f}")

Run it:

python gst_invoice.py items.csv
# invoice.pdf written - grand total Rs 70,800.00

How it works

Loading (load_items). csv.DictReader turns each CSV row into a dict keyed by the header row, so the code reads like the spreadsheet. We cast qty, rate, and gst_pct to floats up front so the math functions never deal with strings.

The tax math (compute_totals). Each line's taxable value is qty x rate, and tax is a simple percentage of that. We accumulate a subtotal and a tax total and keep the per-row figures for the PDF table. The interstate decision happens once, in the entrypoint: buyer GSTIN state code != seller state code means IGST applies. In our example the buyer's GSTIN starts with 27 (Maharashtra) and the seller's with 29 (Karnataka), so the invoice shows a single IGST line. Change the buyer's GSTIN to start with 29 and you will see it split into equal CGST and SGST halves instead — no other change needed.

The PDF (build_pdf). fpdf2's cell() API is old-school but predictable: each cell has a fixed width, border=1 draws the table lines, and new_y="NEXT" moves the cursor down a row. The widths tuple is the entire layout — adjust six numbers and the whole table reflows. Total layout code: about 40 lines, and you own every pixel of it.

Extending it

A few upgrades that each take only a handful of lines: pull SELLER and the buyer from a JSON config instead of hardcoding; add an invoice number that auto-increments from a counter file; loop over a folder of CSVs to batch-generate a month of invoices; or add pdf.image("logo.png", x=10, y=8, w=30) for letterhead branding.

One honest caveat: this covers the common single-rate service invoice. If you deal with cess, reverse charge, or e-invoicing (IRN/QR codes), those are regimes of their own — treat this as the foundation, not a compliance department.

That's a working invoice pipeline in 87 lines — CSV in, compliant PDF out, and the tax split handled correctly without a subscription.

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

Claude Code vs Cursor vs Copilot: An Honest Review After 40 Production Automations

Archit Mittal — Sat, 20 Jun 2026 03:39:36 +0000

The Context — Who This Review Is For

What Claude Code Gets Right — The Four Wins That Actually Matter

1. Multi-file reasoning at a level nothing else touches

2. It asks the right questions before writing code

3. Long-running tasks stay coherent

4. It respects the code that's already there

Where Claude Code Still Breaks

Honest time. Three real failure modes I've hit.

1. Indian fintech APIs are still weak ground

2. Long debug sessions can loop

3. Cost at scale needs discipline

Claude Code vs Cursor vs Copilot — When I Use Each

Simple rule of thumb, from six months of real use:

Task Type	My Pick	Why
New automation from scratch	Claude Code	Plans across files, asks clarifying questions
Single-file editing at speed	Cursor	Faster inline completions, tight editor loop
Boilerplate-heavy typing	Copilot	Cheapest, good at the obvious stuff
Large refactor across 10+ files	Claude Code	Nothing else holds this much context
Working in a legacy repo I don't know	Claude Code	Reads and understands before writing
Pair-programming over screen-share	Cursor	Inline suggestions are less disruptive

All three stay installed. Picking the right one is like picking the right screwdriver — the mistake is treating one tool as the answer to every problem.

The Rupee Impact — What 40 Automations Looks Like in Numbers

A summary from my consulting log since switching:

Build time: 38% lower than my pre-Claude baseline on average.
Client revisions: Down by roughly half — better first drafts mean fewer "can you also..." cycles.
Debugging time: Up slightly, because I now take on projects I wouldn't have before.
Capacity: ₹40,000-₹70,000 of extra billable capacity per month. Over six months, a real second income line without hiring anyone.

The same tooling shift that helped me ship a weekend Python script that saved a CA firm 209 hours during ITR season is now the default for every new project — from the stock screener that replaced a ₹47K/month advisory to the full CFO playbook of five finance automations I rolled out to two SMBs this quarter.

The Non-Obvious Tip Most Teams Miss

If you skip this step, you're using maybe 60% of the tool. I've seen teams adopt Claude Code, get indifferent results, and blame the model. Nine times out of ten, the CLAUDE.md was missing or empty.

Should You Switch?

"Jo tool sahi kaam karta hai, wohi chuno." (Pick the tool that does the actual job.)

Which AI coding tool are you reaching for most right now — and for what kind of work?

About the Author

Archit Mittal helps businesses automate chaos. Follow on LinkedIn: @automate-archit

Get automation insights every Saturday — join The Automation Dispatch at architmittal.com/newsletter.

How a Weekend Python Script Saved a CA Firm 209 Hours During ITR Season

Archit Mittal — Sat, 20 Jun 2026 03:38:01 +0000

How a Weekend Python Script Saved a CA Firm 209 Hours During ITR Season

Last July, a single Python script replaced that entire process. Built in one weekend. Running cost: ₹0. Time saved across the season: 209 hours.

This is not a theoretical tutorial. This is what actually happened, with real numbers, real friction, and the parts that almost went wrong.

The Problem: ITR Season Is a Two-Month Data Entry Marathon

If you've never worked inside a CA firm during July–September, here's what it looks like. Clients send Form 16 PDFs over WhatsApp — sometimes as photos, sometimes as scanned copies with coffee stains. The firm's staff manually opens each PDF, types salary figures into a master Excel sheet, cross-references PAN numbers on the income tax portal, and fills in the ITR form fields one by one.

The three temporary hires cost ₹1,04,000 each for the season — ₹3,12,000 total. And they still made errors. Rajesh's senior CA spent another 40+ hours catching and fixing data entry mistakes.

"Har saal yahi hota tha. Teen log hire karo, train karo, phir unki galtiyan dhundo. It felt like we were paying people to create problems we'd solve ourselves."
(Every year the same thing. Hire three people, train them, then find their mistakes.)

The Script: What It Actually Does

I didn't build Rajesh an AI platform. I didn't sell him a subscription. I built a Python script that does three things — and does them well.

Stage 1: PDF Text Extraction

This stage alone eliminated about 70% of the manual typing.

Stage 2: Validation and Cross-Check

Stage 3: Pre-Filled Output

The Numbers:

Before: 38 min/return x 340 returns = 215 hours of data processing
After: 6 min/return x 340 returns = 34 hours of CA review
Net saving: ~209 hours (after accounting for the 28 returns flagged for manual processing)
Cost saving: ₹3,12,000 in seasonal hiring — replaced by a script with ₹0 running cost

What Almost Went Wrong

I'd be lying if I said the script worked perfectly from day one. Two things nearly derailed it.

That parallel test took an extra day but bought something no amount of demos could: Rajesh's confidence that the numbers were right.

"Jab tak maine apni aankhon se comparison nahi dekha, mujhe yakeen nahi aaya. But the numbers don't lie."
(Until I saw the comparison with my own eyes, I didn't believe it. But the numbers don't lie.)

Why This Matters Beyond One CA Firm

Frequently Asked Questions

Can a Python script really automate ITR filing for a CA firm?

Yes. A Python script can automate the repetitive data extraction, validation, and pre-filling stages of ITR preparation. The CA still reviews and signs off on every return — the script handles the 80% of work that is pure data movement, not professional judgment.

How much time can automation save during ITR season?

In this case, a single script saved 209 hours across one ITR season by automating PDF extraction, data validation, and form pre-filling. The exact savings depend on your firm's volume and how manual your current process is.

Is it legal for CA firms to use automation scripts for ITR filing?

Absolutely. The automation handles data processing — extracting numbers from Form 16s, validating PAN details, and pre-filling fields. The Chartered Accountant still reviews every return, applies professional judgment, and digitally signs the final filing.

What does it cost to build an ITR automation script?

The script in this case study was built in a single weekend using free, open-source Python libraries. Total running cost: ₹0. No SaaS subscriptions, no API fees, no licensing.

Archit Mittal helps businesses automate chaos. Follow on LinkedIn: @automate-archit

Get automation insights every Saturday — join The Automation Dispatch

How I Cut a Client's AI API Bill from ₹85K to ₹12K/Month — Without Losing Quality

Archit Mittal — Sat, 20 Jun 2026 03:36:49 +0000

₹85,000 per month. That was the AI API bill sitting in my client's inbox when they called me in a mild panic last quarter. They run a mid-sized e-commerce operation in Pune — about 4,000 orders a day — and had integrated AI into customer support, product descriptions, and internal reporting. The AI was working beautifully. The invoice was not.

"Archit bhai, AI toh kaam kar raha hai, lekin cost control se bahar ja raha hai." (The AI is working, but the costs are spiralling out of control.)

Three weeks later, their monthly bill was ₹12,400. Same tasks. Same quality. No corners cut. Here's exactly what changed.

The Real Problem: Every Task Was Using the Most Expensive Model

When I audited their setup, the issue was obvious within five minutes. Every single API call — whether it was classifying a customer complaint into one of 8 categories or generating a 2,000-word product description — was hitting the same premium model. It's the most common mistake I see with businesses adopting AI: they pick one model during the proof-of-concept phase and never revisit that decision as they scale.

Think of it this way. You wouldn't hire a senior chartered accountant to do data entry. But that's essentially what was happening — a top-tier reasoning model was being used to answer "Is this complaint about shipping or billing?"

Fix #1: Model Routing — The Single Biggest Cost Lever

Model routing is the practice of sending each task to the cheapest model that can handle it at acceptable quality. I categorized their ~47 distinct API call types into three tiers.

Tier	Task Types	Model Class	Cost Impact
Simple	Classification, extraction, yes/no decisions, formatting	Lightweight (Haiku-class)	~90% cheaper per call
Medium	Summarization, short-form content, template-based responses	Mid-tier (Sonnet-class)	~50% cheaper per call
Complex	Long product descriptions, nuanced customer responses, analytics reports	Premium (Opus-class)	Full price — but only 12% of calls

The result? 68% of their API calls moved to the lightweight tier, 20% to mid-tier, and only 12% stayed on premium. That single change dropped the bill from ₹85K to roughly ₹38K. No quality degradation — we ran A/B tests on customer satisfaction scores for two weeks before fully switching.

Fix #2: Prompt Caching — Stop Paying for the Same Context Twice

Their customer support bot sent the same 1,200-token system prompt with every single API call. That's company policies, tone guidelines, product catalog context — all identical across thousands of daily calls. Every call was paying full input token pricing for information the model had already processed moments ago.

Prompt caching solves this. The first call processes the full system prompt, and subsequent calls within the cache window reference it at a fraction of the cost. For their volume — around 6,000 support interactions per day — this alone saved ₹8,000-10,000 monthly.

Quick math: 6,000 calls/day x 1,200 tokens x 30 days = 216 million input tokens/month just on repeated system prompts. At standard pricing, that's a significant chunk of the bill that prompt caching nearly eliminates.

Fix #3: Batching Non-Urgent Requests

Not everything needs a real-time response. Their internal reporting pipeline — daily sales summaries, inventory alerts, marketing performance digests — was making individual API calls as each data point came in. Sixty to eighty calls that could easily be batched into three or four.

We restructured their reporting to collect data throughout the day and process it in batch windows — once at 6 AM, once at 2 PM, once at 10 PM. Batch API pricing is typically 50% cheaper than real-time, and for internal reports, a few hours of delay is completely acceptable.

"Pehle har choti cheez ke liye alag call jaati thi. Ab ek baar mein sab ho jaata hai." (Earlier, every small thing triggered a separate call. Now everything processes at once.)

Fix #4: Output Token Discipline

This one is subtle but adds up fast. Their product description prompts asked the model to "write a detailed, comprehensive product description." The model happily obliged — averaging 800-1,000 tokens per response when the actual requirement was 200-300 tokens for their product cards.

We rewrote prompts with explicit length constraints and structured output formats. Instead of open-ended generation, the model received exact specifications: "Write a product description in exactly 3 sentences. First sentence: what it is. Second: key benefit. Third: who it's for."

Output tokens are more expensive than input tokens on most providers. Cutting average output length by 60% across thousands of daily calls compounded into real savings.

The Final Numbers

Optimization	Monthly Savings
Model routing	₹47,000
Prompt caching	₹9,500
Request batching	₹8,200
Output token discipline	₹7,900
Total monthly bill	₹12,400 (down from ₹85,000)

That's an 85% reduction. The AI does exactly the same work. The customer satisfaction score actually went up by 3% — likely because the lighter models respond faster, and customers prefer quicker replies over marginally more eloquent ones.

What Most People Get Wrong About AI Costs

The instinct is to shop for a cheaper provider. "Should I switch from OpenAI to Claude? From Claude to an open-source model?" Sometimes that helps, but the real leverage is architectural. I've seen businesses switch providers three times and still overpay because the fundamental pattern — one model for everything, no caching, verbose outputs — never changes.

If your AI API bill is higher than you'd like, start with these questions: How many of your API calls actually need a premium model? Are you sending the same context repeatedly? Can any of your calls be batched? Are your prompts asking for more output than you use?

The answers usually reveal that 60-80% of your bill is waste hiding in plain sight. You don't need to spend less on AI. You need to spend smarter.

FAQ

How much do AI API calls typically cost for a small business in India?
Most small businesses using AI APIs spend between ₹15,000 and ₹1,00,000 per month depending on volume and model choice. The biggest cost driver is using premium models for tasks that cheaper models handle equally well.

What is model routing and how does it reduce AI costs?
Model routing means sending each task to the cheapest AI model that can handle it well. Simple classification tasks go to lightweight models, while complex reasoning goes to premium models. This alone can cut costs by 40-60%.

Can prompt caching really save money on AI API bills?
Yes. If your application sends similar system prompts or context repeatedly, prompt caching avoids reprocessing those tokens. Depending on your use case, this can reduce input token costs by 50-90% on repeated calls.

Is it worth switching AI providers just to save costs?
Not always. The real savings come from architectural changes — model routing, caching, batching, and output token optimization — not from switching providers. That said, comparing pricing across providers for your specific use case is always smart.

Archit Mittal helps businesses automate chaos. Follow on LinkedIn: @automate-archit

Related reads:

The CFO's AI Playbook: 5 Finance Automations Every Indian Business Should Run in 2026

Archit Mittal — Sat, 20 Jun 2026 03:35:43 +0000

Over 60% of APAC finance leaders say AI-led automation is their top priority for 2026. For Indian businesses, that stat hides a quieter truth: most SMBs have no idea which automation to start with. They hear "AI for finance" and picture an enterprise suite with a six-figure licence fee. Wrong picture.

This is the playbook. No enterprise suite. No subscriptions you don't need. Each automation is something I've shipped for real clients using Python, free APIs, and a ledger that's usually Tally or Zoho Books.

1. Bank Reconciliation — The Single Biggest Time Sink in Indian Finance

A CA friend was losing two sleepless nights before every GST deadline on exactly this. We replaced it with a Python script that pulls statements from email attachments, categorizes transactions using keyword rules, cross-references entries with Tally, and flags only the mismatches in a clean Excel file. Eight hours dropped to fifteen minutes of review.

"Tu 2 saal pehle kyu nahi mila?" (Why didn't I meet you two years ago?)

If your team is still opening each bank statement manually, start here. It's the highest-ROI automation in Indian finance. I've written the full workflow in how a weekend Python script saved a CA firm 209 hours during ITR season.

2. Cash Application — Matching Payments to Invoices at Indian Speeds

Globally, AI-driven cash application handles up to 90% of invoice matching without human touch. In India, it's harder — money arrives in more shapes than most tools expect: UPI, NEFT, RTGS, IMPS, cheques, partial payments, grouped settlements where one transfer covers four invoices. Manual matching is why so many Indian SMBs run receivables that are perpetually a week out of date.

I build a three-layer pipeline. Layer one parses payment references — UTR numbers, invoice IDs, sometimes just a customer name in the remarks. Layer two tries deterministic matches: exact amount, reference, customer. Layer three hands the ambiguous ones to a lightweight AI model that reasons about partial amounts, nicknames, and grouped payments, then suggests matches with a confidence score.

Above 95% confidence gets auto-applied. Below that goes to human review. A D2C brand I rolled this out for went from a seven-day receivables gap to same-day application. Their working capital position shifted by roughly ₹14 lakhs without a single new customer.

3. Real-Time P&L Reporting — Know Your Numbers Before the CA Calls You

Most Indian SMB founders see their P&L twenty days after the month ends, when their accountant sends a formatted Excel. By then, the decisions that would have mattered — cut this spend, double that campaign, pause that hire — are a month old.

Real-time P&L automation closes that gap. A scheduled Python script pulls trial balance data overnight, categorizes new entries into your chart of accounts, and renders a dashboard with revenue, gross margin, operating expenses and EBITDA as of yesterday. Usually in Google Sheets or a lightweight HTML dashboard.

What this actually changes: You stop making capital decisions on twenty-day-old data. For a business doing ₹30L/month, a single well-timed cut or push based on real-time numbers can move EBITDA by 2-3 percentage points over a quarter.

This pairs beautifully with the ₹0 automation stack I've written about — cron, Python, Google Sheets, and free accounting exports give you an enterprise-grade finance dashboard without a rupee of subscription spend.

4. GST Filing Prep — Eliminate the Three Nights Before Every Return

GSTR-1, GSTR-3B, and the quarterly reconciliations are the other reason finance teams lose sleep. The filing itself is data entry. The real work is pulling sales data, reconciling with purchase registers, checking vendor filing mismatches, and formatting it all for the GSTN portal.

Every one of those steps is automatable. I build GST prep bots that run on the 28th of every month. They pull sales and purchase data, compute GSTR-1 and GSTR-3B figures, pull vendor GSTR-2A data via the GSTN API, flag reconciliation mismatches, and produce a filing-ready summary.

A small manufacturing client went from three anxious days a month to a two-hour review window. Their CA still does the actual submission — that's judgment work, stays human. The 80% that's data plumbing? Gone.

5. Expense Categorization — Stop Miscategorizing Half Your Costs

This one sounds boring. It isn't. Miscategorized expenses are a silent killer in Indian SMB P&Ls. A ₹2L advertising spend mis-booked as "professional fees" wrecks every board metric that flows from it.

Expense categorization automation uses an AI model trained on your own chart of accounts and historical entries. Each new entry gets a suggested category with confidence. High-confidence ones auto-categorize. The ambiguous 10-15% goes to a review queue. Your reviews feed back in and the model sharpens.

For a client with ~800 expense entries a month, this shifted their finance lead's time from 6 hours of categorization to 45 minutes of review. Accuracy went from ~82% to 97%. Their board deck finally told the truth about where money was going.

The Five Automations at a Glance

Automation	Time Saved / Month	Typical Rollout
Bank reconciliation	6-10 hours	2-4 weekends
Cash application	15-25 hours	3-6 weeks
Real-time P&L	8-12 hours + faster decisions	1-2 weeks
GST filing prep	12-20 hours	3-5 weeks
Expense categorization	4-8 hours	1-2 weeks

Stack all five and you're recovering 45-75 hours of skilled finance time every month. For an SMB with a single accountant, that's effectively a second person at zero incremental cost. For a firm with a CFO, it's the difference between reactive month-end rituals and proactive capital decisions.

Where to Start (And Where Not To)

Do not try to build all five at once. That's how automation projects become automation graveyards. Start with bank reconciliation — bounded, high-ROI, and an immediate win. Once it's running reliably for two months, pick the next one where your team still feels stuck.

Also, don't automate what doesn't need to be automated. I've written a whole piece on when not to automate — it applies especially hard in finance, where reviewing edge cases is often the most valuable part of the job. The goal isn't a human-free finance function. It's one where humans spend hours on judgment, not typing.

"Jo kaam AI se ho sakta hai, AI kare. Jo judgment se hota hai, woh humans ke paas rahe." (Let AI do what AI can do. Let judgment stay with humans.)

That's the whole playbook. Five automations. Zero enterprise suites. A real finance function that tells you the truth, faster, with less pain.

Which of these five is eating the most hours in your finance team right now?

About the Author

Archit Mittal helps businesses automate chaos. Follow on LinkedIn: @automate-archit

Get automation insights every Saturday — join The Automation Dispatch at architmittal.com/newsletter.