A US renewable-energy company was losing hours every week just gathering the same data, over and over, by hand. We replaced that manual grind with an AI pipeline that pulls utility data from PDFs, spreadsheets, and web pages, normalizes it, and runs itself on a weekly schedule — for a few dollars a month in AI cost. Here is exactly how we did it.
The problem: the same messy data, every single week
The client tracks electric-utility interconnection queues — the lists of projects waiting to connect to the grid. The catch is that every utility publishes this data differently. Some post a PDF. Some attach an Excel file. Some only show it on a web page. There is no standard, no API, and no consistency in column names, layout, or formatting.
So every week, someone on the team opened dozens of sources one at a time, copied numbers into a master spreadsheet, fixed mismatched columns, and hoped they didn’t fat-finger a row. It was slow, mind-numbing, and exactly the kind of work that quietly breaks: a missed file here, a transposed figure there, and downstream decisions are now based on bad data.
The task itself was simple. The volume and inconsistency were not. That is the sweet spot for AI.
Our approach: prove it small, then scale
We don’t believe in big-bang AI projects that take three months before anyone sees a result. So we started narrow.
We picked one PDF source, one Excel source, and one HTML source — one of each format — and built the pipeline to handle just those three. The goal was to prove the hardest part first: that AI could reliably read three completely different formats and turn them into one clean, consistent dataset.
We built it, ran it, and demoed the output side by side with the client’s hand-collected spreadsheet. Once they signed off on accuracy, we scaled the exact same pattern across the full list of utilities. No surprises, no wasted build, no “trust us, it’ll work at scale.” It’s the same “start small, prove it” principle we’d apply to any manual data-entry problem.
Why prove-it-small wins
- Lower risk — you validate the approach for a fraction of the cost before committing.
- Faster trust — the client sees real, checkable output in days, not months.
- Cleaner scaling — once the pattern works on three formats, adding the rest is repetition, not invention.
How the pipeline actually works
The system is a Laravel application using Claude Haiku — a fast, low-cost model — to do the parsing. Here is the flow, end to end:
- Fetch. On a weekly schedule, the pipeline pulls the latest file or page from each utility source.
- Detect changes. It checks whether the source has actually changed since last run. If a file is identical, it skips it — no AI call, no cost.
- Parse with AI. For new or changed sources, Claude Haiku reads the raw content — whether it’s a PDF, a spreadsheet, or a web page — and extracts the fields that matter.
- Normalize. Every source, regardless of original format, gets mapped to one consistent schema: same columns, same units, same naming.
- Store and track. The clean data lands in the database, and the run is logged with its AI cost and which sources changed.
Because the data is structured to begin with — it’s just inconsistently structured — Haiku handles it accurately and cheaply. We didn’t need a frontier model to read a queue table.
Cost controls built in from day one
AI that runs on a schedule can quietly rack up cost if you let it. We didn’t. The pipeline ships with four controls:
- Skip unchanged files — no AI call when a source hasn’t moved. Most weeks, most sources haven’t.
- Monthly budget cap — the pipeline stops itself before it can blow past a set spend.
- Per-utility on/off toggle — turn any individual source on or off without touching code.
- Cost tracking per run — every run records what it spent, so there are no mystery bills.
What changed: before vs. after
| Before (manual) | After (AI pipeline) | |
|---|---|---|
| Who does it | A team member, by hand | Runs itself, weekly |
| Time per week | Several hours | Effectively zero |
| Formats handled | PDF, Excel, HTML — all manual | PDF, Excel, HTML — all automatic |
| Consistency | Varies by person and day | One normalized schema, every time |
| Transcription errors | Frequent, hard to catch | Eliminated at the copy-paste step |
| Cost visibility | Hidden labor cost | Tracked per run, capped monthly |
The results
The numbers that matter to the client are simple. The hours that used to go into collecting and cleaning data each week are gone — that time now goes to analysis and decisions instead of copy-paste. The error class that comes from manual transcription is eliminated, because no human is retyping anything. And the whole thing runs for roughly the price of a coffee per month, with every run’s cost tracked and a hard cap in place.
Just as important: the data is now consistent. Every source lands in the same shape, so the team can actually trust comparisons across utilities — something that was never quite true when three different people cleaned three different formats three different ways.
Could this work for your data?
If your team spends recurring hours pulling the same information out of PDFs, spreadsheets, and web pages — and reformatting it into something usable — this pattern almost certainly applies. The ingredients are the same in most industries: messy sources, a clear target format, and a task that’s simple but relentless.
The win isn’t just the hours saved. It’s that the work becomes reliable, repeatable, and cheap enough that you stop thinking about it at all.
Have a weekly data grind you’d love to automate? Get in touch and we’ll scope it the way we did here — prove it on a few sources first, show you the output, then scale once you’re confident.
Find this useful? Add us as a preferred source on Google and our posts will surface more often for you.
Changes only what you see in Google. Nothing is shared with us.
