Engineering Change Process: The Short Version
An engineering change process moves a product change from a reported problem through a change request (ECR) and an approved change notice or order (ECN/ECO) to a released, effective design. inteliScience, a Siemens NX and Teamcenter specialist delivering nearshore from Romania, standardizes change classes, impact analysis, workflows and effectivity first. Result: stage times you can measure.
| Document | Question it answers | Teamcenter standard object | Owner |
|---|---|---|---|
| Problem report (PR) | What is wrong, where, since when? | Problem Report | Whoever finds the problem |
| Engineering change request (ECR) | What should change, why, and what does it affect? | Change Request | Requester, with a change analyst |
| Engineering change notice (ECN) | What exactly was approved, and who does what by when? | Change Notice | Change analyst, then the implementers |
| Engineering change order (ECO) | In most companies the same job as the ECN: the authorized work package | Usually mapped to the Change Notice | Same as the ECN |
| Deviation | May we build differently for a limited time without changing the design? | Deviation Request | Quality, with engineering |
The Problem: Changes Wait Longer Than They Take
Ask a design engineer how long the NX work on a recent change took. Then compare that with the dates on the change notice. The gap between those two numbers is what this guide is about.
A change rarely stalls inside NX. It stalls between people: waiting for an impact statement from purchasing, for the next change board meeting, for an approver who is at a trade fair, for a checker who sends the drawing back because the material attribute is empty. Siemens puts the underlying problem plainly in a June 2026 post on BOM agents: “Engineering change is where BOM complexity becomes tangible.” Executing a change today, the post continues, means moving across tools and contexts, repeating analysis across structures and manually updating multiple occurrences (Siemens Teamcenter blog).
Much of that waiting is information work. In a work-sampling study, 78 design engineers logged their current task once an hour for 20 working days, and acquiring and providing information added up to 55.75% of their working time (Robinson, 2010). Impact analysis is that kind of work in its purest form: the same questions, sent by email to the same five departments, for every single change.
The spread between organizations is wide. Siemens’ own customer story on Teamcenter change management reports that one manufacturer cut engineering change order cycle times from 90 days to 14 days (Siemens Teamcenter blog, February 2025).
Read vendor stories as proof of what is possible, not as your benchmark. Software does not remove a queue on its own. A rule about who decides what, by when, does.
ECR, ECN and ECO: What Each Document Does
An ECR asks for a change, an ECN or ECO records and authorizes the approved change, and a problem report captures the issue that started it. None of these terms is standardized across industries, and many companies use ECN and ECO as synonyms. What matters is that every change has exactly one request object and one implementation object, each with a named owner.
The engineering change request carries the problem, the proposed solution, the reason and a first estimate of the impact. It is a proposal. Nothing on the product changes yet.
The engineering change notice is the record of an approved change: which items and documents get a new revision, which tasks follow, and when the change becomes effective. Where a company says engineering change order, it usually means the same object. Some organizations keep a nuance, with the order authorizing the work and the notice informing everyone affected that it happened, but two objects for one change double the administration without adding control.
Teamcenter’s change management follows the closed-loop CMII model, which Siemens names as the basis of its change management. In that model a problem report can lead to a change request, and an approved request leads to a change notice. In a standard Teamcenter change setup, the change object holds the affected data in separate folders: problem items, impacted items, solution items and reference items. Most installations rename or subclass the shipped change types in their BMIDE template, so check what yours are called before you write a procedure around them.
A deviation is not a change. It permits a limited departure, for a number of units or a period, without touching the released design. Keep it as its own object; otherwise temporary fixes quietly turn into permanent, undocumented ones.
Our recommendation: pick one name for the implementation object, write it into your change procedure and retire the other. A company where engineering says ECO, production says ECN and Teamcenter says Change Notice spends its change meetings on vocabulary.
The Engineering Change Process in Teamcenter, Step by Step
In Teamcenter a change runs as a chain of objects and workflows: problem report, change request with impact analysis, a board decision, a change notice listing the solution items, the design work in NX, a release workflow, and the effectivity that tells manufacturing from when the new revision applies. Each step has its own owner and its own waiting time.
- Report the problem. Anyone files a problem report with the affected item, a description and evidence. A low threshold matters more than completeness at this point.
- Raise the change request. A change analyst turns one or more problem reports into an ECR, attaches the impacted items and starts the impact analysis.
- Analyze the impact. Where-used, stock and open orders, tooling, suppliers, documentation, approvals. Each department answers its part.
- Decide. A change board (CCB or change review board) approves, rejects or returns the request and confirms its class and priority.
- Create the change notice. The ECN lists the solution items, meaning the new revisions of parts, assemblies and drawings, plus the implementation tasks.
- Do the design work in NX. The designer revises the parts, updates assemblies, drawings and PMI, checks the new revisions in to Teamcenter and relates them to the change notice.
- Release and make effective. The release workflow collects the approvals and sets the release status; effectivity tells production and ERP from which date or unit the new revision applies.
Step 6 is the only one that happens in NX, and it depends on the integration underneath. If check-in, revise and attribute mapping do not work cleanly, every change pays for it again. Our guide to setting up the Teamcenter NX integration covers what has to work before any change process can be fast. For the PLM side, from data model to workflow templates, see our Teamcenter consulting and implementation services.
Where Time Is Lost Between NX and Release
Most of the lead time sits in four queues: the impact analysis, the board meeting, the checker loop and the approver inboxes of the release workflow. The NX work itself is rarely the longest stage, and it is the one most improvement projects start with. The table shows where changes wait, why, and what to fix first.
| Stage | Where the change waits | Usual cause | First fix |
|---|---|---|---|
| Before the ECR | Email threads, meeting notes | No low-threshold way to report a problem | A problem report anyone can file in a few minutes |
| ECR to decision | Impact analysis | Answers collected one by one, by email | A fixed checklist with named owners, answered in parallel |
| Decision | Change board | A weekly board for every change | Routing by change class; minor changes skip the board |
| Design work in NX | Checker loop | Empty attributes, old title blocks, rule errors found at check | Attributes from the start part, rules checked in NX |
| Release workflow | Approver inboxes | Sequential sign-offs, no surrogates | Parallel reviews, surrogates, rule checks before start |
| After release | ERP, manufacturing, suppliers | Effectivity decided late, manual handover | Effectivity decided with the change request |
The board queue is the most expensive one to leave as it is. In practice a weekly board that sees every change does not work: minor changes wait up to a week for a two-minute decision, and major ones get two minutes because the agenda is full.
The checker loop is the one NX teams can fix on their own. A change notice comes back when the new revision has an empty material attribute, an outdated title block or a drawing that no longer matches the model. Those are not engineering errors. They are start-part and rule errors, and they disappear once the attributes exist from the first save because the NX templates carry them, and once the important rules are checked in NX while the designer works.
Our team has worked on exactly this in earlier positions: the analysis and automation of design and release processes in NX and Teamcenter at a large design organization, including attribute and naming standards for the integration, and a check suite that tests company rules at the designer’s workstation. That check suite existed for one reason. Rule violations found at release sent parts back through costly loops; found at the workstation, they were fixed before anyone else saw them.
Measure Your Engineering Change Process Before You Standardize It
Before you touch a workflow, find out where your changes actually wait. Three months of change objects, each with the date of every state transition, show which stage dominates for which change class. The script below turns such an export into median and 80th-percentile days per stage, using nothing but the Python standard library.
Export your change objects from Teamcenter with their transition dates (created, submitted, decided, released, effective) in whatever way your administrators already report on change, for example a saved query exported to Excel or the workflow audit data, and save it as CSV.
# Where does change time go? Median and 80th-percentile days per stage
# and change class, from a CSV export of your change objects.
# One row per change. Columns:
# change_id, change_class, created, submitted, decided, released, effective
# Dates as YYYY-MM-DD, empty if the change has not reached that state yet.
# Usage: python change_stage_times.py changes_2026q3.csv
import csv
import sys
from collections import defaultdict
from datetime import date
from statistics import median, quantiles
STAGES = [
("created", "submitted", "request drafting"),
("submitted", "decided", "impact analysis and board"),
("decided", "released", "NX work, check and release"),
("released", "effective", "release to effectivity"),
]
def to_date(value):
return date.fromisoformat(value.strip()) if value and value.strip() else None
def main(path):
days = defaultdict(list) # (change class, stage) -> calendar days per change
with open(path, newline="", encoding="utf-8") as f:
for row in csv.DictReader(f):
for start, end, stage in STAGES:
a, b = to_date(row[start]), to_date(row[end])
if a and b:
days[(row["change_class"], stage)].append((b - a).days)
print(f"{'class':<10}{'stage':<30}{'n':>5}{'median':>8}{'p80':>6}")
for change_class in sorted({c for c, _ in days}):
for _, _, stage in STAGES:
values = days.get((change_class, stage))
if not values:
continue
p80 = quantiles(values, n=5)[-1] if len(values) >= 5 else max(values)
print(f"{change_class:<10}{stage:<30}{len(values):>5}"
f"{median(values):>8.1f}{p80:>6.0f}")
if __name__ == "__main__":
main(sys.argv[1])
Read the output per class. If major changes spend most of their time between submission and decision, your problem is the impact analysis and the board. If minor changes spend theirs between decision and release, look at the checker loop and the inboxes. The 80th percentile matters as much as the median, because the slow fifth of your changes is what production remembers.
If your workflow records rejections, add their count per change as a column. A change that loops twice through check is a template or rule problem, not a workflow problem.
We’d advise against redesigning workflows before you have these numbers. A workflow rebuilt on opinion speeds up the stage someone complained about loudest, not the one that costs the most days.
What to Standardize First: Classes, Impact Analysis, Workflows, Effectivity
Standardize in this order: change classes, impact analysis, workflows, effectivity. Classes come first because every other rule depends on them: who analyzes, who decides, which workflow runs and how carefully effectivity is planned. Rebuilding workflows without classes moves the same queue into a new template.
1. Change classes with yes/no criteria
A change class decides how much process a change gets. Three classes are enough for most NX design organizations, and each needs criteria a requester can answer with yes or no.
| Class | Criterion | Part number | Impact analysis | Decision |
|---|---|---|---|---|
| Major | Form, fit or function changes; interchangeability broken; customer, safety or certification relevant | New part number | Full checklist, all departments | Change board |
| Standard change | New revision, still interchangeable, no customer impact | Same number, new revision | Checklist, only the departments concerned | Change analyst plus affected owners, asynchronous |
| Minor | Documentation only: drawing corrections, notes, title block errors without effect on the part | Same number, new revision | Where-used only | One approver, fast track |
The split follows the form-fit-function rule that many companies already apply to part numbers, and it mirrors the Class I and Class II distinction known from defense configuration management. Resist a fourth and fifth class. Every extra class needs its own criteria, its own workflow and its own training, and requesters start to pick the class with the shortest path.
2. Impact analysis: one checklist, named owners
Impact analysis gets fast when it is a fixed list of questions with an owner each, answered in parallel inside the change object instead of by email. Siemens summarized the scope on 1 October 2026: “A single change can affect requirements, BOMs, tooling, manufacturing processes, service plans and downstream documentation” (Siemens Teamcenter blog). Turn that into questions:
- Where used: which assemblies, products and variants contain the item? (Design, from Teamcenter where-used)
- Stock and orders: what is in stock, in production or on order, and is it used up, reworked or scrapped? (Logistics, from ERP)
- Manufacturing: which NC programs, fixtures, tools and work instructions change? (Manufacturing engineering)
- Suppliers: who holds the old revision, and does the change need a new first article inspection? (Purchasing and quality)
- Documentation and service: do manuals, spare parts catalogs or service instructions change? (Technical documentation)
- Compliance: are CE conformity, customer approvals or certificates affected? (Quality)
- Electrics and software: are ECAD data, wiring or control software affected? (Electrical and software teams)
Teamcenter helps with the first question. Teamcenter 2606, released on 12 June 2026, added “new views for impacted items and participants, along with bulk revert for BOM changes”, and Siemens says its large-scale impact analysis now runs with ten times more content visible (Introducing Teamcenter 2606). The other six answers still live in ERP, in CAM and in people’s heads. That is why the checklist matters more than the viewer.
3. Workflows per class, checks before the start
Build one workflow per change class, not one per department, and keep machine checks in front of it. Four rules cover most of the gain:
- Parallel instead of sequential reviews wherever reviewers do not depend on each other. Purchasing and manufacturing can read the same ECR at the same time.
- Surrogates and out-of-office assignments as a rule, not a courtesy. Teamcenter worklists support both; a task that sits in the inbox of someone on holiday is the most avoidable wait there is.
- Checks before the workflow starts. A rule handler such as EPM-check-object-properties can block the start when mandatory properties are empty, and Check-Mate in NX can test modeling and drafting rules before check-in. A workflow should never be the first place an empty attribute is discovered.
- Rejections with a reason code. A mandatory reason turns rework into something you can count and attack.
Our clear recommendation: move every check a machine can do in front of the workflow, and keep the workflow itself for decisions only people can make.
4. Effectivity: decided with the change, not after release
Effectivity defines from when, or from which unit, a new revision applies, and it belongs in the change request, decided by class. Left until after release, it turns into a phone call from production planning. Date effectivity suits series production with a planned cut-in date. Unit effectivity, by serial number, suits machines built to order, where a change applies from a specific machine onward.
Teamcenter supports both, and revision rules evaluate them when a BOM is configured; Siemens describes its BOM management as configuring “the bill of material using release states and maturity, effectivity and variants” (Siemens, BOM management). For DACH machine builders who build to order, unit effectivity usually fits better. It answers the shop floor’s real question, whether machine 1042 gets the new bracket, instead of what is valid on a given Monday.
A change process redesigned in a workshop is a prototype. What’s missing for production: change classes your board actually uses, an impact checklist with named owners, workflows rebuilt and tested in Teamcenter, checks that run in NX before the workflow starts, and three months of stage times that prove the difference. We set this up with your methods and PLM team, measured on your own changes, as part of engineering process optimization for Siemens NX and Teamcenter.
Where AI Helps in Engineering Change, and Where It Stops
AI is starting to take over the information work in change management: summarizing impacts, navigating where-used and BOM structures, drafting a request from a problem description. It does not replace the class rules, the board’s decision or the effectivity plan. In June 2026 Siemens presented a BOM agent that analyzes impact and executes changes within governed Teamcenter workflows, and its October post describes a user who could ask for an impact summary “instead of manually tracing a change across multiple systems and documents”.
Both speed up the first questions on the checklist. Neither decides whether stock is scrapped or when a change cuts in. An AI on top of an undefined process gets you to the same queues faster. Standardize first, measure, then add AI to the stage your numbers show as slowest.
Frequently Asked Questions
What is the difference between an ECR, an ECN and an ECO?
An engineering change request (ECR) proposes a change and documents why it is needed and what it affects, while an engineering change notice (ECN) or engineering change order (ECO) records the approved change and authorizes its implementation. Many companies use ECN and ECO as synonyms; some use the ECO for the authorization and the ECN to inform the departments affected. In Siemens Teamcenter the standard objects are called Change Request and Change Notice, often renamed in the company’s BMIDE template.
How does engineering change management work in Siemens Teamcenter?
Teamcenter manages a change as a set of objects with their own workflows: a problem report can lead to a change request, which is analyzed and decided, and an approved request leads to a change notice that lists the new revisions as solution items. Siemens bases its change management on the closed-loop CMII model. Change types, properties and workflows are configured per company in BMIDE and Workflow Designer, so two Teamcenter installations rarely run the same engineering change process.
How much does an engineering change cost a manufacturer?
There is no reliable universal figure, because the cost depends mainly on how late the change comes. Before release it is mostly engineering and administration time; after release it adds scrapped or reworked stock, tooling, supplier requalification and updated documentation. The often quoted “rule of ten” for costs rising by phase is a rule of thumb, not a measured constant, so measure hours and lead time per change class in your own data. inteliScience does this in the NX Engineering Assessment, a one-week, fixed-price €4,900 review of the NX and Teamcenter design process, which can start with a free first call with an NX engineer.
Date effectivity vs unit effectivity: which should an engineering change use?
Use date effectivity when products run in series and a change cuts in from a planned date, and unit effectivity, by serial number, when products are built to order and the change applies from a specific machine or lot. Unit effectivity takes more effort to maintain but answers the shop floor’s actual question of whether a given machine gets the new revision. Siemens Teamcenter supports both and evaluates them through revision rules when it configures a BOM.
Can AI do engineering change impact analysis in Teamcenter?
Partly. Siemens positions Teamcenter Copilot and the BOM agent it presented in June 2026 for change impact analysis: summarizing impacts, navigating BOM structures and where-used, and preparing changes within governed workflows. What AI cannot decide is whether stock is scrapped, which supplier needs a new first article inspection or when a change becomes effective, because those answers come from ERP, manufacturing and people. Treat the AI output as a draft for the change analyst, not as the impact assessment itself.
Next Step
Bring three changes your team closed last quarter. In a free 60-minute call, inteliScience’s Siemens NX and Teamcenter engineers from Cluj-Napoca walk through their dates with you, show where they waited and what to standardize first, under NDA. Talk to an engineer about your engineering change process
Related Topics
- NX Engineering Assessment for your design and release process
- Teamcenter workflow AI grounded in your own templates
References
- Siemens Digital Industries Software, Will Haines, “From engineering change to BOM execution: How AI BOM agents transform PLM”, Teamcenter blog (23 June 2026): https://blogs.sw.siemens.com/teamcenter/ai-bom-agent-plm-engineering-change/ (retrieved 9 October 2026)
- Siemens Digital Industries Software, Margaret Furleigh, “Take charge of change with Teamcenter”, Teamcenter blog (17 February 2025): https://blogs.sw.siemens.com/teamcenter/teamcenter-take-charge-of-change/ (retrieved 9 October 2026)
- Siemens Digital Industries Software, “Introducing Teamcenter 2606”, Teamcenter blog (12 June 2026): https://blogs.sw.siemens.com/teamcenter/teamcenter-2606/ (retrieved 9 October 2026)
- Siemens Digital Industries Software, Susan Zimmerlee, “AI in PLM: Turning product data into product lifecycle intelligence”, Teamcenter blog (1 October 2026): https://blogs.sw.siemens.com/teamcenter/ai-in-plm-teamcenter/ (retrieved 9 October 2026)
- Siemens, “Teamcenter BOM management”: https://www.siemens.com/en-us/products/teamcenter/solutions/bom-bill-of-materials-management/ (retrieved 9 October 2026)
- Robinson, M. A., “An empirical analysis of engineers’ information behaviors”, Journal of the American Society for Information Science and Technology 61(4), 640-658, 2010: https://doi.org/10.1002/asi.21290 (metadata and abstract retrieved via Crossref, 9 October 2026)

