Connect Vault in Real-time with ERP and PLM

MILTON CAPSIMALIS: Hi. Welcome to this AU 2023 presentation on connecting Vault in real-time with ERP and PLM. I'm Milton Capsimalis. I'm the head of North America for Cool Orange. We'll start off by telling you who we are. We're a partner of Autodesk that builds solutions to extend Autodesk's data management and PLM products, particularly in the area of design and manufacturing.

So a little bit about us. We were founded in 2009. We're mostly a bunch of former Autodeskers. We have easily 20-plus years of software development focused primarily in this area and in CAD and related. We're founded in Italy, Germany, and Spain. We have a office in the US now. We are 100% an Autodesk shop, so our software is built to extend the Autodesk platform. And our backgrounds and our focus is entirely on the Autodesk customer base.

So we have over 1,000 customers, 20 different countries. We work with partners all across the globe. One of the things about our software is that once people install it, almost nobody ever wants to give it up, so we have a very high renewal rate. This is just one of those things that once you get-- once you get your work all automated and connected up, nobody really wants to go back to doing things manually. And I'll show you what that looks like in a minute.

We work with Autodesk resellers, Autodesk themselves, other software, vertical software partners. Basically, we are deeply embedded in the Autodesk community and fully committed to developing solutions for our customers.

So what do we do? We build solutions to extend the Autodesk data management platform, both the PDM and PLM solutions, that really focus on three areas. If you're using-- let's start with talking about Vault, you already have a solution for keeping track of the corpus of your engineering data. You've got all your files in there. You've got their version history, and you have them all under control.

We provide solutions sort of to surround that. The first portion is what we call our load products, which are focused on helping you get your data into the Autodesk Data Management platform in the first place. We have a thing called power load. It's the most commonly used piece of this puzzle for grabbing all your files either out of an old system or off your shared drive and loading them into the Vault and getting them all organized. Similarly, if we want to extend that into PLM, we can do the same thing there.

The core of our products and the things that get used permanently by our customers fall into two related categories. One is what we call automation, primarily focused on a product called powerJobs. That product is a scripting engine that runs on the CAD and Vault clients and the Vault job processor that, like the name implies, automates jobs. So things that you would do repetitively, we allow you to write scripts to do those using Microsoft PowerShell so that you don't have to do things manually and so you don't make mistakes when things that have to be done over and over again, sometimes in bulk, have to be done perfectly.

And then the topic primarily for today's discussion are we have a set of tools in our Connect family that help you take that corpus of engineering data that you have in your PDM solution and connect that information with the other systems that surround it in your company's overall architecture.

And there's two primary products that we'll focus on today. One is a thing called powerGate, which is a gateway between primarily the Vault and products like ERP. And then a more specific product called powerPLM, which is connectivity between the Vault and PLM Solutions, specifically Fusion 360 Manage.

So one of the things that's interesting about the way we build our products is that we build a layer on top of the Autodesk APIs that allows two things. One is it allows you to customize and extend the capabilities of the product using a scripting language, Microsoft PowerShell. If you notice "power" in all of our names, well, that's where that comes from.

But it also allows us to isolate customizations from version upgrades of your Autodesk product. So if you do an annual upgrade cycle, you upgrade your Vault, you update your Inventor, your AutoCAD, et cetera, all of the customizations and things that you built, automations of common processes and things like that, all those automation scripts and things will move forward from version to version without having to do any changes. You don't have to recompile. You don't have to do anything like that when you go from version to version.

So let's dive into our integration solutions or our connect solutions. So here's the reality of the world. Engineers work typically in CAD, and PDM, and PLM. You're building up the information that's the primary intellectual property that defines the product you make, whether you make stable SKUs of products that have a long-term revision history, or you do engineered order of one-offs where everything's custom, or you do some combination of the above, at some point, you have to communicate information about the design work that you've done, usually when you're finished or finished with a change, over to other systems in your company.

Now, this can be PLM. This can be procurement. But the most common sort of target of that information communication and synchronization is ERP. And the reality in the world, sadly, is that a lot of this is done manually. And given the complexity, the most common information you're communicating between your design data and your CAD files and your ERP system are items, say parts and items, whether you call them parts or items, bills of materials made out of those. And then often, another set of documentation associated with that; PDFs of drawings, certain kinds of other artifacts like DXF flat patterns, or STEP files, or what have you.

There's a whole corpus of information that needs to be communicated to your other systems at the right time, in the right data form, correctly and without forgetting anything. And given how complicated bills of materials and things can be these days, that can be a truly painstaking process.

And these days, sadly we still see people sitting with two screens open and they're looking at their bill of materials in Inventor or in Vault, and they're cutting and pasting things into the material master of SAP, or the item master of one of the other ERP systems. And they're trying to translate codes in their head and remember what that value means over in that other system that they don't live in all day. So it's a painstaking, often slow, sometimes error-prone process that really, really, really deserves software to take some of that burden off you and to be sure that it's-- sure that you do it correctly.

So we have two pieces of software I'm going to profile a little bit today that automate a bunch of this and allow you to script out the most common actions during this integration process. So as I mentioned, the way we build this, we make it so that your integration and the customizations of your integration are independent of the Autodesk software version. We allow you to customize and extend the integrations and the automations, which I'll show you in a minute, based on PowerShell, which is sort of the-- if you're familiar with PowerShell, it's sort of the lingua franca now of IT automation.

So if you're doing an integration and you find a new couple of steps that you'd like to have automatically in your process, you want to create a different packet of files out of your different packet of PDFs out of your core drawings, even if you're not a PowerShell expert, you can probably find someone in IT who's just finished helping you upgrade your Active Directory server and they know a bunch about PowerShell and they can help you with that part. We're piggybacking off the fact that the IT world knows their way around PowerShell to do automation kinds of things. Just has the effect of making this stuff much easier to implement and to customize and even to maintain then sort of classic traditional .NET coding using C-Sharp or what have you.

And then the key to all this is that we're a software company, right? We do some services. We'll help with integrations. We'll help with deployment of these things. But our primary function is as a software development team that builds and releases software, interestingly enough, we also still act as staff augmentation to a certain extent for the Autodesk teams, which has the effect of keeping us exactly in cycle with Autodesk releases.

So they do their annual releases. When they're beta, we're beta. They release, we give them a couple of weeks and then we come out with our updates afterwards. So if you use our software, you'll never be in the circumstance where you're waiting for this piece of your architecture to decide to do an upgrade. We also provide free product support. This is a little bit of a humble brag, but our products don't require that much support running, so that's not exactly a big burden on us.

So let's talk about powerGate. So powerGate is-- it's a gateway middleware, as the name implies, I hope, that connects your specifically Autodesk Vault, so your PDM system which has your corpus of CAD data in it and works the sort of your release cycles and all for that data, to other systems in your company. It needn't just be ERP, but ERP is sort of the mainstay of this style of integration.

Because for many things that we sort of-- as sort of CAD bigots that we consider downstream of our work, it's the sort of first stopping point for the information that we publish out of our design repository. So that's where your parts get published, where your bills of materials get published, where you publish other kinds of artifacts and viewables and things that the people downstream who are going to buy parts, or make things, or whatever, that's where they'll find that information if they're not the kind of folks who have CAD and access to your Vault. So the powerGate system is the way to get that connection all automated.

So what does it actually do? The main thing that it does is it extends the user experience of the vaulted CAD user. So if you work in an Inventor, you're working in AutoCAD, you're working in AutoCAD Electrical, et cetera, it makes it so that the user working in that environment, in the normal way that they would work, they're working on a design that has a life cycle, they're collaborating with other people on their team on making changes, et cetera, as they're working in that environment, they have access to information about the correlated records in that other system in the context of their vaulted working environment.

So you have an item in your ERP system or a material, if it's SAP, it's called, that corresponds to a part in your Vault, the Vault-- the gateway knows how to both keep those things synchronized. It helps you create them in the other system at the right time and then it shows you information about the state of that object, information that lives in the other system, including helping with the transfer of this information in the first place. It can handle things like raw materials and virtual components.

It also knows-- the powerGate knows how to fit into the kinds of workflows that a vaulted CAD engineer expects to use. So for example, most of the things that you would do can either be done manually. We give you a right-click menu or a button. Or they can be tied into Vault workflows, so a release process. So the act of pulling a new part from your ERP system or synchronizing a BOM can be wired into your release process, so it'll happen automatically. It will kick off the synchronization automatically at the right time in your workflow.

We also have this concept of guardrails, which I'll show you when we get to that. But the idea is that we can put these little scripts and these little bits of intelligence interposed into the operations that the user does, so they go to check in a new file, they go to release something, they go to changes lifecycle state from one state to another, if there's a bunch of little checks that would be useful to do, so comparison values against a list, make sure things fall within a certain range, check permissions for things, though all those little checks and things can be automated and we can stop people from making mistakes or remind them to do things that they're supposed to do. That's why we call it guardrails. They go to go off the road, and we don't let them.

And then we can automate some of the most common operations that happen in bulk. The biggest of those tends to be things like generating documentation. So you go to release a whole big design, and there's a bunch of drawings in there that for every one of them, you want to create a PDF in a certain style and name it something, attach it back to the Vault, also send it over to fit into a document info record in your system on the other side that's attached to the part.

All of those things, if you have to do them manually and you have a bill of materials, for example, that has hundreds of parts in it, you're going to forget something or you're going to misname something or whatever. And the consequences of that downstream can sometimes be expensive. And the act of having to do it even if you get it right is painful.

So we attempt to automate all that stuff away, or at the very least put guardrails around the things that people do. So that they either don't forget things and things get done for them. And then, of course, all of this stuff is customizable because of the way the technology is designed. And I'll show you that when we get to it.

So essentially, this picture describes the bulk of what this does. We essentially take the user experience of a vaulted engineer, which this is a picture of a Vault, but it's similar if you're looking at the extensions to Inventor, or AutoCAD, or what have you. And what we do is we take the information that's correlated. So a part is often correlated to an item in your ERP system. So when you pull a new part, you pull a new part record on the other side. And we show you information about the record of the correlated object in the other system.

So in this case, you're looking at-- this is Microsoft Business Central. This is the example in this case. This tab here that says Business Central Item, you'll notice this Business Central BOM, that's essentially a view into the corresponding record in the other system. And it's actually live information that's pulled through this bidirectional gateway that we set up next to your Vault server that knows how to translate requests for information and to do operations between your vaulted CAD [INAUDIBLE] and the ERP system on the other side.

And then, like I said, all of this is customizable. You can customize what fields you want to see here, whether they're read write on this side versus that side. Sometimes the correlations are complicated because there's a field in your ERP system that in order to create it, you have to grab a couple of fields on the Vault side and concatenate them together and stick a revision number on the end or what have you. All those things that would normally be part of the manual work of creating a new item in the ERP or synchronizing a bill of materials, all those steps and all the little translations and all are automated behind here so that you don't have to remember each of the steps and you don't have to remember the codes and the other system and things like that.

So let me just give you a little example of what that looks like. So here we have an example. We're looking at an assembly with a part in Vault, so this is an Inventor example. And notice we have the part number, and it's got a title and description. This is sort of standard Vault stuff, right?

But then there's these other bits of information that really aren't in the Vault. That's actually information that belongs in Business Central. You'll see over here, we go over to the unit price, and we change it and we go and we say, all right, we've got a few more of these in inventory than we thought before, and all that's happening over in ERP.

And then we come back over to the Vault side, and we just refresh the view because it has to actually ask, and you notice those changed. So now it's got different number in stock and we changed the price. But we didn't do it on the Vault side and this information is not actually copied in the Vault because there's no good reason to keep that information in Vault. The person working in Vault might want to know. And it could be that information, any one of these fields is editable on this side and that side. That's fine too. You just have to decide that when we decide what fields get mapped.

And this is the general rule of this is the two objects, the part in Inventor, in this case the assembly in the BOM, is correlated with an object on the other side via usually the part number and then the fields that can be-- that we want to see in both cases. And the things that need to be transmitted when we create a new one or copy changes are handled by the software as part of how we set this up because usually these things are scripted with fairly simple rules.

So the most complicated portion of this is often centered around BOMs, right? So if you have-- you're doing your sort of classic big machine design, you have a multi-level bill of materials that uses items from your item list, all of this data, most of this data is in your Vault. Sometimes all of it. Sometimes most of it. What exactly those correspond to on the other side is determined by usually something like a part number.

But then how the fields correlate between the two systems and what codes mean on this side versus that side and all that could require a little bit of-- a little bit of mapping, which we can usually do up front. We explained what the-- we explain what the rules are on the ERP side and we say, OK, great, we can make that out of this field and this just maps exactly to that field. And then obviously, when we're looking at this, we make it so that you can customize this view, you can filter things, you can rearrange it so you can see what's been changed and all that.

And then we provide a bunch of capabilities for helping you do this initial creation and then maybe more importantly, synchronization. Because if you have a complicated multi-level bill of materials and you've been making changes to it, this part and that part, and you rearranged a few things, it's not always obvious when you then go to republish it. What's changed, right? And humans are terrible at that, especially if you're not familiar with both systems or you don't work in both systems all day.

So computers are great at it. So we actually give you the wherewithal with the software to run through and compare everything. So in this case-- I'll show you an example of this in a second-- it's telling you. We compare the BOM on this side and the BOM on that side. And there's two different parts, and one that went away, and 12 new ones were added and 48 were identical. So it's just telling you that you can decide what to do. You can say it's OK and then you can go-- or you can go back and change something because you didn't get it right or whatever. So what does that look like?

So in this case-- I can launch this-- we have an assembly here. It corresponds with a machine on the other side in this case, in Business Central. So this is the information about how that thing looks in the other side, in this case, Business Central. And here we say, all right, we've made some changes here. Let's go and check and see what the current state is or if someone might have changed things on the other side.

So in this case, we're going to check the items first. And it goes through and says, well, look, that part's OK, that part's OK, that part's OK. In this case, it's comparing a bunch of data that's returned from the other side. And it said, oh, look, you changed two of them and you put two new parts in there. So we're like, well, yeah, we knew that, so, OK.

Now once we saw that, we're like, OK, that's fine, so let's go ahead and send those. And sure enough, after that, it sends them. It all came back with no errors. And now let's go check our BOM because now the items are up to date, let's make sure if we added or changed anything. And it says, oh, well, you know what? Actually, you've got a couple of changes here.

So in this case, this is actually the screen from before. We had a couple that changed. We removed one. We added a couple, right? And so in this case, we say, all right, here's one that wasn't there on the other side. There's a couple others that weren't there on the other side, so they're new.

So we say go ahead and transfer them. And so now behind the scenes, it's talking to the API of the other system. It thinks it's done. So let's go over to the other side and let's see. So one of the things we often do is we-- well, in this case, we're just going to go look.

So now we go find this. This is the Business Central view of that same bill of materials. Let's go find the part that it thought it changed, the thought that we changed. And sure enough down at the bottom, we'll find there's a bunch of new screws that weren't there before. Now we have eight of these M4s. And there you go.

So the key here is that the synchronization between the bill of materials on the Vault side and the bill of materials in its own representation on the other side is coordinated by the software through a gateway so that we didn't have to go through and manually compare this or write out a spreadsheet, and then monkey with the spreadsheet, and then upload it to the other system, and then wait for it to tell us some errors and go back and have to figure out what we didn't get right or whatever. All that is negotiated by the software behind the scenes and then it surfaces the changes for you so you can decide what action to take.

So now, it's perfectly common that you would-- you want to do things like create new parts while you're working, say, in Inventor, one of the most common places to do this. So what we've done is we've made it so we also can extend the Inventor UI to add the capability to do things like right there at the beginning when you create a new part, if your ERP system requires you to pull a new part number from it as opposed to say Vault having a Vault numbering scheme that decides on the part number.

So if your ERP is particularly opinionated about part numbers, for example, SAP coming to mind, you have to ask at the beginning, and then we will permanently associate the part that we create and check into the Vault with that material ID, even if later it does or doesn't wind up showing up in any BOMs. So we extend the UI for that.

If also you want to select things like raw materials from a list of things that you can procure in your ERP system as opposed to in Vault, we can do that as well. We can pull up a dialogue in your-- right there in your Inventor and let you do that. Same thing for virtual components. If there's these things that don't have CAD parts associated with them but you want them to show up in your BOM and then they have them translate over to your ERP BOM, we can do that as well, all by extending the UI of Inventor, or AutoCAD, or whichever the apps you're using.

And obviously, if you've got parts that you've already created and you want to-- in the other side and you just want to find them and link them, then you can do that as well. And of course, all of this is customizable because Autodesk builds all these apps on top of-- with a .NET front-end and we've built this layer to make easy extension and customization of that UI and of the operations using the .NET framework.

So let's see what that looks like. So let's say-- let's say we have one-- we have a design in here. And let's go make a change to it. So pop it up in Inventor, go over, look at the symbol and we say, all right, let's find this one thing and let's add a raw material to it. So we go and grab this bearing and we say, well, let's make sure we select stainless steel or what have you.

So we're going to do a search now. And now this is a search through the gateway making a search against the ERP system. So it's actually calling whatever API underneath, but it's presenting it back in a Vault UI. Now we say, OK, well, this is the-- this is what we want to make it out of. We select that. That gets added back as a raw material and assigned to an iProperty in Inventor. So now it's going to be there in our Inventor BOM and it will carry all the way through the Vault and to when we synchronize the bill of materials later. We actually can go ahead and assign it. So now it gets surfaced nicely in the Vault later when this part gets checked back in, check back in.

So, OK, so at some point, we have to check it back in. And we should have made a comment, but we didn't. And then so let's see also now what else we want to do. Let's go add a virtual component. So now again, we're going to search Business Central, not Vault, and we're going to find Loctite adhesive.

We'll put some of that, add it into our Inventor bill of materials. There's no CAD part for that, but we don't care. We want it to show up in there and we want it to correlate and transfer when we transfer the bill of materials later.

So now if we look in our Inventor BOM, sure enough, there's our Loctite added in, three pieces of Loctite. I'm not sure exactly what a piece of Loctite looks like. And then so now we say, OK, fine. So we check it back in. We've made a couple little changes here.

And now this assembly and this design has lots of parts. And the bill of material has sub-assemblies, et cetera, et cetera. When we go to synchronize this bill of materials, we don't want to have to walk through all the parts and compare them against what's on the other side.

We don't want to have to export it to a spreadsheet and see if the numbers still match. Instead, we let the software go and behind the scenes and call over, check the status of every single one of the parts, check the whole bill of materials, walk the whole list, and then give us a summary of, well, what did you do? And in this case, it says, oh, yeah, you added three new parts and the rest are all the same. Fine. So we say, OK.

And then when we're done with that, we can transfer it over to the other side. And let's go find our new parts we put in here. So it's down at the bottom there where it says, that guy doesn't exist. So we go ahead and check it in and then transfer it, and then it'll show up on the other side.

And at no point here do we have to manually switch over to the other system. We didn't have to remember even where that screen was that does whatever. But here, we'll go over and just show you. If we go look at that bill of materials now, it'll have the Loctite somewhere on the list and all of that was handled automatically. We didn't have to notice. Because that could have been two days later you got around to actually synchronizing this BOM or it could have been someone else that did it, not you. So the key is that all this stuff is handled in a sort of a software dialogue between the two systems.

So what I showed you in the first example was a sort of manual version of kicking off these operations. So we had a button that said check, and then another one that said transfer. But often, Vault users set up their design processes using life cycles.

So you say, here's my workflow for creating changes to parts, or new parts, or a new whole design. And it may have a number of participants. You have some quality check or something in the middle and then you have-- and then you have finally sort of a release process. And sort of the most common thing is that we connect to the ERP system usually during release.

During all of the steps in the changes to your vaulted design, because of the way Vault allows us through its API to watch changes, both on the client via the interface between the client and the server and the Vault object change transitions themselves, we can put little bits of intelligence right in there.

So in this case, we have what we call a restriction where we say, hey, look, you just tried to release that part, but on the other side, it's in some state called block. You didn't know about it, but you're not allowed to do it. So it'll pop up a little dialog box and it'll tell you that. We can also put all kinds of just regular design restrictions. You say someone's not allowed to release this if certain things aren't filled in or they're not filled in correctly or whatever. All those little changes, all those little guardrails can be added in.

The other thing we can do is we can automate common operations that you have to do during this process. And the two sort of main stays of that are publishing artifacts. So if associated with releasing a design, you have to make a bunch of PDFs of drawings or a packet of PDFs of drawings, or you have to make a DXF flat pattern out of your sheet metal parts, or a STEP file, or some kind of mold file or something like that, all of those-- if your bill of materials is complicated and you have a lot of parts and many of them have changed or maybe only a few of them changed so you didn't notice that way down in the tree something changed, we can have all those things done automatically as part of your release process using a job on the job processor.

And then also, notifications of things, so when certain things happen. If you want to have the system say, hey, I'm about to release this or I just released this and it's going to send out an email to notify people, or throw something up in a team's channel, or Slack, or what have you, all those things are easily accomplished using these PowerShell automation jobs.

So give you a little example. So in this case, we're going to do a similar operation to before but we're going to do it with under control of the workflow instead of having a button press do it. So here in this case, we have a design and we're going to try to go from work-in-progress and release it. And you probably saw the little red thing there. It's not going to let us because for some reason on the other side, that part is listed as blocked, whatever that means.

So if we go over the other side and in this case, Business Central, and we take that part and we say, huh, I don't know why but I'm going to unblock it, which presumably means you're allowed to use it in your design now. So maybe we can buy that or we couldn't buy it before.

So we go back to Vault and let's just try to do it again. And when we go to change state this time, it's going to check that thing and it's going to say, oh, yeah, you're OK. It was unblocked this time. And so sure enough, the release goes through and the BOM transfer was all automated in the background as well. So that's just an example of extending these guardrails to operate based on information that's in your Vault and on the other side of the gateway.

So how does this work? We'll do a little diversion into the plumbing. I'm not going to spend too much time on this because it's sort of low level. But essentially, a powerGate is a gateway. It's a piece of middleware that runs on the server, either on or adjacent to your ADMS server. It uses the Vault and CAD client API extensions to connect natively.

And then inside this gateway is a little plug-in that essentially translates what we call CRUD operations, Create, Read, Update, and Delete operations, on the common objects that we work with here, and then that talks to your other system. And then that-- and it does it for parts, BOMs, and documentation, so those things like PDFs and the like. This is all extensible, but this is sort of the common way this works. And this is all based on a modern web services architecture called OData. Makes it pretty easy to keep things up to date for us.

We've connected to everything. The most common are the sort of biggest names in the industry, SAPs, et cetera. But we're not even really limited, like I said earlier, to ERP systems. You can connect to document management systems like FileNet or Documentum. Things are a little bit different in that case because you're not usually asking for parts but you often are translating documents. We've even done integrations to things like manufacturing execution systems like Prodsmart, the new Autodesk product. So it's not limited to ERP, even though that's sort of the mainstay of this.

So with all that in mind, let me just take a quick diversion and I'll show you how this works in a related environment, which is when we connect to Autodesk PLM product, Fusion 360 Manage. The concepts are very similar here, though it's a little bit different in that the workflow can be a little bit more complex because the PLM system, if any of you are familiar with Fusion 360 Manage, is its own sort of long-spanning workflow manager that implements long-running processes across really a broader spectrum of persona in your engineering processes.

So you'll have people who are not just focused on CAD work. You'll have procurement people, and quality people, and people who are keeping an eye on shop floor scheduling and things like that. And so the sort of span of those workflows in some sense is broader.

And your sort of CAD PDM work, almost the way this winds up working is it's almost like you've got little workflows in PDM around changing parts or changing it, making a change to the design inside bigger processes that are running in your PLM system. And the key to the integration in this case is to keep this-- again, keep synchronization between objects that are correlated, so you've got your parts and you've got your items in there in PLM, and handling the handoff of the workflows, so it's your turn to do something now, and translation and transmission of the data that's shared between the two systems, so send me a PDF of that so I can see it.

So in a lot of ways, it's similar. So you've got item and BOM publishing workflows. It can work with PLMs built-in, change management workflows. And it integrates them nicely into your Vault life cycles. So the one work-- the one workflow in PLM works cleanly with the vaulted life cycle of the thing that it's asking the Vault engineer to change. Things can be manual and automated just like-- manual workflow-driven just like the ERP integration. Again, guardrails apply, so we can ensure the sort of data integrity.

We publish a whole set of extra workflows that are sort of prepackaged that you can come and get from a GitHub repository and just wire in. And the whole thing's customizable, so using a combination of PowerShell and our other tools so that you can-- as you have customized PLM workflows, you can connect up cleanly to the Vault workflows that sort of support them.

So let's give you a little example. So in this case, we're going to make a little change to a part in our Vault. And this is something that's being worked on as part of a process that's running up in PLM. So we just want to show that if we go in here, we grab this part, we made a little change to it.

Now in the background, if you see the little toast notification that comes up there, it's going to ask our automation engine job processor to keep-- to make a couple of things and send them up to Fusion 360 Manage to keep it apprised of the change that was made. So now we go up and we look at that same object up in the-- up in PLM 360 and-- I'm using the old name.

And then now the user up there says, well, yeah, that's great, but I really would like you to change something here. So in a typical PLM fashion, that person goes in, puts a mark up on the thing and says, I'm going to make-- I'm going to request a change order from the engineer, because this person is probably not a CAD-wielding engineer. So up in here, they make a they make a change and they create a new change order in Fusion 360 and then go ahead and initiate it. So please, Mr. Vault Guy, can you fix this part for me, right? And so it's associated-- we associate it with that part.

And then now if we go back in Vault, we'll notice that in the change order list-- well, as soon as we refresh-- that that creation of a Fusion 360 Manage change order initiated the creation of a Vault change order. And the change order came with the associated reference to that part.

So if we look in the records here, it says, oh, look, so it's the mid-compression shaft and here's a reference to the vaulted part. So now we're looking at the part in Vault. And we brought back the mark-up so that the engineer who's being asked to change it can see what that person was asking for. So in this case, we just grabbed the picture of the mark-up, but that's fine.

And then now it's up to me as the vaulted CAD engineer to go ahead and dispatch this change order. And in the same way that we saw before, when I'm done with that, it'll publish my result up. And the person up there who asked for it will say, oh, my change order's done. And so all that stuff is coordinated.

So also while this is happening, we can throw in my famous guardrails. So let's say I'm working in here in Vault and I'm going to go ahead and try to release this part. Well, I'm working on this part, but it's also part of a design process that's going on. And the folks who are working on some other aspect of this, like namely preparing that part for manufacture or whatever, say, no, you know what, I'm not ready yet.

Now, I don't know that because that information is not in my Vault. But we can throw a check in there that says, well, let's ask, PLM if it's change order is ready for that piece to be released. In this case, it's not, so it just stops me from doing that.

So all of this is just to show that when you're working in an environment-- let's say you've got Vault and you've got Fusion 360 Manage. You have a system to maintain all of your data. You've got control over changes to the data, life cycles, properties about that thing. And because the environment's extensible, we're able to do automatic synchronization and communication of the information from that system, even into other non-Autodesk systems that don't speak CAD and don't understand Inventor's bill of materials. And we can do all that for you behind the scenes in an automated way so that you don't make mistakes and you don't have to do long, tedious, manual lists of tasks on Friday afternoon after you're done with your design work.

So, if you're interested in this and you think this is something that could help you out, feel free to reach out to us. The easiest way is just to come to our website, coolorange.com. And if you want to see other classes that my colleagues and I are doing here, we have some really interesting sessions this year on other kinds of integration and extensions. And feel free to check out our link to those classes on our site at Autodesk University 2023. And with that, I'll thank you very much for your attention. And hope we'll hear from a bunch of you.