Product Configurator – Devlicious.net

Product Configuration: Performance with Z3

Introduction

In the spring release of 2018 for Microsoft Dynamics 365 for Finance & Operations a significant investment in improving performance of the constraint evaluation has been made.

The result of this investment is the introduction of the Z3 sovler strategy. Z3 is a theorem prover from Microsoft Research, that has won several awards and has an active open source community.

The Microsoft Dynamics 365 for Finance & Operations team, teamed up with the Microsoft researches to develop new algorithms targeted at the Product configuration scenarios for Microsoft Dynamics 365 for Finance & Operations.

Microsoft Dynamics AX 2012 R3

The Z3 solver strategy is also available for Microsoft Dynamics AX 2012 R3 with the following KB article numbers:

4341629 - Additional performance improvement of loading models

4046549 - Performance improvement of loading models

4034024 - Fix to support customization related to system defined table constraints

4012892 - Introduction of the Z3 Solver strategy

Usage

The applied solver strategy for a product configuration model is selected by accessing the Model properties form.

From the Model properties form the Z3 solver strategy can be selected as illustrated below:

The Z3 solver strategy will currently not have a functional impact, the impact will be on performance.

Product Configuration: Multi-column dialog layout

In the spring release of 2018 for Microsoft Dynamics 365 for Finance & Operations, Multi-column layout is now available for the Product configurator’s runtime dialog.

To enable this functionality, select a model and open the Model properties form.

In the Model properties form, there is now a new field Maximum number of columns. This field allows you to specify how many columns should be used display the attribute groups of each component of the selected product configuration model.

Now, when the model is loaded in the configuration dialog in Test or via any of the order forms (Sales, Purchase etc.) it will look like this:

With this feature more of the user interface real estate is being put to use, to providing a better overview of the attributes of the selected component.

I hope you find this useful

Microsoft Dynamics AX 2012 Product Configuration : Enterprise Portal

In this blog post I will explain how on user interactions are handled by the product configuration module for Microsoft Dynamics AX 2012 on the Enterprise portal.

The figure above, is a high level illustration of how user interactions in general are processed on the Enterprise Portal (EP) for Microsoft Dynamics AX 2012. The clients access the AOS through EP, which is a web implementation built on top of Microsoft Sharepoint, hosted on a web server (IIS). The communication between EP and the AOS is synchronous using the .NET Business Connector RPC call. Each RPC call must be completed and returned, before http request timeout is exceed on the IIS.

To understand what implications the above has, when using the Product configuration module, we will go through the sequence of events, which take place when the user loads a configuration model and assigns a value to an attribute.

The above illustrates the sequence of loading a configuration model and assigning an attribute a value on the Enterprise portal.

Loading a configuration model

When the user wants to configure a product, e.g. from a sales order, the requests will be handled by EP. The EPPCConfigurator web control will be loaded, inside the web control a proxy Instance of the PCEnterprisePortalMain class is created. This proxy is used to interact with the AOS Product configuration logic.

On the AOS, the XML representation for the specific configuration model is retrieved from the database. Then the XML string is passed as argument to Product Configuration Server API, which unlike the Client API is design to support synchronous execution. In the creation of the ProductConfigurationServer instance, the XML is parsed and supporting data structures are created, just like on the Windows client implementation.

Once the data structures have been created, the configurator instance can start processing the constraints and calculations of the configuration model. Unlike the Windows client however, the processing on EP needs to respect a fixed time limit, in order not to cause a timeout on the web server.

Another difference between the Windows client an EP is the way the model is being processed. The EP implementation will attempt populate all visible enumeration and Boolean attributes. This is the equivalent of opening all the visible attribute controls on the active component in the form, and letting the configurator deduce feasibility of the values of each attribute.

The more attributes that are visible, the less time that is available to process each attribute. For components with over 20 enumeration and boolean attributes, it can happen that there is not enough time to process the feasibility of all values within the domain of the attribute.

Assigning values to attributes

When the user makes an assignment to an attribute, the web form is then posted back to EP and a request to assign the attribute is made on to the AOS. On the AOS, each call from EP executes in its own context, this implies that a new instance of the configurator is created. This instance must again parse the XML representation of the configuration model, before being able to process the user assignment. After this, the instance is disposed and a new one is created to process the assignment , same as before.

The main problem can be seen from the diagram in Figure 2, is the activation line of the ProductConfigurationServer object. Unlike the Windows client implementation , the configurator instance is not kept alive throughout the configuration session. The synchronous execution combined with the time limitation is the main limiting factor, which forces us to create and dispose instances of the configurator for each request.

The consequence of this is that the EP implementation of the configuration module, is not able to deliver a user experience which is similar to that of the Windows client for models of medium to high complexity.

Please keep this in mind when considering implementations of the Product Configuration module on Enterprise Portal for Microsoft Dynamics AX 2012.

Product Configuration Performance : Solver strategy

This post is part of the series of posts explaining performance improvements introduced in
Constraint-Based Product Configuration in Microsoft Dynamics AX 2012 R3 CU8.

The Solver strategy concept was first introduced in Cumulative update 7 for Dynamics AX 2012 R2 and has been extended in Cumulative
update 8 for Dynamics AX 2012 R3. It now includes the following strategies:

Default
Minimal domains first
Top-down

What is a solver strategy?

Imagine you were given the task of solving a 100 piece jigsaw puzzle. How would you start?

A common solving strategy is to start with the edges and move towards the middle, most of us
will either have done this ourselves or if not it should be pretty simple to
convince yourself that this strategy is sound.

Now, what if the puzzle you have to solve does not have straight line edges (often referred to
as impossible puzzles)? Suddenly our edge-first strategy will be dramatically less efficient as the edges are much more difficult to identify.

For the Solver, a configuration model is a bit like a jigsaw puzzle which needs to be solved.
With the Solver strategy concept, we have enabled you to set the strategy which
the solver will use when it solves the model. Configuration models can however
be very different in nature and the strategy for solving one model efficiently
may prove to be inefficient to solve a different model.

What is the impact?

The impact of response times has been shown on real customer models, to go from minutes to
milliseconds. For this reason it is really worth your time to spend a few
seconds to change this one setting, to see if a change in Solver strategy could
have this impact on your configuration model.

You can change the Solver strategy setting in the model properties form.

Which strategy to choose

Currently there is no build in logic which automatically detects which solver strategy will be most efficient, so for now, you will have to try them out.

Default

What can be said about the different solver strategies is that the default Solver strategy has been optimized so solve models which rely on table constraints. On all the customer models we have seen which use table constraints to a large extend this
solver strategy has proved to be the most efficient.

Minimal domain first and Top-down

These two strategies are closely related. The Top-down strategy, which has been introduced with CU 8 has shown to outperform Minimal domain first in all of our studies, but for
backwards compatibility we have decided to keep the minimal domain first strategy
in the product. Both of these strategies have shown to be more efficient for
solving models which contain several arithmetic expressions and where table constraints are not used. However, there are still examples where the default solver strategy will out perform these, so remember to try each.

Product Configuration: Setting values based on system variables – example, current user ID

In this blog post we will describe how you can set values
based on the current user ID by leveraging system-defined table constraints
together with the build-in query range methods.

If you are familiar with the Product Builder configurator,
you may by familiar with the User Profile
feature where you can associate a collection of default values with a given
user. Use the following description to achieve a similar behavior using the
Product Configurator.

Creating the System Table

The table we create for this example should look like this and have two columns, that is, one for
the User ID (uses the UserID EDT) and one for our user-specific value (an Integer to keep it simple).

Once the table is created, we can add the user specific data.

As seen above, we have added the value 42 for the Admin
user ID. The intention is that when the table constraint is created and used in
model, the attribute, which will be bound to the UserSpecificIntegerValue
column, will be assigned the value that corresponds to the current user ID.

Creating the Table Constraint

Now that the System Table is created, we can create the actual table constraint. This is done by
opening the Table constraint definition
form, under Product information management -> Common -> Product configuration models.

Create a new table constraint by clicking the new button.

Select System defined, and enter the name of the table created previously.

Add a column for the user-specific integer value and choose an integer attribute type with ranges.

Now comes the part which gives the attribute a user-specific value. This can be accomplished by
opening the Select query (SysQuery) form and entering the range specified
below. The content of the table will be filtered to just return the records
associated with the current user ID.

Click OK to complete the table constraint creation, click Next in the Wizard, and then click OK again.

Using the system-defined table constraint in a Product configuration model

Having just created our system-defined table constraint, we are now ready to use it in a Product
configuration model. Below I have create a very simple model with 3 attributes:

One integer attribute to hold
the user-specific value
Two boolean attributes for
     each of which I will be using the Hidden modifier with a condition
     expressing that the attribute is only to be shown if the user-specific
     value matches that of the current user.
     The “Only Admin” attribute will be hidden if the user
     specific value is different from 42.

Similarly, I have added an attribute named “Only Dmitry”, which only will be
visible if the user log on to Dynamics AX is associated with User ID Dmitry.

Once the attributes have been defined, it’s time to attach the table constraint to the
model. This is done by creating a new constraint in the constraints section and
selecting Table constraint in the opened dialog.

Then select the new table constraint and associate the user-specific value attribute with
the user-specific value column, as shown below.

Launching the model and understanding the results

We are now ready to launch the model we created with the attached table constraint. As can be seen
below, once the model is loaded, the User Specific Value is assigned the value 42 by the configurator. The “Only
Admin” attribute is shown and the”Only Dmitry” attribute is hidden.

This example can be extended to include several other concepts like hiding subcomponents and
grouping user specific value into table constraints. An obvious use case would
be that you hide some parts of the Product configuration model from the order
takers (Susan persona). This could be engineering-specific details and the
product designer (Emil persona) would still be able to see them.

Furthermore, the above pattern can be used together with other of the build-in query range
methods.

currentCompany
currentLanguageId
currentUserLanguage
currentLegalEntity
currentParty

Note:

It you are running
on a build that has a performance fix to run the XML generation in IL, you will
need to generate IL for the SysQueryRangeUtil class.

I hope you find this useful

PrivateProject_MyUserSpecificValuesDemo.xpo

Understanding the default configuration concept for constraint-based products

Introduction

The default configuration concept enables users to start the product configuration process when the main product master data are available within a legal entity. You can learn more of the details of this concept in this post.

The default configuration concept

You must use the configuration technology Constraint-based when you configure product masters and the product masters must be configured with only one active product dimension, the Configuration dimension. We refer to the products masters as constraint-based products throughout this post.

To create a constraint-based product you must specify a valid product dimensions group which complies with this requirement.

Figure 1 Error message when the wrong dimension group is selected

You use the Configuration dimension to capture the final product configuration of a certain product model. The product model is represented in the system as a new product variant with a specific configuration dimension value. This is how Dynamics AX distinguishes between different results of the final product configuration. This allows you to complete a lot of tasks, such as:

Record and view on-hand inventory for individual configurations.
Run master planning against specific customer requirements (and across different legal entities).
Reuse existing product definitions in order to create products that are identical to existing products. You can also apply existing product definitions across legal entities.

Once you have released a constraint-based product to a legal entity, you can kick off a product configuration process from the following source document lines:

Sales order line
Sales quotation line
Project order line
Production order line
Purchase order line

The product dimension Configuration must have a value before you can start the product configuration process for a selected constraint-based product on an order line. Also, all active product dimensions must be specified before you can save an order line. These requirements are based on a series of technical solutions which are consistent with the experience that many users have from the Product Builder functionality.

Note – This is always the case for stocked products .For non-stocked products, you can specify a product category instead of defining the particular SKU.

The default product configuration concept is dedicated to solve the above described issue. It enables end users to proceed with the product configuration as soon as the product has been released to the legal entity.

Figure 2 The Default configuration is just there, after the product release

When a constraint-based product is released to a legal entity, the system automatically creates and releases a default product variant with the configuration value Default. The Default parameter is derived from the Default configuration ID field on the Constraint-Based product configuration models tab in the Product information management parameters form. This form is located under Product information management > Setup. The Default configuration ID value is set automatically during system installation. It references the SYS Label @SYS331038, but you can always change the value.

Figure 3 Product Parameters form

The process to create and release the default product variant is completely transparent and once the Default configuration ID parameter is set, no further action is required. If the product is released to multiple legal entities, the same default product variant will automatically be released to all of those legal entities.

Once the default product variant is released to the legal entity, the system will also update the default product variant fields on the released product. The default configuration dimension value is provided when you enter the item number on the order line. Any end user can change this setup in order to, for example, always have a basic configuration of a specific product suggested on all order lines

Figure 4 The default product variant dimensions are set to match the Default Configuration ID

Summary

The default configuration concept makes it possible to start the product configuration process at the point where the main product master data are available within a given legal entity. In order words, it facilitates the first step in the overall process of configuring an order line and it goes without saying that the first step is a prerequisite to move on in the process. Thanks for reading.

Product configurator, new Calculations concept

In cumulative update 6 for Dynamics AX 2012 R2 we are introducing a new concept
called Calculations in the Constraint-based product configuration models.
Calculations have many similarities with constraints in the way they are
created and maintained, but constraints are focused on limiting the number of
possible combinations and Calculations to enable mathematical expressions. One other
important difference between Constraints and Calculations is that Calculations
can work with decimal numbers. So for instance if the cable length for a home
theater system is decided by the room size it could be expressed as in the
screenshot example below.

If[ RoomSize / 1.33 > 7.5, 3.33, 6.66]

The image below shows how Calculations are defined for a product configuration model.

A Calculation, much like other product configuration model concepts, has a name
and a description to allow you to state the purpose of the Calculation.

Calculation expressions are uni-directional and the Target attribute receives the value
from the expression. The attributes can not be of type free text.

(It is possible to use a Text with a fixed list, also known as an Enumeration, but for a Target attribute of this type the return vale has to be the Integer order of the text value in the text list)

An attribute can both be used as a target attribute and
in expressions for other target attributes. The order of the calculations will
be determined accordingly.

The Calculation expression holds the logical or mathematical expression that
represents the Calculation. The expression syntax is similar to the syntax
available for expression constraints, but a wider range of operators are
available, such as the If operator shown in the example above. Also, both
decimal numbers and unbound integers can be used both as Target attributes and
in the Calculation expression. You can type the calculation expression yourself,
or build it using the new expression editor (Screenshot below). This is also a
new capability in CU6, and I will give a more detailed introduction in my next
post.

This enhancement makes it possible to manipulate decimal numbers at run-time during
configuration; you no longer need to express this type of operation through the
dedicated application programming interface represented by the PCAdaptor class.

In the screenshot above, the Target attribute is of type decimal number and it can be
used as a property on a bill of material (BOM) line or a route operation, but
it cannot be included in a constraint or a condition. If you want to control
the inclusion of a certain BOM line or route operation, this can be achieved by
using a Target attribute of type Boolean and then using the Target attribute in
the condition on the BOM line or route operation. Please see example below:

Target attribute: widthLengthRatioBoolean

Calculation: widthAttribute > lengthAttribute

BOM line condition: widthLengthRatioBoolean

Route operation condition: !widthLengthRatioBoolean

In this example the widthLengthRatioBoolean attribute takes the value true if the
widthAttribute is greater than the lengthAttribute and false if it is equal to
or smaller than lengthAttribute. The BOM line condition will include the BOM
line only if the calculation returns true, whereas the route operation will
only be included if the calculation returns false.

The introduction of the Calculation concept means that an attribute can get its
value set by four different sources:

User, value entered by the user during the configuration
Default, value set in the product model
Calculation, value resulting from a calculation expression
Constraint, value set by a constraint

In the matrix below the rows state, which input sources have the ability to overwrite
an existing attribute value. Overwriting a value set by a constraint would result
in a model, which is in contradiction, and thus the configuration cannot be
finished and saved. This is indicated by the * in the Constraint column cells.

So one example here is that a calculation can overwrite a value set by a constraint,
but then the configuration cannot be saved.

Input order matrix
		Can be overwritten?
		User	Default	Calculation	Constraint
Can overwrite?	User		Yes	Yes	Yes *
	Default	No		Yes	Yes *
	Calculation	No	No		Yes *
	Constraint	No	No	No

Product Configuration – Physical data model for user selected values

A constraint-based configurator was shipped with Microsoft
Dynamics AX 2012. In this post, we will provide an overview of the data model
that is used to persist the values that you can select when you configure a
product using the constraint-based configurator.

At first glance, you will notice that there are several
tables involved. If you are not familiar with previous versions of Dynamics AX
and the Product Builder configurator, this might not surprise you. However, if
you are familiar with the Product Builder, you will know that the old
configurator persisted all user selections in one table, namely the
PBATableInstance Table. This implies that retrieving the user selected values
is not as simple as writing a select statement against a single table. In the
following, I will use a report as an example and show you how you can retrieve user
selections in tables.Building a report

The report** that we use as an example displays all the user
selected values that are related to the configurations for a given product configuration
model.

**Disclaimer:
The report is not performance optimized. The purpose of the report is solely to
illustrate traversal of the data structure.

In the report, each element is indented to show the
parent-child relationship between, for example, the HomeTheaterSystem root
component and the “Color” attribute. The “Color” attribute can be assigned
other values, such as “Red”, but in the data on which the report was executed
no such configuration existed.

Note: I have used the Contoso dataset.

Data requirements

The data required to build the report can be broken down
into three parts:

Get the instances of the root component from a
given product configuration model. Here we only want the instances that are
created for product variants and not the ones that are created for configuration
templates.
Get the attributes and their user selected
values for a component instance.
Traverse the subcomponent instances recursively
and repeat part 2.

Let’s take a look at how to retrieve the data requirements to
build the report. The following statements will meet the data requirements and you
can also see the table involved:

Get the instances of the root component from a product configuration model

protected void
provideDataForModel(PCProductConfigurationModel _productConfigurationModel)

{

PCVariantConfiguration variantConfiguration;

PCComponentInstance componentInstance;

PCComponentInstanceRootComponent rootComponentInstance;

PCClass rootComponent;

…

// get all
configurations made for the given product configuration model

while select componentInstance

// only get instances which belong to a variant configuration, not a configuration template

join TableId from variantConfiguration

where variantConfiguration.RecId == componentInstance.ProductConfiguration

// find the
root component instances of the selected model

join TableId from rootComponentInstance

where rootComponentInstance.ComponentInstance == componentInstance.RecId

join rootComponent

where rootComponent.RecId == rootComponentInstance.RootComponentClass

&& rootComponent.RecId == _productConfigurationModel.RootComponentClass

{

// handle data for component

…

}

Get the attributes and their user selected values for a component instance

PCComponentInstanceValue componentInstanceValue;

EcoResAttribute attribute;

EcoResAttributeValue attributeValue;

EcoResValue value;

// get all attribute value assignments
related to the component instance

while select value

join TableId from attributeValue

where value.RecId == attributeValue.Value

join TableId from componentInstanceValue

where componentInstanceValue.RecId == attributeValue.InstanceValue

&& componentInstanceValue.ComponentInstance == _componentInstance.RecId

join attribute

where attribute.RecId == attributeValue.Attribute

{

// handle data for attribute and attribute value

…

}

The values as such are sub-typed to model their respective data type.

Traverse the subcomponent instances

PCComponentInstance componentInstance;

PCComponentInstanceSubComponent subComponentInstance;

PCSubComponent subcomponent;

PCClass childComponent;

// get all the subcomponents that have been associated with values

while select component

join TableId from subcomponent

where subcomponent.ParentComponentClass == _parentComponent.RecId

&& subcomponent.ChildComponentClass == childComponent.RecId

join TableId from subComponentInstance

where subComponentInstance.SubComponent == subcomponent.RecId

&& subcomponentInstance.ParentComponentInstance == _componentInstance.RecId

join componentInstance

where componentInstance.RecId == subComponentInstance.ChildComponentInstance

{

// handle data for component

…

}

Implementation of the report

The data in the report is hierarchical in nature because of
the relationship between components and subcomponents.

The report that we build includes the parent-child
relationship between a component and a subcomponent and it also includes the parent-child
relationships between, for example, an
attribute and an attribute value. This data cannot be retrieved from Dynamics
AX using a single query[1]
so we will use a data provider to populate a temporary table. The table has the
following structure:

[1]
This is not completely true because in Dynamics AX 2012, each component is
brought about as a reference to the configured variant. Thus, you could
retrieve all the data and then resolve the parent/child relations once the data
is retrieved.

A quick explanation of why the fields are required:

ID : this is used because the report framework
will not expose the RecId field of the temporary table
Name : this is the name, such as Color, that we choose to display for the
element
Parent : this is a reference to the parent
record ID that helps grouping the SSRS report hierarchically
UniquePath : this is used to distinguish the
attributes that belong to subcomponents of the same type. The path will be
unique since it describes the path from the root component to each element in
the model.

For more information about how to build a simple
hierarchical report in SSRS, go to:

http://technet.microsoft.com/en-us/library/dd255243(v=sql.105).aspx

For details on the implementation, take a look at the
attached X++ project.

Enjoy

PrivateProject_PCSessionValues.xpo

Kitting in Microsoft Dynamics AX 2012 using product configuration and sales event kanbans

Many Microsoft Dynamics AX users have asked for a solution that supports kitting. To support a kitting solution, two primary components are needed:

Configuration of a kit for the order management
An activity that assembles the kit

Many ERP and SCM solutions support kitting as part of the Warehouse management or logistics functionality. Without having native support for kitting, Microsoft Dynamics AX 2012 offers an approach where it might not have been expected: Using to product configurator to configure kits based on a product configuration model combined with a lean process activity where the kits are built or packaged to order.

So in fact, the kits are built based on sales event kanban’s, with a single kanban per kit.

It all starts with modeling the kit as a configurable product, and then creating a configuration model that represents the products that can be combined in kits, possibly also including the packaging material. In our example we have a configurable speaker set that consists of two front and two rear speakers per kit. This is represented by a simple product configuration model.

The model structure is rather flat, and consists of the front and the rear car speaker set. The products that can be selected in each configuration step are modeled as conditional BOM lines. In our example the configuration model makes sure that while different models of speakers can be selected for the front and rear speaker pairs, all speakers – front and rear – will have the same cover color. Because the assembly of the kit is done by a lean production flow, route operations are not
needed in the configuration of the product model.

Therefore a global attribute of Color is associated to the Car speaker set. This constrains the selection of components to the common color.

Based on the model shown above, a sales order taker can configure the kits based on the customer’s demands, or use pre-configured kits by selecting a specific configuration of the kit.

The individual configuration is done in the sales order line as shown below, by clicking Product and supply > Product model > Configure line.

The Configure line form allows the configuration of the kit to be based on the product model.

Before finishing the configuration, the sales price of the kit can be calculated based on the configuration of the new kit:

After the configuration is done, a new variant of the kit is created with a corresponding BOM version, and the sales line is updated with the new configuration and sales price.

Note that the BOM version is automatically approved and activated.

Once the configuration is final, the order taker can create the kanban that is to assemble the kit on the packaging work cell directly in the order form:

This creates one or more kanbans, depending on the number of packages that are needed, and load them on the kanban board of the packaging work cell.

In our example, Set05 with the new configuration has been added and is now ready to be picked and completed.

On the same work cell, other preconfigured kits (in our example CSS_SS1B) and other products can also be packaged and delivered to order or to stock.

The kanban rule

The magical configuration that enables this process is the kanban rule. A kanban rule uses the activities that are configured for a production flow. Evaluating the possibilities of configuration of the production flow would go too far for this blog entry. To learn more about that, refer to the Whitepaper “Lean manufacturing for Microsoft Dynamics AX 2012 – Production flow and activities.” Assume that for the kitting application, a single activity production flow, as described in the whitepaper, could apply.

In the actual case, the kanban rule is a manufacturing kanban rule with a replenishment strategy event.

The packaging activity is followed by a transfer to a vendor managed warehouse.

Some highlights of the kanban rule configuration should be emphasized in the context of our scenario. Let’s start with the Product selection field in the Details FastTab of the kanban rule.

Notice that product CSS_SS_CUST is a configurable item for which the configuration dimension is mandatory. A configuration is not assigned to the kanban rule, so it is valid for all configurations of this product. In other words, any kit that is configured based on this model by using the product configurator will be supplied using this kanban rule.

The Events FastTab specifies the events that will trigger the creation of a kanban. In this case, Manual is selected in the Sales event field. The event cannot be created automatically when using the product configurator because the configuration of the line must be completed before the event kanbans are created. The dependency to the source requirement – in our case the sales line – ensures that the sales line cannot be shipped before all kits have been assembled and received. However, in the current example, a reservation is not needed. Because every sales line will have a separate configuration it’s unlikely that the wrong kit will be reserved so the lean approach would be to not make a reservation.

The maximum quantity of a kit per kanban is 1. Every kit creates a separate kanban and receives a separate kanban card. The automatic planning quantity of 1 ensures that every
kanban is directly loaded to the schedule, so the picking and packaging can start immediately after the kanban is created from the sales order line.

Depending on the settings of the kanban rule, the kanban card can be printed automatically in two ways:

When the kanban is created,
When the first activity is planned for the kanban and printed on the printer that is associated to the work cell responsible for the picking activity.

The picking list can be automatically added to the kanban card as well. Instead of having to look at the kanban board first, the worker can take the kanban card directly from the printer and start the picking process. When the kit is assembled, the worker can complete the packaging activity by scanning the card ID.

Costing the Kit

In many cases, the cost of a kit is mainly driven by its components. The cost of the packaging activity can be calculated based on the activity time. To enable the full cost support for the kitting solution, the cost price needs to be calculated and activated for each configuration. However, the value of costing the kitting might be really low, especially if this process usually creates no or only low variance. On top of that, the configured kits usually don’t stay in the warehouse for very long because they are assembled to order shortly before the shipment. For this reason, it might be a good idea to configure the kit so that it has only one standard cost activated for all of its configurations. This is done by clearing the Use cost
price by variant check box in the product master.

This configuration will result in material variances because different materials are used in the kits. To avoid manual corrections, the account that is used for material variance could be redirected to the cost of goods sold. Some people might disagree with this, but from the lean perspective, if costing of the kits and the related variances are not an issue then a manual or even an automatic cost calculation and activation should be avoided.

Both Product configuration and Lean manufacturing in Microsoft Dynamics AX 2012 are powerful tools that support manufacturing and the logistics processes required in many industries. When combined, they can support many use
cases in a very flexible way. I hope this example provides insight into the capabilities and opportunities and how they can be used to empower your business.

The approach that is described in this blog might leave open a couple of requirements that a kitting process in your company might require. If that’s the case, we’d very much like to hear more about your scenarios. But without a doubt we would also like to hear from you if this matches your requirements.