The first use case that counts: how manual integration becomes a repeatable model
You do not sell a data platform with an architecture slide, but with a visible first win. Two use cases from pharmaceutical manufacturing and the question of what really changes.
Every connectivity initiative needs exactly one thing at the start: a "shining star" — a first, visible use case that secures budget and momentum. What is meant is not the perfect platform and not the complete data model, but a result someone can see and understand; only then does the organization start believing in everything that follows.
Sound familiar from your own projects? Most of the time, the start doesn't fail because of the technology — it fails because nobody has a tangible reason to keep going. Two cases show what that first win can look like — and what it sets in motion.
Use Case 1: Standardized Communication Between MES and the Process Control Level
This case is the classic shining star. Starting point: for every line, MES programmers (MES, Manufacturing Execution System) and OT programmers (OT, Operational Technology) build integrations by hand — every connection a one-off, every message between systems handled individually. It works, but it doesn't scale, and every change costs effort all over again.
Integration per line, by hand
Many MES and OT programmers build their own connections for every line. Message handling is individual for each system, and the effort repeats with every new line.
One standardization layer
The connectivity layer acts as a message broker: it translates a standard MES message into whatever the underlying process control system understands — defined once, reused everywhere.
This wasn't rolled out for a single site, but across all sites. The result: a significant reduction in individual integration effort and a standardized approach across the whole company. Many one-offs become a pattern.
After that, the path of a message looks the same on every line:
Use Case 2: Using Data Beyond the MES
The second case started out as a side quest — one that emerged from the same infrastructure. Once the connectivity layer was in place, line data could be moved into the cloud. And that opened up an entirely different door: forecasting models, predictive maintenance, and further analytics applications.
This is the point where data starts to know something before the technician does: an impending failure shows up in the data pattern before it becomes a stoppage. That's possible because the data finally arrives where it can be analyzed — securely, and without starting from scratch for every new source.
What's notable here: the second use case wasn't planned. It became possible because the first one had laid the foundation — a base that suddenly allowed for more.
How to recognize a good first use case
Not every use case is suited as a starting point. The first use cases that opened the way for further ones in our projects have four properties in common:
Visible
The result is recognizable to operations and management, for example an integration that previously had to be rebuilt for every line.
Measurable
There is a figure for a before-and-after comparison, such as the integration effort per line or the time to the next connection.
Reusable
What is built for one line can be transferred as a pattern to further lines and sites.
Contained
The scope stays manageable and leaves validated systems untouched, so that the first success does not get stuck in fundamental debates.
Which structural prerequisites are needed afterwards so that the first success does not turn into a permanent pilot is covered in the article Why Industrial Data Fabric Projects Stall After the Proof of Concept.
What Actually Changed
You might expect a number now. I'm deliberately not giving you one — not as the real result, anyway. Because the decisive shift isn't a single metric but consists of two shifts:
The real benefit is templating, repeatability, reuse. And the effect multiplies across sites once the first connectivity layer exists.
The real change isn't a single metric — it's the shift from one-off, manual integration work to a scalable, repeatable model that accelerates every use case that follows.
How to make the effect of a use case visible
Anyone who wants to prove the change later does not need a large KPI landscape, but a few figures recorded from the first use case on. Four have proven useful: the integration effort per line in person-days, the time from request to first use of a new data source, the number of templates reused for a further line or site, and the number of sites working according to the same pattern. None of these figures is spectacular on its own. Together, though, they show whether one-offs really turn into a pattern, and they provide the arguments for the next budget round. It is important to record them before the first use case, because without a baseline there is no comparison later. An honest estimate from recent projects is often enough, as long as it is documented and understandable for everyone involved.
In regulated environments, one more condition applies: the first use case should only read validated systems, not change them. How that works architecturally is covered in part 2 of the series. That keeps the start small enough to become visible quickly without triggering a fundamental debate about re-validation.
Why the First One Is So Hard — and Still the Most Important
And here's the honest part: the first use case is the slowest and most laborious. Anyone who judges the model by the effort of that first step will underestimate it. Its value shows up at the fifth, tenth, twentieth — once the pattern is in place and every new connection runs almost by itself.
And one more thing engineers don't like to admit: in 18 years of OT integration, I've learned that the hardest part is never the technical one. The technology is manageable. The real work is change management — the path from "this is something new" to "this is just a tool I use every day." Getting a platform to feel that self-evident often takes not just months but more than a year. Knowing that in advance changes how you plan — and leads to fewer disappointments.
That's why the shining star matters so much: it delivers the proof that unlocks budget and support — and it's the first tile in a pattern that carries everything else. So the interesting question isn't really which platform you need. It's this: what would be the one visible win you'd start with? That's a conversation best had around your specific case.
What a first use case does not solve
A visible first success secures budget and support, but it does not replace direction. Without clear data ownership, without a way to take in new ideas and without someone who maintains the pattern, even a successful start remains a one-off. This calls for a self-critical look: as an integrator, we see the technical side of the pattern first. Whether it takes hold is decided in the organization, by the people who are meant to use it every day.
What would be your first visible win?
cts Group and Xenium AG look with you at how a first use case becomes a repeatable model, from the message broker to predictive maintenance.
Arrange a conversation
