A recap of our live session, "AI Is Only as Good as Your Data: How Intelligent ETL Accelerates Data Readiness," with Rob Hartwig, Senior Solutions Architect at Adeptia. Missed it live?
Watch the full recording on YouTube →
Enterprise AI initiatives often stall before a single model is deployed—not because of the AI itself, but because of poor data readiness. We opened last week's webinar with a quick poll asking attendees: what's the single biggest obstacle keeping your organization from getting real value out of AI?
We expected a clear winner. We got a three-way tie — data quality, integration complexity, and governance, running neck and neck. Rob Hartwig, who spent three years at his previous company doing nothing but cleaning up data for AI and machine learning pipelines, wasn't surprised. "Data quality is the winner there for sure," he said, "but integration complexity is basically tied with it."
That tie is the whole story. Here's what we covered, and why it matters if your team is trying to get AI initiatives off the ground.
Why 80% of Enterprise AI Effort Goes Into Data Preparation
The stat Rob opened with: 80% of enterprise AI effort goes into preparing and wrangling data — not building models, not generating insights, just getting the data into a state where AI can actually use it.
It's not just a slide statistic. Rob mentioned a call from the week before the webinar, completely unprompted, where a customer described his machine learning team spending 80% of their time on exactly this — cleaning up data before any actual AI work could start. "That quote was independent of the stat we already had on the slide," Rob said. "He said the exact same thing."
Garbage In, Garbage Out
The mechanism is simple and unforgiving: garbage in, garbage out: Except AI amplifies it. Bad formatting, mislabeled fields, or inconsistent categorization doesn't just produce a bad result, it produces a worse one than the input data would suggest, especially on smaller datasets where a handful of errors carry disproportionate weight.
Why Traditional ETL Wasn't Built for AI-Ready Data
Traditional ETL tools are good at one specific thing: moving structured data between systems that already agree on the rules — database to database, fields and tables already labeled and consistent.
The problem is that most of the data enterprises actually need to bring in for AI doesn't look like that. It's flat files. It's Excel spreadsheets where someone added a new column last week and quietly broke every downstream mapping that depended on the old structure. It's legacy EDI formats and mainframe exports that predate anything resembling a modern schema. It's PDFs, scanned forms, and call transcripts sitting in storage, technically "data," but nowhere close to usable.
"One person adds a new column to an Excel document," Rob explained, "and the mapping you had before doesn't work anymore." Multiply that across every partner, every format change, every new data source — and you get exactly the 4-to-6-month onboarding timelines Rob said are typical for bringing in a new dataset the traditional way.
What Changes with Intelligent ETL
This is where AI-assisted mapping — what Adeptia calls Intelligent ETL — changes the equation, and it does it in a way that's less about replacing your team and more about removing a bottleneck that shouldn't exist in the first place.
The bottleneck, as Rob described it, usually looks like this: a business team notices a new data format or a changed column, and now has to file a request with IT to adjust the ETL mapping — even though the business team is the one that actually understands what the data means. IT already has a backlog. The request waits. The business team waits with it.
From a Messy Form to a Working Field Map
With AI-assisted mapping, that dependency loosens considerably. In the live demo, Rob walked through mapping a genuinely messy source (a hand-filled-out form, complete with sloppy handwriting, checked boxes, and circled answers) the kind of input that would break a traditional OCR template the moment a field moved position. Instead of relying on a fixed template, AI "hunts down" the data regardless of where it sits on the page: the state field, the zip code, the address, wherever they happen to be.
From there, mapping the resulting fields to a target schema follows a similar pattern: AI proposes a mapping, attaches a confidence score, and — this is the part worth pausing on — explains its reasoning and lets you test the output before you accept it. You can add context (a partner's data dictionary, internal notes on formatting) if the AI needs it, but often it doesn't. And when something needs adjusting, say a currency field needs dollar signs and decimals, you can drop into that one field, make the fix, and re-test immediately.
How Intelligent ETL Has Evolved Over 25 Years
One detail that stuck with us: this mapping tool itself isn't new. "We've had this AI mapper for 25 years at Adeptia," Rob noted, "and our customers loved it even before AI was involved." That’s back when it meant manually writing XSLT code by hand. What's changed isn't the underlying tool's philosophy, it's who can use it. The same mapping logic that used to require a specialist fluent in transformation code can now be driven by a business user describing what they want in plain language and the AI writes the comments explaining what it did and why.
The result, per Rob: datasets that used to take 3–6 months to onboard now take days or weeks.
Validation and Business Rules — Not Just Mapping
Mapping is half the story. The other half is making sure the data that comes through actually meets your standards and this is where AI-assisted business rules came up in the demo.
Instead of writing validation logic in code, you describe the rule in plain language — "date of birth can't be in the future," or something more layered, like a dependent's date of birth needing to fall after a parent's. AI converts that description into deterministic Python code (not a fuzzy, inconsistent AI judgment call each time — an actual, testable rule), and you can immediately test it against sample data to confirm it catches what it should.
This is, in Rob's words, one of the more freeing parts of the platform for business teams specifically: "A business user that knows the date should probably not be a future date... can do it themselves," without waiting on a data engineer to write the validation logic.
What Happens If AI Gets It Wrong?
This question came in during Q&A, and it's worth addressing directly, because it's the honest concern underneath a lot of AI adoption hesitation.
Rob's answer had two parts. First, mapping errors are catchable during mapping. You review the AI's proposed mapping field by field, and if something looks wrong, you correct it right there and re-test before anything goes live. Second, once data is flowing, AI-driven business rules act as an ongoing check at runtime, continuously validating incoming data against your defined rules — not a one-time check, but a constant one across every record moving through the system.
For anything with real uncertainty, like new or unfamiliar document formats, there's also a human-in-the-loop review step: processed documents can route to a person for a quick double-check before anything downstream depends on them. "Lots of ways to get the human in the loop," as Rob put it; the goal isn't unsupervised AI, it's AI that removes the manual work while keeping a person in control of the judgment calls that still need one.
You Don't Have to Rip Anything Out
Another question from the audience: can this just be added on top of an existing ETL or iPaaS tool, rather than replacing it?
Yes — and this seems to be a common enough concern that it's worth stating plainly. Adeptia doesn't require an all-or-nothing commitment. If you have a single painful step in an otherwise-working pipeline (say, unstructured document processing), Adeptia can slot into just that piece and leave the rest of your existing stack untouched. Rob described this as a "crawl, walk, run" approach — start with the one problem you actually have, and expand only if and when it makes sense.
That flexibility extends to deployment, too: Adeptia isn't a SaaS-only tool. Larger customers frequently install it directly in their own environment — Azure, GCP, wherever their infrastructure already lives — rather than being locked into a single hosting model.
Where Intelligent ETL Shows Up in the Real World
A few industry patterns came up repeatedly:
- Insurance — enrollment data, carrier feeds, and onboarding from multiple sources, cleaned up and routed to where it needs to go.
- Financial services — among the largest use cases, with long-standing customers including Visa, Voya, and AIG.
- Healthcare — increasingly urgent this year specifically because of the new FHIR interoperability standard, which companies are working to comply with by year's end.
- Manufacturing and logistics — EDI-based supplier transactions, a format that's been historically painful to modernize.
On scale: some customers run upwards of 80,000 automated processes a day through the platform and rather than manually digging through logs to monitor that volume, teams can simply ask AI in plain language what ran, what succeeded, and what needs attention.
On timeline: a recent onboarding for an S&P 500 customer was completed in 90 days — Adeptia's general benchmark, with some implementations completing in under 30.
Watch the Full Session
This recap covers the core ideas, but the live demo — especially watching AI process that hand-filled-out form and build a mapping from scratch in real time — is worth seeing directly rather than reading about secondhand. Watch the full webinar recording on YouTube →
And if you'd like to go deeper on the concept underpinning all of this, we've just published a companion guide: Download: What Is Intelligent ETL? →
Have a specific data challenge in mind? Request a tailored demo → and we'll walk through what this looks like for your actual environment — not a generic walkthrough.