A supplier sends you 800 SKUs. Not in a clean feed. In a 60-page PDF spec sheet, plus an Excel export with merged cells and three header rows, plus a folder of product label photos where the technical attributes live in 7-point type. Your PIM is ready to receive that data. The problem is everything that has to happen before the data is in a shape the PIM can accept.
On June 25, 2026 at 15:00 CEST, we are running a live session with Pimcore that takes exactly that pile of files and walks it all the way into Pimcore Studio. Raw supplier file at the start, structured PIM-ready product data at the end, in two days instead of two months. This post is the written version of what you will see on screen, so you know whether it is worth 45 minutes of your day. It is.
The work that actually breaks your timeline
PIM implementations do not run late because the PIM is slow. They run late in the layer nobody sells: supplier data onboarding.
After 15 years at LemonMind, more than 70 PIM implementations and roughly 40 million SKUs in production across Pimcore, Akeneo and Ergonode, the pattern repeats on every project. The platform works. What stalls is the human work of receiving a supplier file, understanding the products inside it, mapping foreign attribute names and units to your taxonomy, deciding what is a variant and what is a base product, and cleaning the whole thing before the PIM gets to do its job.
That work usually lands on a category manager who costs around 4,500 EUR per month and takes close to three months to onboard one supplier with a few thousand SKUs. Multiply by the 10 to 50 new suppliers a real distributor takes on every year and the annual bill sits between 135,000 and 675,000 EUR. That is the cost of doing nothing, and it ignores the revenue lost as products sit in a queue waiting to be listed.
The reason this never gets fixed is that it scales linearly with supplier count, which means it does not scale at all. Add a supplier, add the cost. The headcount math eventually wins, and the project that was supposed to ship in Q1 ships in Q3.
Where AI fits, and where it does not
The PIM category already runs on plenty of AI, and most of it is genuinely useful. Pimcore Copilot, for example, is strong at the work that happens once data is already inside Pimcore: generating and reformatting product descriptions, auto-tagging and classifying products, producing alt text and metadata, spinning up variants. That is enrichment. It makes good data better and ready for more channels.
openProd solves the step before that one. It ingests. It takes the chaotic file the supplier actually sent and turns it into clean, validated, structured records mapped to your Pimcore attributes. Enrichment assumes the data is in. Ingestion is how it gets in.
That distinction is the whole reason this webinar is co-branded. The two layers are complementary, not competing. openProd sits in front of the PIM as an AI product data middleware, hands Pimcore clean data through a native bundle, and from there Pimcore and Copilot do what they do best. The live walkthrough shows both halves of that stack working on the same dataset.
The workflow, step by step
Here is the sequence we will run on June 25, in the same order you will see it live.
1. Drop the raw file
We start with the worst-case input on purpose: a supplier PDF with embedded tables and inconsistent layouts, alongside an Excel file that no human enjoys reading. No pre-cleaning. The point is to show what happens when you feed the system the file you were actually sent, not a sanitized demo file.
2. Extraction
A multi-agent pipeline reads the documents. This matters more than it sounds. Different file formats and different data structures need specialized agents coordinated by a conductor agent, not one large model with a giant context window trying to do everything at once. We tried the single-model approach early. It fell over on real supplier data. Vision-capable extraction pulls product names, specifications, dimensions, prices and attributes out of tables and even out of label photographs, and returns them as structured fields.
3. Mapping to your Pimcore model
The supplier’s data model never matches yours. Different attribute names, different units, different categories, different language. The pipeline maps the extracted fields onto your Pimcore class definitions and attribute structure, normalizes units, and flags duplicates against what is already in your catalog. This is the step that eats weeks of a category manager’s time, compressed into minutes.
4. Confidence scores on every field
Every mapped field carries a confidence score. This is the difference between “AI did the work” and “AI did the work and told you exactly where to look.” Without it, you are back to reviewing every field by hand, which is the problem you started with. With it, your team reviews the 8 percent the system is unsure about and trusts the rest. The governing rule is one sentence: AI proposes, you decide. Nothing reaches the PIM without a human sign-off.
5. Push to Pimcore Studio
Approved records flow into Pimcore Studio through a native bundle. From that moment the data behaves like any other Pimcore data object: workflows, versioning, channels, and Copilot enrichment all apply. The supplier file that arrived as a 60-page PDF is now governed product data living in your PIM.
The same pipeline that pushes into Pimcore also speaks REST API to Akeneo, Ergonode or a custom catalog, because the ingestion problem is identical regardless of which PIM sits behind it. On June 25 the destination is Pimcore Studio, and the integration is native.
What this looks like on real supplier files
The numbers above are not theoretical. Every one of them comes from running this workflow live on a prospect’s own files. Here are three recent examples, anonymized, because the point is the pattern, not the logo.
A building-materials distributor running Pimcore sent us a supplier Excel file the day before a session. On screen, the pipeline imported the first batch of products in about two and a half minutes and auto-mapped roughly 500 attributes against their Classification Store, including the semantic matches that usually need a human: a supplier’s label for a thermal value lined up to the correct normalized attribute, and units converted on the fly from grams to kilograms and millimetres to metres. In the same dataset it detected 128 product variants out of a PDF that contained no explicit variant list. The reaction in the room was the quiet kind: that is the part we actually spend our weeks on.
A fasteners manufacturer had no PIM at all. What they had was a 28-page sales catalog in PDF, the kind of document you would otherwise retype by hand. That PDF went in, and the pipeline generated 15 variant SKUs from a single base product automatically, classified them to ETIM, and produced a BMEcat export. Greenfield to standards-conformant data, from a sales brochure.
A fasteners distributor gave us nothing at all. We took their own public product catalog and ran it. ETIM-classified and export-ready in minutes, which was expected. What was not expected, by them, was the second half: the system surfaced quality problems hiding in their own published catalog, including duplicated codes, undocumented prefixes, and a transposed diameter value. Nobody on their side had flagged those. The pipeline did, because confidence scoring treats an out-of-range value as something to check rather than something to wave through. Speed gets attention. Catching the error a human missed is what earns trust.
Why this session is built for the DACH market
If you sell technical or B2B products in Germany, Austria or Switzerland, the supplier data problem has a specific shape, and it has a name: standards compliance. BMEcat, ETIM and Datanorm are not nice-to-haves in DACH B2B trade. Without ETIM conformity a product simply drops out of the filters on many B2B marketplaces, which means it effectively disappears for buyers who shop by technical attribute.
The catch is that suppliers rarely send you clean, standards-conformant data. They send what they have, in the format they keep it in, and the job of getting it to ETIM-class and BMEcat-ready structure falls on you. That mapping work, technical attributes to the right classification, values to the right units, is exactly the work the pipeline automates. If your team has ever hand-mapped a supplier catalog to ETIM, you already know why two days versus two months is not a marketing number. It is the difference between listing a supplier this quarter and listing them next year.
For a deeper background on the standards themselves, our team keeps a free guide to ETIM and BMEcat that pairs well with this session.
The ROI table the CFO will ask for
| Approach | Time per supplier (a few thousand SKUs) | Cost per 1,000 products | Scales with supplier count |
|---|---|---|---|
| Manual onboarding | 2 to 3 months | High, fully loaded headcount | Linearly, so not at all |
| openProd into Pimcore | Around 2 days | Roughly 95 percent lower | Flat |
The headline is 95 percent time savings versus manual onboarding and around 14,000 EUR saved per 1,000 products. Those are LemonMind numbers from real implementations, not a vendor estimate. The webinar shows the workflow that produces them, on a real file, end to end.
What you will leave with
This is a working session, not a slide tour. By the end you will know:
What a multi-agent ingestion pipeline actually does, and why it beats a single model on messy supplier files. Where confidence scores change the economics of review, and how the AI-proposes-you-decide model keeps a human in control. How clean data lands in Pimcore Studio through a native bundle, ready for workflows and Copilot enrichment. And how to estimate, for your own catalog, what moving from manual onboarding to AI ingestion is worth in time and money.
If you run a PIM, own product data, or carry the timeline for a Pimcore project, this is the part of the stack that decides whether you ship on schedule.
Join us live
openProd x Pimcore, June 25, 2026. Olgierd Mrozik, CEO of LemonMind and co-founder of openProd, runs the full workflow live: from a raw supplier file to PIM-ready data in Pimcore Studio. Bring your worst supplier file in your head as the benchmark, and judge the result against it.
Register at pimcore.com/pimcore-openprod.io-webinar. If you cannot make the live slot, register anyway and we will send you the recording and the ROI worksheet.
