Building a Unified Namespace with Tatsoft FrameworX

Session 1: Welcome and Introductions 

Speaker 1 (Isabela): 
Hello everyone! I can see some people already joining. Welcome! 
I’m going to give everyone a few minutes to get connected before we officially begin. 
First, thank you so much for being here today — it’s truly a pleasure to have you with us. 

My name is Isabela, and I work with the Marketing team here at Tatsoft. 

Today, we’re going to talk about building a Unified Namespace using Tatsoft’s FrameworX platform. 

Specifically, we’ll walk through the solution we built for the ProveIt! 2025 Conference. 
(And don’t worry — if you’re not familiar with ProveIt! yet, I’ll explain what it is in a moment.) 

At its core, today’s presentation is about how FrameworX outperforms other IoT platforms — 
especially when it comes to speed, flexibility, and cost. 

Today’s agenda: 

• The presentation will run for about 40 minutes. 
• After the presentation, we’ll open it up for live Q&A. 
• Feel free to use the chat during the session to submit your questions — 
  our Senior Engineer Philip will be keeping an eye on incoming messages. 
  If there’s something we can answer immediately, we will — otherwise, we’ll address everything during Q&A at the end. 

Quick notes: 

• This session is being recorded. 
• I’ll be sending the recording along with the Q&A summary to everyone who registered. 
• If you have any technical issues (audio or video), please let us know via chat — 
  you may also want to double-check your Zoom settings if needed. 

Alright — I think everyone is getting settled! 

Now, before we dive into the demo and technical details, I’d like to introduce the team you’ll be hearing from today: 

• Marc Taccolini, Founder and CTO of Tatsoft. 
• Dave Hellyer, Vice President of Business Development. 

Dave is going to kick us off with a brief introduction to Tatsoft and FrameworX, and then Mark will take over to walk you through the technical side of the project. 

Dave, can you go ahead and get us started? 

Session 2: Company Introduction and ProveIt Background 

Speaker 2 (Dave): 
As Isabella mentioned, today’s session is focused on what we built for the ProveIt 2025 Conference, held earlier this year in Dallas. 

This was a very unique conference. 
Typically, companies show up at events with their best salespeople, set up booths, and talk about how great their technology is. 
ProveIt was different — it didn’t allow that approach. 
You had to actually prove what your technologies could do by demonstrating a real-world solution, live and working. 
No sales pitches — only working systems. 

We were excited to be part of it and had a great turnout. 
Today, we’ll walk you through the solution we presented there, and hopefully, you’ll see the value and flexibility FrameworX brings to projects like this. 

For those of you new to Tatsoft: 

• We’ve been around as Tatsoft since 2009. 
• However, many of us, including Mark and other team members, have much deeper experience in industrial automation — stretching back well before Tatsoft was founded. 
• Our flagship product is FrameworX — a fourth-generation industrial software platform, designed using the latest technologies. 

FrameworX is built specifically for: 

• SCADA (Supervisory Control and Data Acquisition) 
• IIoT (Industrial Internet of Things) 
• Data Hub applications 
• And more. 

We’re headquartered in Houston, Texas, with offices in Brazil and the United Kingdom. 
We also have partners around the world who support and deliver solutions based on FrameworX. 

FrameworX is a real-time data platform. 
It helps you collect, process, visualize, analyze, and act on real-time operational data — all using a single, unified platform. 

Some of its key strengths: 

• High-performance HMI: You can build a display once and run it anywhere — 
  on a Windows machine, inside a web browser, or on smartphones — all from the same design, using the same toolset. 

• Unified development environment: There’s no need for different tools depending on where you deploy. One design, multiple deployment targets — web, mobile, local. 

We’ve been successfully applying FrameworX across many industries, including: 

• Oil and Gas 
• Pharmaceuticals 
• Transportation 
• Steel and Metals 
• Mining 
• Materials and Manufacturing 

Even though these industries differ, they all share common needs: 

• Connect to real-time data 
• Collect and store it 
• Process it 
• Visualize and analyze it 

FrameworX offers a fully integrated set of tools to meet those needs, no matter the industry. 

About the ProveIt! Conference: At ProveIt, there were strict rules of engagement: 

• Every vendor solution had to integrate with a Unified Namespace (UNS) — a shared, virtual data layer. 
• You had to demonstrate a real-world solution using live data. 
• The goal was to show actual integration and problem-solving, not just talk about it. 

There were also specific questions that each participant had to answer: 

1. What problem did you solve? 

1. How did you solve it? 

1. How long did it take to implement? 

1. What would it cost if a manufacturer wanted to adopt your solution? 

We were able to answer all those questions during the event, and we’ll walk you through that today. 

Specifically, the problem we addressed was about seamless data connection, visualization, and transformation — using data coming from multiple different vendors and sources, integrated through the UNS. 

Our solution was built using: 

• MQTT 
• OPC UA 
• SQL 

We aggregated and analyzed data from the UNS and turned it into actionable insights. 

Timeline: 

• It took about two weeks of engineering work — 
  about 80 hours total — to build and deliver the solution. 

Cost: 

• Including redundant servers, the solution would cost under $20,000. 
• A typical full deployment would range between $20,000 to $50,000, depending on scope and customization. 

Now, I’ll turn it over to Marc, who will walk you through the technical side: 

• How the solution was built, 
• The architecture we used, 
• And the key technology features of FrameworX that made it possible. 

Session 3: FrameworX Architecture and Platform Overview 

Marc: 
Thanks, Dave. 
I’ll now share my screen so you should be seeing the presentation from my computer. 

Before I dive into our solution for ProveIt!, just a quick overview for those who are new to FrameworX. 

FrameworX is a platform to build applications based on real-time data. 
The key concept behind it is simple: 
Instead of requiring you to pick and assemble different modules separately, FrameworX includes everything you need by default. 

Even on the communication side, FrameworX comes with more than 75 built-in drivers at no additional cost — supporting a wide range of industrial protocols. 

Our platform covers: 

• Data Communication 
• Alarming 
• Historical Data Storage 
• Integration with SQL Databases 
• Dashboards 
• Reporting 
• And much more 

All built directly into the product — no need for third-party modules. 

Because FrameworX is 100% built in .NET, it integrates seamlessly with third-party applications and cloud systems. 
You can deploy FrameworX on: 

• Windows servers and workstations 
• Linux devices 
• Embedded systems (thanks to .NET Core/.NET 8) 

And importantly: all modules are included even when you’re deploying at different scales. 
Sometimes, when you’re building solutions, you need lighter versions for: 

• Machine HMI panels 
• Data collection at the edge 
  FrameworX has you covered across the entire architecture, from Edge to Cloud. 

Connect → Process → Visualize 

When you configure solutions with FrameworX, you’ll think in three logical steps: 

1. Connect: 
   Collect data from your assets, devices, and systems. 

1. Process: 
   Apply logic, calculations, normalization, and store results. 

1. Visualize: 
   Build intuitive user interfaces, dashboards, and reports for actionable insights. 

Each of these steps has specific modules in FrameworX to support them. 

This “Connect-Process-Visualize” framework is what we used when building our solution for the ProveIt event. 

Challenges at ProveIt! 2025 

At the ProveIt! conference, the environment simulated a virtual factory — multiple production lines, multiple vendors publishing live data to a shared UNS (Unified Namespace). 

Key challenges: 

• Some data was static and predefined — we knew the structure in advance. 

• Some data was dynamic — we had no idea how many assets or machines would show up during the event. 
• Different vendors published data in different formats, different naming conventions, and different levels of quality. 

Handling Dynamic and Static Data Together 

To solve this, FrameworX used its Unified Namespace features. 

In FrameworX, you can: 

• Define a known asset model (structured data) 
• At the same time, dynamically connect to external systems like MQTT Brokers, OPC UA servers, or other sources — 
  and automatically pull in data structures you don’t know in advance. 

For example: 

• Known structure: We defined the production lines, areas, and base assets. 
• Dynamic structure: We created dynamic connections that pulled new devices and assets live from the UNS broker during runtime. 

In our configuration, the dynamic data appears seamlessly inside the asset tree — without needing manual mapping or reconfiguration. 

Quick Live Demo of Dynamic Connection 

(While showing on screen) 
In FrameworX Designer, you can create a dynamic connection like this: 

1. Choose the dynamic provider type (e.g., MQTT Broker, OPC UA Server). 
2. Configure connection credentials. 
3. FrameworX immediately starts browsing the structure and brings in the live asset model. 

You can also filter which parts of the external model you want to expose — for example, only data under a certain topic or device group. 

Compared to other platforms: 

• In FrameworX, dynamic connection setup takes about 5 seconds. 
• No need to configure hundreds of points manually. 
• You get automatic population and synchronization. 

During the ProveIt event, we connected to all 38 vendors using this approach. 
(As far as we know, we were the only company connecting successfully to all vendors.) 

Processing the Data 

After connecting the data, we needed to normalize it. 

The challenge was that different vendors provided: 

• Different OEE (Overall Equipment Effectiveness) metrics 
• Different hierarchy models 
• Inconsistent tag structures 

FrameworX allows you to: 

• Write scripts in C#, VB.NET, or Python 3. 
• Apply transformations directly inside the real-time database. 
• Standardize models without external tools. 

All processing objects — tags, devices, alarms, database tables — are first-class objects in FrameworX. 
You can browse, manipulate, and extend them easily. 

Example: 
When normalizing OEE data, we could dynamically detect: 

• Asset paths 
• Device types 
• Data quality levels 

And process them without predefined hardcoding. 

Visualization Layer 

Finally, we built the visualization part. 

Key points: 

• Single design runs across Windows Clients, Web Browsers (HTML5/JavaScript), and Mobile Devices. 
• Switching between screens happens in under 100 milliseconds. 
• Fully responsive canvas adapts UI components to different screen sizes without needing to redraw layouts manually. 

Even under high data update rates (10–15 changes per second), the displays remained fast, smooth, and stable — 
critical for factory-floor users who expect instant feedback. 

That’s the basic architectural overview: 

• Unified dynamic connection to the UNS 
• Real-time processing and normalization of incoming data 
• High-performance visualization across all platforms 

Now I’ll move on to show you a live demo of the application and some performance highlights. 

Session 4: Demo Walkthrough and Performance 

Speaker 3 (Marc Taccolini): 

Let’s walk through the demo we created based on the ProveIt! application. 

When you install the latest version of FrameworX, we actually include this demo as a reference project — 
we call it GS Demo, and it’s built using all the same concepts we used at the conference. 

Now, one important clarification: 

• At the actual event, we connected to a shared MQTT broker hosted by the ProveIt team. 
• Right now, that broker isn’t available, so for this demo, we’re using our own internal MQTT environment — 
  but the architecture and configuration are the same. 

Virtual Factory Layout 

The demo represents a virtual factory with multiple production lines and zones. 
Each production line has several machines, and vendors were publishing data for different parts of this model. 

Here’s what made this complex: 

• In reality, 25+ vendors were pushing data to the same broker. 
• Some of that data was predictable (e.g., fixed asset IDs). 
• Much of it was completely dynamic, showing up during the event without advance notice. 

FrameworX handled both: 

• Known structures were statically mapped. 
• Unknown assets were automatically pulled into the dynamic Unified Namespace. 

Live Visualization and Performance 

Let’s look at the visualization layer. 

I’ll click through different sections of the application now. 
Pay attention to the responsiveness: 

• I click — and the new display loads instantly. 
• I click again — and again, it updates immediately. 

This is running inside a browser, over Zoom screen share — and you can still see how fast it is. 

That’s because FrameworX: 

• Uses WebAssembly for fast rendering. 
• Pushes data updates in under 100 milliseconds. 
• Keeps interface performance identical across Windows, Web, and Mobile deployments. 

Industrial-Grade Responsiveness 

We come from the factory floor — and that influences our performance standards. 

In a control room, if an operator clicks something and it takes more than 250 milliseconds to respond, 
they assume the system is frozen — and start mashing buttons or restarting the HMI. 

That’s why FrameworX is optimized for: 

• Fast transitions 
• Minimal lag 
• Stable rendering, even under rapid-fire data updates 

UI Customization and Themes 

Another thing we included in the demo is theme switching. 

Out of the box, FrameworX includes: 

• 12 default themes (light and dark) 
• 2 high-contrast themes 
• And full customization support — you can brand it with your own company colors and identity 

So for operators spending hours looking at the screen, you can offer more comfortable visuals and consistent branding. 

And that same theming is reflected in both: 

• The runtime application 
• The configuration environment (Designer tool) 

Responsive Design and Layouts 

FrameworX also supports responsive canvas design — which means: 

• UI elements adapt to screen size dynamically 
• You can define how each component resizes (proportional, block-based, or fixed) 
• The system adjusts to mobile devices, tablets, and wide displays without rebuilding layouts 

For example, in this demo: 

• On desktop, you’ll see a full sidebar, top nav, and full-size charts. 
• On mobile, that same layout switches to a simplified view — 
  the navigation changes and buttons resize for touch input. 

All of that behavior is built using our layout engine — 
no need to duplicate screens or manage multiple versions of the same display. 

Marc (wrap-up of Session 4): 

So to summarize the demo portion: 

• You saw how fast we can load and switch displays. 
• We support responsive UI for all devices. 
• Our system handles thousands of live data points, visualized with high performance. 
• And everything you see — from theme to layout to scripts — is customizable. 

Next, I’ll show you a few ways to customize logic and navigation using scripts inside FrameworX. 

Session 5: Customization, Themes, and Mobile Behavior 

Marc: 
Now let’s go a little deeper into customization — both in terms of logic and user interface behavior. 

One of the big challenges at ProveIt was the lack of consistency in how vendors published their data. 

For example: 

• Some published machine data under “City > Area > Machine.” 
• Others skipped the city layer. 
• Still others placed operational data in inconsistent or unexpected branches of the Unified Namespace. 

So we needed to create smart navigation that could handle this variability. 

Smart Navigation with Scripts 

Let me show you one example: 
In our application, we built a navigation page — we called it the menu tree. 

When a user clicks a region on the plant layout, the system automatically: 

• Checks the type of asset selected 
• Verifies whether it belongs to a city, machine, or other context 
• Loads the appropriate display based on the asset type 

This logic was written using client-side scripting, powered by WebAssembly. 

So it all runs inside the browser, instantly — no server delay, no refresh needed. 

Custom Behavior for Mobile Devices 

The same application also behaves differently when it detects it’s running on a mobile device. 

For example: 

• On mobile, we don’t load the full sidebar menu 
• We switch to a top toolbar that’s more compact and touch-friendly
• The layout adapts automatically based on screen resolution 

This isn’t a separate app — it’s the same project, just with conditional layout rules. 

So whether you’re running FrameworX on: 

• A phone, 
• A desktop browser, 
• A Windows operator station, or 
• An embedded panel… 

You’re getting the same core logic and visuals — customized intelligently by platform. 

Responsive Canvas Example 

Here’s a quick look at how our responsive canvas works: 

(While showing live on screen) 

• I resize the window — and UI blocks reorganize themselves 
• You can define resizing behavior for each component: 
• Some grow proportionally 
• Others snap into rows or columns 
• Some remain fixed-size (e.g., logo bars, legends) 

We call this responsive layout mode, and it gives you the flexibility to build screens once and use them everywhere. 

Previewing Different Screen Sizes 

Another neat feature: you can preview layouts in different resolutions directly inside the designer. 

You can simulate: 

• Tablet view 
• Smartphone view 
• Landscape vs. portrait orientation 

This makes it very easy to build and test mobile-ready HMIs without switching devices. 

UI Layers and Layout Management 

The layout engine in FrameworX supports multiple layers: 

• A navigation pane 
• A main content area 
• A toolbar layer 
• Optional pop-ups or slide-in panels 

You can show, hide, or replace any of these dynamically. 
And again — it’s the same design engine across all deployment types. 

So when someone says, “Can this application run on mobile?” — 
The answer is: yes. 
And not only will it run — it will behave as if it was natively designed for mobile, thanks to layout intelligence. 

Marc (wrapping Session 5): 
So to summarize: 

• FrameworX supports full theming and brand customization 
• UI adapts across devices without duplicating designs 
• You can build smart navigation based on asset type and structure 
• Client-side scripting allows interactive, high-speed behavior in-browser 

This makes FrameworX ideal for teams that want one solution to run everywhere — edge, web, cloud, or mobile. 

Let’s move now into the Q&A portion.

Session 6: Live Q&A Discussion 

Isabela: 
Alright, let’s move into the Q&A portion of our session. 
We received a number of great questions during the webinar — I’ll read them out, and Mark will provide the answers. 
Let’s begin with one that came in early: 

Q1: Is FrameworX a separate product from your SCADA solution? 

Marc: 
Great question. 
No — FrameworX is not separate from our SCADA. 
It’s actually the underlying platform that powers everything: 

• SCADA 
• HMI 
• IIoT 
• Data Hub 

It’s all one platform. You’re not buying separate modules — it’s one unified environment. 

Q2: Can FrameworX be deployed at the Edge within an IIoT/UNS architecture? 

Marc: 
Yes, absolutely. 
We’ve made major improvements to our EdgeConnect product line, which is part of FrameworX. 
With EdgeConnect, you can: 

• Deploy lightweight versions on embedded systems 
• Collect and normalize data at the edge 
• Use it as a protocol converter, MQTT publisher, or local historian 

And all of it ties directly into your Unified Namespace (UNS). 

Q3: Is there a containerized version? Can I run FrameworX in Docker? 

Marc: 
Yes. 
We have an official Docker image you can use out of the box. 
You can either: 

• Pull and run our prebuilt image 
• Or create your own custom image using our documentation 

You’ll find everything you need at docs.tatsoft.com — just search for “Docker.” 

Q4: Just to confirm — is FrameworX a complete system to collect data, send it to Snowflake, process it there, and bring the results back in? 

Marc: 
Yes — and I love that you used the word “complete.” 
That’s exactly how we designed it. 

FrameworX: 

• Collects and publishes data to external platforms like Snowflake 
• Supports bi-directional flows, so you can bring results back in 
• Doesn’t require you to license or assemble individual modules 

Everything — including scripting, alarms, SQL, OPC, MQTT, visualization — is included. 

The only exception is a few niche power industry protocols, but that’s it. Everything else is built-in. 

Q5: Are the built-in themes standard, or can I customize them with my company branding? 

Marc: 
You can absolutely customize them. 
Out of the box, we include: 

• 6 light themes 
• 6 dark themes 

• 2 high-contrast options 
  And we also include two fully customizable themes where you can define all color values to match your brand. 

And yes — these themes apply to both: 

• The configuration tools 
• And the runtime displays 

Q6: Is the new version compatible with Linux? Do I need a Windows machine to run the server? 

Marc: 
No — you don’t need Windows to run FrameworX. 
You can: 

• Create, edit, and run FrameworX projects directly on Linux 
• Or inside a Docker container 
  The only requirement is that the machine supports .NET 8 (Microsoft’s cross-platform runtime). 

We’ve seen it run on: 

• Ubuntu 
• Debian 
• Raspberry Pi 
• Even routers with 400MB of memory 

Q7: How does the built-in MQTT broker scale? Can I use it in production? 

Marc: 
Great question. Here’s how we look at it: 

Our built-in MQTT broker: 

• Is ideal for development, testing, and mid-sized production 
• Can handle thousands of points, no problem 
• Offers basic admin and security tools 

However, if you need to scale to millions of points — like what we saw at ProveIt — 
we recommend pairing FrameworX with an enterprise MQTT broker like HiveMQ. 

At ProveIt, the shared HiveMQ broker was handling 1–3 million transactions, and we worked seamlessly with it. 

Q8: Can I use third-party WPF and HTML controls in FrameworX? 

Marc: 
Yes — and we support multiple rendering engines. 

You can build pages that are: 

• Portable — they run on both Windows and Web 
• Windows-only (WPF) — where you can use any WPF control 
• Web-only — where you can use HTML, JavaScript, or Blazor components 

You can even mix-and-match — 
if a page can’t run in one environment, FrameworX automatically loads an alternate version using the same navigation structure. 

Q9: What is the licensing structure for FrameworX? 

Marc: 
We offer flexible licensing that scales with your needs. 

You can start with: 

• FrameworX Unlimited — for enterprise solutions (unlimited tags, users, clients) 

Or go smaller: 

• FactoryStudio for mid-sized applications 
• MachineHMI for embedded HMI panels 
• EdgeConnect for protocol gateways or MQTT data servers 

And the same configuration tool supports all of them — so it’s easy to reuse projects across scales. 

Isabela (wrap-up): 
We had a few more questions we didn’t get to — including SQLite for historians and SMS notifications. 
We’ll follow up by email on those. 

Thanks again to everyone who submitted questions! 

Session 7: Closing Remarks 

Isabela: 
That brings us to the end of today’s session. 
Thank you so much to everyone who joined us — it’s been great to share this solution with you. 

As a reminder: 

• The recording will be sent to everyone who registered. 

• We’ll also include the Q&A summary and some links to learn more about FrameworX. 
• And we’d really appreciate it if you could fill out the survey — your feedback helps us improve these webinars. 

Dave: 
I just want to echo that — thank you again for attending. 
This was a unique event, and we were proud to be part of it. 
We’ll be hosting more technical sessions like this in the future, so stay tuned. 

Also, one last thing — 
If any of you are going to the CSIA Conference in San Diego this June, we’ll be there! 
We’d love to meet in person and talk about your projects. 

Isabela: 
That’s a great note to end on. 
We’ll be at CSIA June 2–6. Stop by, say hello, and let’s keep the conversation going. 

Marc: 
And from me — thank you again for your patience, especially with my accent! (laughs) 
Seriously though, I really appreciate your engagement. 
If you have a specific scenario or challenge, don’t hesitate to reach out. 

FrameworX is powerful, but with that flexibility, we know it can sometimes feel like: 
“Where do I start?” 

That’s what we’re here for — if you tell us about your setup, your challenges, we’ll help point you in the right direction with: 

• The right product tier 
• The right modules 
• And the most efficient configuration 

Thanks again everyone — and we hope to talk to you soon.