Change management in Upchain - Core concepts

00:05

In this video, we'll introduce you to the key concepts you'll need to understand the change management process in Upchain.

00:11

We'll also discuss an example of the general lifecycle of an item. So let's take a look.

00:20

As your products progresses through its lifecycle, it will undergo numerous enhancements and revisions.

00:27

In order to keep track of what's being changed, why it's being changed，and by whom,

00:33

it is vital to ensure that all issues and decision points are well documented.

00:39

Sorting through all of the data and working through the approval process can be a complex and time consuming task if not properly managed.

00:52

Change management with Upchain enables you to tell the full story of your product development.

00:58

By automating many steps in the change process, informing the correct person when it is their turn to be involved,

01:06

and keeping all of your change request data centralized, Upchain streamlines product change,

01:12

while making it easy to review the change process itself.

01:16

So let's take a closer look at the key details of how this works in Upchain.

01:21

But first, let's review what an item is.

01:26

An item represents a level in the Bill of Materials, or BOM, whether it be mechanical or electrical.

01:33

It can be a top-level end item, an electrical package, assembly, sub-assembly, or part.

01:39

And it contains many documents and attributes that provide more information about the item and what it represents.

01:46

Importantly, an item may exist with or without CAD files associated with it.

01:54

What does it mean to be released?

01:57

An item always begins its life in a Development state.

02:01

This means that it can be edited by those who have the license to do so.

02:05

It can have CAD, drawings, and other documentation associated with it, that can be modified at any time.

02:13

Its attributes can also be changed.

02:16

When the item is considered finished, it is moved to a status of Released.

02:21

The item itself becomes read-only meaning that it is locked for editing.

02:26

Its attributes cannot be changed and the documents inside the item can only be downloaded and viewed.

02:33

A released item is the only status of an item that can be viewed by users who have a viewer license.

02:39

If changes are needed to be made to the item, then it must be revised to move it to a development state.

02:46

Necessary changes can then be made to the item and then it can be released a second time.

02:51

We'll come back to this process in more detail in a moment.

03:01

What is item maturity?

03:03

Item maturity is an additional status on a released item that allows you to specify what type of release has just been performed.

03:12

For example, the first release of an item may be for prototyping,

03:16

and so you could easily specify that the released item is at the Prototype maturity level.

03:22

The second release of an item, perhaps after further revisions are made, or perhaps no changes were necessary,

03:28

might indicate that the item is ready for Production.

03:30

And again, the item's maturity status could be updated to production.

03:36

Item maturity helps other stakeholders who may only be interested in items at a specific maturity level,

03:42

to distinguish between the items that are relevant to them and those that are not at the required maturity level.

03:49

For more information, please reach out to Upchain support to have this functionality enabled in your organization.

04:02

In addition to an item having a status of released and a possible maturity level,

04:07

items also have a major and minor revision to indicate what type of changes have been made to the item.

04:14

They fall into two categories.

04:17

The Major Revision indicates the design evolution of the item that is commonly known as a customer-facing revision.

04:23

In other words, a major revision is one that will affect the final product delivered to the customer.

04:29

How you choose to define the major revision depends on your organization, but some common examples include changes to fit form or function,

04:38

material changes, or safety changes.

04:43

The Minor Revision is an evolution of the item major revision that is commonly known as an internal or administrative revision.

04:50

In other words, a minor revision is one that does not affect the final product delivered to the customer

04:56

but may affect supporting information or documentation.

05:02

For a single item major revision, there can be multiple item minor revisions.

05:07

Again, how you choose to implement the minor revision depends on your organization.

05:13

But some common examples include missing dimensions on drawings,

05:17

certain attribute changes that won't affect the physical product or any documentation updates.

05:25

So, how is an item released in the first place? You use a Change Request.

05:31

A Change Request is a form in Upchain that describes a change to one or more items, and represents a formal request to release the items.

05:41

It is used to release items and set their item maturity level, if required.

05:46

The Change Request records the reason for the change, contains supporting documentation and identifies all items involved in the change.

05:55

Typically, a Change Request is used to release items, but can also be used to obsolete an item or update an item's maturity level.

06:05

A Change Request lifecycle, including any item checks, approval stages, and the resulting release of the items, are all governed by a workflow.

06:16

So what is a Workflow?

06:18

A Workflow is a set of statuses, transitions, tasks, and system processes that an object moves through.

06:26

Often, the progress of a workflow depends on actions taken by key team members within the system.

06:33

But the structure of the workflow is configured by your Upchain administrator

06:37

to align with your organization's internal business processes for change management.

06:43

Additional information is included in our help center.

06:49

Okay. We've covered a lot of information. So let's consider all of this in an example.

06:57

We have an item that was created from the mechanical CAD plugin.

07:01

This item doesn't have any drawings, but they're handled in the same way as the CAD model.

07:06

Here, you can see the Item Name and Number.

07:11

Consider the following. The item is in the Development state. We could see this by looking at its status and by the fact that the item version is 1.

07:22

The item does not yet have a maturity level. The major and minor revisions are at XX.

07:29

This is the default, which means it is going through its first development phase.

07:39

The CAD file inside this item always begins at Version 1,

07:44

and can be versioned as many times as necessary by checking out and then saving or checking the file back in.

07:50

This is all covered in our mechanical CAD courses.

07:54

In our example, let's suppose the file has been checked in four times, so the CAD file version is now at 5.

08:03

Now we're ready to release the item to our alpha maturity level.

08:07

This is done through a Change Request.

08:10

Once the Change Request is complete, the item becomes as follows. The item is now released.

08:18

We can see this by looking at its status and by the fact that the item version is 0.

08:24

This is always the case for a released item.

08:27

The item maturity is Alpha.

08:31

The Major Revision is AA.

08:33

This is always the first value it becomes when using the default double character representation.

08:41

The first release is always major.

08:43

The Minor Revision is 00. This is always the first value it becomes when using the default double digit representation.

08:52

The CAD file inside it is also versioned up,

08:55

to keep the released file version separate from the previous file versions associated with the development item.

09:02

They are kept for tracking purposes.

09:06

Now, suppose the item needs an update to its model.

09:09

Perhaps a part needs a chamfer so that it does not interfere with another part.

09:14

In order to make modifications to the attributes or documents inside the item, it must be returned to a development state.

09:21

This should be done in the mechanical CAD plugin if the item has CAD. We'll cover how to do this in another course.

09:34

The item is now as follows. The item is now in development.

09:38

We can see this by looking at its status and by the fact that the item version has been incremented to 1.

09:48

The item maturity has been removed as this only applies to released items.

09:55

The Major Revision is still AA and the Minor Revision is still 00.

09:60

This is because the major and minor revision levels are only updated at the time of release, to reflect what has just been done to it.

10:08

The CAD file inside it is also versioned up to keep the previous release file version separate from the current file version, which we can now edit.

10:18

In this example, it's incremented to 7.

10:22

Changes can now be made to the CAD file or whatever else might need updating in this item.

10:27

When these changes are complete, we must check in the file.

10:31

In this example, we've created versions 8 and 9, and we are now ready to release the item again.

10:39

In this example, it was a major change as the model changes would modify the physical component.

10:47

The item is also ready to move into our Beta maturity level.

10:52

The item becomes as follows. The item again is now released.

10:57

We can see this by looking at its status and by the fact that the item version is 0.

11:03

The item maturity is Beta.

11:07

The Major Revision is AB. This is because we specified that it was a major change that was made. The Minor Revision is 00.

11:16

This is because we did not make a minor change and we have not yet made any minor revisions to the item at Major Revision level AB.

11:27

The CAD file inside it is also versioned up

11:30

to keep the released file version separate from the previous file versions associated with the development item.

11:36

Here, it's at Version 10.

11:42

And so it continues.

11:44

In subsequent lessons and courses, we'll dive deeper into how to send an item to a change request and how to revise an item.

11:52

You may be a bit overwhelmed, but don't worry.

11:56

As you begin to work through the subsequent videos and courses, you'll become more comfortable with these terms and concepts.

12:03

Continue working through the change management courses to learn more.