NX Drawing Automation Whitepaper: Master Model to Batch

NX Drawing Automation: The Short Version

NX drawing automation means producing Siemens NX drawings from the master model through templates, part attributes and NXOpen programs, so every sheet of a part family looks like the first. inteliScience, Siemens NX and NXOpen specialists delivering nearshore from Romania, works in three tiers, templates, journals and batch generation, and measures every pilot against a baseline.

Question	Answer in one line
Why still drawings?	MBD is growing, but the drawing remains the document suppliers, purchasing and QA sign against.
What is the foundation?	The master model: one part file holds geometry, a second part file holds the drawing and references the first.
Where does automation start?	With PAX-registered templates and a title block that reads part attributes. No code yet.
When does code pay off?	When the same sheet pattern recurs across a part family, or when a vault full of parts needs drawings regenerated.
What must be checked afterwards?	View state, alignment, orphaned views, title block completeness and scale, ideally by a checker in batch.
Where does AI fit?	It reads the model and proposes the documentation. NXOpen executes, a human releases.

1. Why Drawings Still Exist in 2026

Drawings survive because they are contracts, not because anyone loves drafting. A supplier quotes against a drawing. Incoming inspection measures against a drawing. A customer’s purchasing department archives a drawing revision next to the order. Model-based definition moves the annotations into the 3D model and is clearly the direction of travel, yet in most DACH supply chains we work with, the PDF drawing is still the artefact that gets a signature. We compared the two approaches in detail in our piece on MBD versus the 2D drawing; the short answer is that the two coexist for years in any real supply chain.

That coexistence is the reason NX drawing automation matters. If the drawing were disappearing next year, nobody should invest in automating it. It is not disappearing. It is being produced, in many companies, by hand, for parts whose geometry already came out of a configurator or a family table.

The timing is also right for a different reason. Siemens renamed Designcenter NX to Designcenter with the June 2026 release, version 2606, announced on 23 June 2026, and the headlines were Copilot, Live Share collaboration and immersive engineering. Drafting is not where the new features are, which means the Drafting application and the NXOpen drafting API are mature, stable and safe to automate against. The September 2026 Early Access Program for the next release, Designcenter 2612 (virtual week 31 August to 4 September, in-person weeks 14 to 25 September 2026 in Mason, Ohio), listed core modeling, a unified token system, collaborative engineering and AI-enabled design as its focus areas. Again, not drafting. The drawing stack you automate today is the stack you will have in two years.

This document is written for CAD managers, NX administrators and engineering leads who own drawing throughput.

2. The Master Model Concept in NX

A master model drawing is two files. The model part, say bracket.prt, contains the geometry, expressions, PMI and model views. The drawing part, say bracket_dwg.prt, contains the master as an assembly component and holds the sheets, the drafting views, the dimensions and the title block. Views in the drawing point at model views in the master. Change the master, update the drawing, done. Siemens describes this as the recommended way to create drawings, and every automation tier in this whitepaper assumes it.

Why two files rather than sheets inside the model part? Three reasons that matter for automation. The drawing does not lock the model: a designer works on bracket.prt while a drafter works on bracket_dwg.prt, and in Teamcenter the two live as separate datasets under the same item revision, the model as the UGMASTER dataset and the drawing as a UGPART dataset that carries the master as a component. The drawing can carry its own geometry, an exploded view or a drawing-only reference set, without polluting the master that CAM, simulation and the supplier’s STEP export depend on. And a batch process can regenerate drawings without touching the model, which is the property the whole batch tier in chapter 6 rests on.

Our recommendation, stated as plainly as we can: never “save the model as a drawing”. A model part with sheets inside it is one file with two lifecycles, and the day someone saves it under a new name to make a variant, the revision history forks. We have cleaned this up for clients more than once, and it always costs more than the ten minutes the shortcut saved.

	Model part (`bracket.prt`)	Drawing part (`bracket_dwg.prt`)
Holds	Geometry, expressions, PMI, model views, attributes	Sheets, drafting views, dimensions, notes, title block
References	Nothing above it	The model part as a component
Changes when	Design changes	Design changes (via update) or documentation changes
Teamcenter dataset	UGMASTER	UGPART
Touched by batch	No	Yes

3. Drawing Templates and Standards

Templates are the first automation tier, and the one every NX installation already has. When you choose File > New > Drawing, NX reads a PAX file, a text file that lists each template with an id, a name, a description, units and the file name of the template part. Two files matter: ugs_drawing_templates.pax for File > New > Drawing and ugs_sheet_templates.pax for Insert > Sheet, with nxdm_ prefixed variants for Teamcenter-managed installations. On a native install they sit in the DRAFTING\templates folder of the NX installation, for instance C:\Program Files\Siemens\NX2206\DRAFTING\templates on an NX 2206 install. The cleaner way is to set UGII_TEMPLATE_DIR to a company folder and keep your PAX files and template parts there, so an NX upgrade does not overwrite them. The “Mark as Template” command registers a template part and updates the PAX file for you; a text editor works as well.

One tag in the PAX entry decides more than people realise: UsesMasterModel. It controls whether the new drawing asks you for a part to reference or stands alone. If you want master model drawings, and you do, the tag must be set on every template your team can pick.

3.1 ISO versus ANSI

The drafting standard is set when the drawing is created and it drives sheet sizes, projection angle, dimension style, arrowheads, fonts and the default view style. For DACH shops that means the ISO standard with first-angle projection and A-series sheets; the ANSI templates that ship with NX and appear in most YouTube tutorials use third-angle projection and letter-sized sheets. A drawing created on the wrong template is not fixed by swapping the border. It is recreated.

Our clear recommendation: strip the PAX files down to the templates your company actually uses, one per sheet size and standard. A picker with thirty entries, half of them ANSI, is how the wrong standard ends up on a supplier drawing.

3.2 The title block reads attributes, it is not typed

The title block in a template is a table with notes, and every field that can be an attribute reference should be one. Part number, name, revision, material, mass, the drawn-by and checked-by fields, the date: all of these exist as part attributes on the master or the drawing part, and a note that references an attribute updates when the attribute changes. A title block that is typed by hand is a title block that lies after the next revision, and it is also the reason a batch process cannot fill it.

This is the boundary between tier one and tier two. If the title block is attribute-driven, an NXOpen program only has to set attributes and the sheet follows. If the title block is typed, the program has to find and edit note text, which is fragile and standard-specific. Fix the template first, write code second.

Approach	Setup effort	Per-drawing effort	Consistency	Breaks when
Manual drafting on a default template	none	high, every view and field by hand	depends on the drafter	anyone is in a hurry
Template-driven (PAX, standard, attribute title block)	days, once	medium, views by hand, title block free	high on the title block, medium on views	a new standard or sheet size appears
NXOpen batch on template-driven drawings	weeks, once per sheet pattern	minutes of machine time	high, identical by construction	the sheet pattern changes or a part breaks the pattern

4. View Types in Practice

Base view, projected views, sections, broken-out sections and exploded views cover most of what a mechanical drawing needs. Each behaves slightly differently under the master model, and one of them has a trap that fills Siemens Community threads year after year.

View type	Command family	Under master model	Automation note
Base view	Base View, pick model view (Front, Top, Trimetric or a saved view)	Reads model views of the master and of the drawing part	The one view every batch job places; the anchor for the rest
Projected view	Drag from the base view with the cursor	Follows the base view’s standard and projection angle	Placed relative to the parent, cheap to automate
Section view	Section View on an active parent, draw the cut line	Hatching from the view style and body section settings	Needs a defined cut line; automate only for fixed geometry patterns
Broken-out section	Break-Out Section (Command Finder: `breakout`), closed boundary plus depth	Local cut, parent stays whole	Sketch-based; rarely worth automating
Exploded view	Explosion created in Modeling on the drawing part, then Base View with Part = drawing part	Must live in the drawing part, not the master	Automatable once the explosion exists in the drawing part

4.1 Base view first, then the rest

File > New > Drawing. Pick the ISO template of the right size. The dialog asks for a part: point it at the model, not at an empty drawing. Place a Base View, choose Front or whatever your standard prescribes as the main view, then drag the projected views off it. Three views, one command. Everything after that is a view type.

4.2 Section and broken-out section

A section view cuts the parent along a line you draw and places the result in the projection direction. Hatching comes from the view style and the body’s section settings; painting a hatch by hand is a sign the view style is wrong. A broken-out section is different: you need a closed boundary sketched on the expanded parent view and a depth, and NX removes a local pocket of material so a hole or rib shows without cutting the whole part. If the break-out looks like a full section, the depth is through the part or the boundary is the whole view. Undo, smaller boundary.

4.3 The exploded view and the Part picker trap

This is the view that fills Siemens Community threads. Under the master model you cannot display an exploded view of the master in the drawing part. The Siemens Community quick tip on exploded views in the master model drawing concept is explicit: create the explosion in the Modeling application of the drawing part, save the model view, go back to Drafting, open Base View, expand the Part group at the top of the dialog, select the drawing part under Loaded Parts, and only then pick the exploded model view.

The default Part in the Base View dialog is the master. The explosion is not in the master. That is why “Explosion 1” never appears in the view list, and it is the single most common reason a team concludes that exploded views “do not work on drawings”.

Some teams skip explosions and use an assembly arrangement named for the purpose, then pick that arrangement on the view; for nested subassemblies that is often cleaner. Tracelines are the weak spot either way. We make no release-specific claims about whether a future Designcenter version relaxes this. Check the Part picker every time, on every version.

The first thing we run on any drawing that someone says is “wrong” is a listing of sheets and views with scale and update state. It answers the exploded-view question in one glance, because a view placed on the master shows a normal view name, not the explosion.

# List every sheet and drafting view in the work part (NXOpen Python).
# Run inside NX (File > Execute > Journal) or via run_journal in batch.
import NXOpen


def list_drawing_views():
    session = NXOpen.Session.GetSession()
    work_part = session.Parts.Work
    lw = session.ListingWindow
    lw.Open()
    lw.WriteLine("Drawing part: " + work_part.Leaf)
    for sheet in work_part.DrawingSheets:
        lw.WriteLine("Sheet: " + sheet.Name)
        for view in sheet.SheetDraftingViews:
            state = "OUT OF DATE" if view.IsOutOfDate else "current"
            lw.WriteLine("  view={0}  scale={1}  {2}".format(
                view.Name, view.Scale, state))


if __name__ == "__main__":
    list_drawing_views()

If your exploded view is missing from that list, you placed a trimetric of the master. Repeat Base View with the drawing part selected.

5. PMI Inheritance: Reusing the Model’s Annotations

If your models carry PMI, the drawing should not retype it. NX Drafting can inherit PMI into a drafting view, and the behaviour is well defined in the NX documentation. Inherited PMI is displayed with the annotation preferences of the drawing, not with the preferences applied in the model view, and its size adjusts to the drawing scale. Position and orientation relative to the geometry stay as they are in the model view; if the annotation’s z-axis points into the drawing, NX rotates it so it reads correctly.

The part that matters for this whitepaper is the master model support. When you create a non-master drawing from a master part, the model views of both the drawing part and the master part are available, NX maintains the associations back to the master, and drafting views pick up PMI changes from the master when they update. If someone adds PMI to a model view that was already placed on a drawing with the Inherit PMI option, NX marks the drawing out of date, highlights the affected views in the Update Views dialog, and adds the new PMI to the drafting view on update.

Three practical consequences. PMI inheritance turns the drawing into a rendering of the model’s annotations, the only way a drawing and a model stay consistent without a person comparing them. The quality of the inherited drawing is exactly the quality of the PMI, so badly placed or badly numbered PMI produces an unreadable view, which is why we automate PMI placement and numbering before we automate drawings. And an out-of-date drafting view is a machine-readable state, IsOutOfDate in NXOpen, which a batch job checks and updates instead of a person opening every drawing.

We would advise against inheriting PMI into a drawing whose standard differs from the one the PMI was authored under. The annotations render, but the tolerancing conventions may not match what the supplier expects, and nobody notices until incoming inspection.

6. The Three Automation Tiers

NX drawing automation is not one thing. It is three tiers with different cost, different risk and different points at which they break. Most teams should climb them in order.

Tier	What it is	Effort to set up	Benefit	Breaks when
(a) Templates + attributes	PAX-registered templates per standard and size, attribute-driven title block, house view styles	Days, once, no code	Every drawing starts right; title block never typed	A second standard or an unmanaged template copy appears
(b) Journals and NXOpen programs	Recorded journals cleaned into functions, or a compiled NXOpen program, that place the recurring sheet and views for a part class	One to three weeks per sheet pattern	A first sheet in seconds, identical for every member of the family	Geometry outside the pattern, or a view that needs judgement (sections through variable features)
(c) Batch generation	Tier (b) driven by `run_journal` over a list of parts, on a folder or on the vault, with checks on the output	Weeks, including the check step and error handling	Hundreds of drawings regenerated overnight after a template or standard change	Parts with broken links, missing model views or non-standard reference sets; no GUI means no dialogs

6.1 Tier (a): the tier without code

Everything in chapter 3. We start every drawing automation project here, because a program that places views onto a badly configured template only produces bad drawings faster.

6.2 Tier (b): journals and programs

A recorded journal is the fastest way to learn what the NXOpen drafting API does: record a base view and two projected views and you have the exact builder calls for your NX version. The recording is not the automation, though. It has hard-coded names, hard-coded coordinates and no error handling. The step from journal to program, which we described in our comparison of NX journals and NXOpen programs, is where the sheet pattern becomes a function with parameters: which part, which model views, which scale, which template.

The API surface you need is small. NXOpen.Session.GetSession() and session.Parts.Work give you the drawing part. work_part.DrawingSheets and sheet.SheetDraftingViews let you inspect what exists. work_part.DraftingViews.CreateBaseViewBuilder(...) returns a BaseViewBuilder whose SelectModelView, Placement, Scale and Style sub-builders match the groups in the Base View dialog. Attributes are read with GetUserAttributes() and written with SetUserAttribute(...) on any NXObject, including the part itself.

Our recommendation for tier (b): stay in Python for inspection, checking and orchestration, and move to a compiled NXOpen program only when the placement logic grows past a few hundred lines or needs a proper UI. Python journals need no build step and are what most CAD admins can maintain after we leave.

6.3 Tier (c): batch on the folder or on the vault

run_journal.exe starts an NX process without a GUI and runs a journal against it; since NX 11 it lives in the NXBIN folder of the installation. In batch mode there are no dialogs, so a journal that calls a message box fails, and the journal must open the part it works on itself. That is a constraint and a feature: a batch job is deterministic by construction.

Tier (c) is where a template change, a title block change or a standard change stops being a project: regenerating a family’s drawings after the title block gained a field becomes a night of machine time. It is also the tier where errors compound. A part with a broken WAVE link, a missing model view or an unusual reference set fails silently unless the job checks its own output, which is chapter 8.

Do not start at tier (c). The batch job is only as good as the sheet function it calls, and the sheet function is only as good as the template it starts from.

7. Worked Example: Automating the First Sheet of a Part Family

The scenario: a family of machined brackets, all modelled from the same template with the same model views, each needing a first sheet with a front base view, two projected views and an attribute-driven title block. The geometry differs, the sheet pattern does not. We want a job that opens each drawing part, verifies it, updates what is out of date, stamps the revision attribute and saves.

The example below is deliberately an inspect-and-update job rather than a from-scratch view placement. It is what we run first in every pilot, because it produces value on existing drawings before any new view is created. New views use the builder pattern shown afterwards.

# first_sheet_job.py: verify and refresh the first sheet of a master model
# drawing, then stamp the revision attribute. Runs in batch via run_journal.
# Usage: run_journal.exe first_sheet_job.py -args <drawing.prt> <revision>
import sys
import NXOpen

REQUIRED_ATTRIBUTES = ["PART_NUMBER", "PART_NAME", "REVISION", "MATERIAL"]
# Adjust the names above to the attributes your title block references.


def attribute_titles(nx_object):
    """Return the set of user attribute titles present on an NX object."""
    return {info.Title for info in nx_object.GetUserAttributes()}


def check_title_block(drawing_part, lw):
    """Report title block attributes missing on the drawing part."""
    present = attribute_titles(drawing_part)
    missing = [name for name in REQUIRED_ATTRIBUTES if name not in present]
    for name in missing:
        lw.WriteLine("  MISSING attribute: " + name)
    return not missing


def refresh_first_sheet(drawing_part, lw):
    """Update out-of-date views on the first sheet and report scale."""
    sheets = drawing_part.DrawingSheets.ToArray()
    if not sheets:
        lw.WriteLine("  ERROR: drawing part has no sheets")
        return False
    first = sheets[0]
    lw.WriteLine("  Sheet: " + first.Name)
    ok = True
    for view in first.SheetDraftingViews:
        if view.IsOutOfDate:
            lw.WriteLine("  updating view " + view.Name)
            view.Update()
        lw.WriteLine("  view={0} scale={1}".format(view.Name, view.Scale))
    return ok


def main(args):
    session = NXOpen.Session.GetSession()
    lw = session.ListingWindow
    lw.Open()
    path, revision = args[0], args[1]
    drawing_part, load_status = session.Parts.OpenActiveDisplay(
        path, NXOpen.DisplayPartOption.AllowAdditional)
    load_status.Dispose()
    lw.WriteLine("Opened " + drawing_part.Leaf)

    title_ok = check_title_block(drawing_part, lw)
    sheet_ok = refresh_first_sheet(drawing_part, lw)

    if title_ok and sheet_ok:
        # -1 means a non-array attribute; Update.Option.Now applies it at once.
        drawing_part.SetUserAttribute(
            "REVISION", -1, revision, NXOpen.Update.Option.Now)
        drawing_part.Save(NXOpen.BasePart.SaveComponents.TrueValue,
                          NXOpen.BasePart.CloseAfterSave.FalseValue)
        lw.WriteLine("  saved with REVISION=" + revision)
    else:
        lw.WriteLine("  NOT saved: fix the reported problems first")


if __name__ == "__main__":
    # run_journal passes -args values through sys.argv after the script name.
    main(sys.argv[1:])

What the job does, in order. It opens the drawing part, which pulls in the master as a component. It checks that the attributes the title block references exist on the drawing part and lists any that are missing rather than guessing values. It walks the drafting views on the first sheet, updates the ones NX has flagged as out of date, and logs each view’s name and scale so the log can be diffed against the expected pattern. Only if both checks pass does it set the revision attribute, which the title block reads, and save. A drawing with problems is left untouched and reported, which is the behaviour a CAD manager will accept in batch.

Placing a new base view follows the builder skeleton below. The placement point and scale come from the Placement and Scale sub-builders, and a two-minute journal recording gives you the exact calls for your release.

# Skeleton for placing a base view from a named model view (NXOpen Python).
import NXOpen

session = NXOpen.Session.GetSession()
work_part = session.Parts.Work

builder = work_part.DraftingViews.CreateBaseViewBuilder(
    NXOpen.Drawings.BaseView.Null)
try:
    # The model view lives in the master for normal views and in the
    # drawing part for explosions (see chapter 4). Pick accordingly.
    front = work_part.ModelingViews.FindObject("Front")
    builder.SelectModelView.SelectedView = front
    # builder.Placement and builder.Scale mirror the dialog groups;
    # take their exact calls from a recorded journal on your NX version.
    base_view = builder.Commit()
finally:
    builder.Destroy()

The driver around either script is plain Python with the standard library: read a list of drawing parts from the vault export or a folder, call run_journal.exe once per part with subprocess, collect the listing output per part, and write a summary. No NXOpen in the driver, so it runs on any machine and can be scheduled.

This runs as a POC. What’s missing for production: Templates for every standard and sheet size your customers demand, Teamcenter datasets instead of folders, batch on the vault with checkout and check-in, error handling for the parts that break the pattern, and checks on the generated output before anyone sees it. We close the gap from “runs on my machine” to “runs on the vault every night” as NXOpen specialists with nearshore delivery from Romania, one hour ahead of CET. Book a strategy call about NX drawing automation.

8. Drawing Quality Checks After Generation

A generated drawing that nobody checks is a liability with a nicer title block. The checks are cheap, they are mostly the same for every company, and they should run in the same batch that produced the drawing.

Check	What it catches	How to detect it
View update state	Views that do not reflect the current model	`IsOutOfDate` on each drafting view; update or fail
View alignment	Projected views drifted off the base view’s axes, rotated views	Compare view origins against the parent; a checker with a dedicated alignment check
Orphaned and obsolete views	Views whose model view no longer exists, leftover views from a template	List views per sheet and compare with the expected pattern for the part class
Title block completeness	Missing or unset attributes the title block references	`GetUserAttributes()` against the required list, as in chapter 7
Scale	A family sheet at 1:2 where the pattern says 1:1, or a view that does not fit the sheet	`Scale` per view, sheet size from the `DrawingSheet`
Standard and projection angle	ANSI sheet in an ISO shop, third-angle where first-angle is required	`ProjectionAngle` and `Units` on the sheet
Empty or duplicate sheets	Batch jobs that ran twice, templates with a spare sheet	Count sheets, count views per sheet

Two tools cover the ground beyond what a job like the one in chapter 7 checks. Siemens NX Check-Mate ships with hundreds of standard checks across modeling, drafting, PMI, geometry, routing and other applications, can be run interactively or in batch, and has an authoring tool for custom checks; it is the natural place for company-specific rules. DOCUFY CAx Quality Manager 2026.1, released on 30 March 2026, added a check for the alignment of drawing views, and the product carries more than 450 configurable checks, a batch mode and healing for supported checks, which turns “found” into “fixed” for the cases it covers. inteliScience is an official DOCUFY partner and sets DQM up alongside Check-Mate where a client wants alignment and healing in the same run as generation. How the two checkers divide the work, and where the NX-native checks stop, is the subject of our overview of CAD quality assurance in Siemens NX.

Whatever the checker, one rule has held in every project: the check runs in the same pipeline as the generation, and a failed check leaves the drawing unsaved and reported. Checks that run a week later, by a person, on a sample, are the reason drawing automation gets a bad name.

9. Where AI Fits

An AI assistant does not draft. It reads. The useful role of a language model in NX drawing automation is to look at the model, the PMI, the attributes and the part class, and propose the documentation: which views this part needs, which sheet pattern applies, which title block fields are unset, which notes the house standard requires for this material and process. The proposal is text and parameters. NXOpen executes it through exactly the functions of chapters 6 and 7, and a human releases the result.

That division is not caution for its own sake. A model that places views by guessing coordinates produces drawings that look plausible and are wrong in ways a checker may not catch. A model that fills a parameter set for a deterministic sheet function produces drawings that are right by construction or fail loudly. Our Drawing and Documentation Assistant follows the second pattern: the assistant reads the open part and proposes the sheet set and the notes.

Siemens’ own Designcenter Copilot, introduced with the June 2026 release, answers questions from documentation and the current task rather than placing views. The sober summary for 2026: AI proposes, NXOpen executes, a human releases. Teams that expect a chat window to produce a released drawing will be disappointed; teams that use it to stop the first draft from starting at zero will not.

10. Measuring a Pilot and the Adoption Path

A drawing automation pilot is judged by numbers on your own parts, measured before and after. We do not publish benchmark percentages here, because the result depends on how many drawings per week your team produces and how much of that is family work. What we do publish is the measurement plan we agree with every client before writing a line of code.

Metric	Baseline (before)	Pilot (after)	How it is measured
Drawings released per week	count from the vault or release log	same source	Release date on the drawing dataset
Time per first sheet	drafter’s time on the first sheet of a family member	job runtime plus review time	Time tracking on a defined set of parts
Rework loops per drawing	number of times a drawing returns from check to drafter	same	Workflow history in Teamcenter or the check log
Failed checks per hundred drawings	from the checker run on the current stock	from the checker run on generated drawings	Checker batch report
Share of family parts covered by a sheet pattern	drawings that fit an existing pattern divided by all drawings	same after new patterns	Classification of the pilot part set
Time to regenerate after a template change	elapsed time for the last title block change	batch runtime	Project log

The adoption path that has worked, in the order it has worked:

Weeks 1 to 2: templates and attributes. PAX files cleaned to the standards in use, UGII_TEMPLATE_DIR set, title block attribute-driven, one part class chosen for the pilot, baseline numbers collected.
Weeks 3 to 5: the first sheet function. One sheet pattern for one part family, as a Python journal with the checks of chapter 8 built in, run by the CAD admin on real parts and reviewed by the drafters who used to draw them.
Weeks 5 to 7: batch on a folder, then on the vault. run_journal driver, per-part logs, failed drawings reported rather than saved, checker integrated. Pilot numbers reported against the baseline.
Rollout: further sheet patterns, Teamcenter integration, scheduled regeneration after template changes, and, where the team wants it, the AI assistant of chapter 9 proposing sheet sets for parts outside the known patterns.

inteliScience delivers this from Romania, in EET, one hour ahead of Central European Time, with senior NX and NXOpen engineers who have done the template cleanup as often as the code, for clients across the DACH region. The templates, the jobs and the checks are yours at the end.

Frequently Asked Questions

What is NX drawing automation?

NX drawing automation means producing Siemens NX drawings from the master model through templates, part attributes and NXOpen programs rather than by hand. It ranges from PAX-registered templates with an attribute-driven title block, through journals that place the recurring views of a part family, to batch generation over many parts with quality checks on the output.

Does the master model concept work with Teamcenter?

Yes. In Teamcenter the model is stored as the UGMASTER dataset and the drawing as a UGPART dataset under the same item revision, with the drawing carrying the master as a component. Release workflows can treat the two separately, and a batch job can regenerate the drawing dataset without modifying the model. Templates must use the Teamcenter-managed PAX variants.

NX journal vs NXOpen program: which one for drawing automation?

Start with a Python journal. It runs without a build step, can be maintained by a CAD admin, and covers inspection, checking, view updates and attribute stamping. Move to a compiled NXOpen program when the placement logic outgrows a few hundred lines, needs a dialog, or must be shared as a signed tool across sites. The batch driver around either is plain Python.

How much does an NX drawing automation pilot cost?

inteliScience scopes pilots at a fixed price after a short assessment of your templates and one part family. The cost driver is the number of drafting standards and distinct sheet patterns, not the number of parts, because a pattern written once regenerates any number of drawings. A pilot that covers template cleanup, one sheet function and batch generation with checks fits in roughly seven weeks.

Can drawing views inherit PMI from the model automatically?

Yes, with the Inherit PMI option on a drafting view. Inherited PMI is rendered with the drawing’s annotation preferences, keeps its position relative to the geometry, and under the master model stays associated with the master part. When PMI is added to a model view already on the drawing, NX marks the drafting view out of date and adds the new PMI on update.

Next Step

If your drafters are producing the same first sheet for the twentieth family member this month, the template tier is overdue and the sheet function is a scoping conversation.

Talk to our engineers about automating your NX drawings

Sources

Siemens Digital Industries Software, “Welcome to the September 2026 Early Access Program for Designcenter”, https://resources.sw.siemens.com/en-US/presentation-welcome-to-designcenter-early-access-program/ (retrieved 24 September 2026)
Siemens, “CAD model design validation” (NX Check-Mate), https://www.siemens.com/en-us/products/designcenter/nx-cad-software/mcad/design-validation/ (retrieved 24 September 2026)
Siemens NX documentation, “Restrictions and operating characteristics for inherited PMI”, and Siemens Community, “Inherit PMI Dimensions”, https://community.sw.siemens.com/s/article/inherit-pmi-dimensions (retrieved 24 September 2026)
Siemens Community, “NX Quick Tips: Create an Exploded View in the Master Model Drawing Concept”, https://community.sw.siemens.com/s/article/nx-quick-tips-create-an-exploded-view-in-the-master-model-drawing-concept (retrieved 24 September 2026)
Siemens Community, “Pax files? NXcustom2206”, https://community.sw.siemens.com/s/question/0D54O000081SFjZSAW/pax-files-nxcustom2206, and Swoosh Technologies, “How to create a custom drafting template in NX”, https://www.swooshtech.com/2022/09/23/how-to-create-a-custom-drafting-template-in-nx/ (retrieved 24 September 2026)
Siemens Community, “Is it possible to save a UGMASTER as a UGPART of another item?”, https://community.sw.siemens.com/s/question/0D54O00006HAKdXSAX/is-it-possible-to-save-a-ugmaster-as-a-ugpart-of-another-item, and Eng-Tips, “Teamcenter master model drawings”, https://www.eng-tips.com/threads/teamcenter-master-model-drawings.272302/ (retrieved 24 September 2026)
NXOpen .NET Reference (NX 2022.1 mirror): DraftingViewCollection, BaseViewBuilder, SelectModelViewBuilder, DrawingSheet, DraftingView, View, NXObject, https://nxopencsdocumentation.thescriptingengineer.com/NX2022_1/NXOpen.Drawings.DraftingViewCollection.html (retrieved 24 September 2026)
NX Journaling, “Using Batch file to run recorded journal” and “NX10/NX12 Python NXOpen Batch File Differences?”, https://nxjournaling.com/content/using-batch-file-run-recorded-journal (retrieved 24 September 2026)
DOCUFY, release announcement for version 2026.1 (“NX-Datenqualität sichern”), 30 March 2026, https://docufy.de/nx-datenqualitaet-sichern-neue-version-des-docufy-cax-quality-managers/ (retrieved 24 September 2026)

NX Drawing Automation Whitepaper: Master Model to Batch

NX Drawing Automation: The Short Version

1. Why Drawings Still Exist in 2026

2. The Master Model Concept in NX

3. Drawing Templates and Standards

3.1 ISO versus ANSI

3.2 The title block reads attributes, it is not typed

4. View Types in Practice

4.1 Base view first, then the rest

4.2 Section and broken-out section

4.3 The exploded view and the Part picker trap

5. PMI Inheritance: Reusing the Model’s Annotations

6. The Three Automation Tiers

6.1 Tier (a): the tier without code

6.2 Tier (b): journals and programs

6.3 Tier (c): batch on the folder or on the vault

7. Worked Example: Automating the First Sheet of a Part Family

8. Drawing Quality Checks After Generation

9. Where AI Fits

10. Measuring a Pilot and the Adoption Path

Frequently Asked Questions

What is NX drawing automation?

Does the master model concept work with Teamcenter?

NX journal vs NXOpen program: which one for drawing automation?

How much does an NX drawing automation pilot cost?

Can drawing views inherit PMI from the model automatically?

Next Step

Sources

Company

Services

NX Drawing Automation Whitepaper: Master Model to Batch

NX Drawing Automation: The Short Version

1. Why Drawings Still Exist in 2026

2. The Master Model Concept in NX

3. Drawing Templates and Standards

3.1 ISO versus ANSI

3.2 The title block reads attributes, it is not typed

4. View Types in Practice

4.1 Base view first, then the rest

4.2 Section and broken-out section

4.3 The exploded view and the Part picker trap

5. PMI Inheritance: Reusing the Model’s Annotations

6. The Three Automation Tiers

6.1 Tier (a): the tier without code

6.2 Tier (b): journals and programs

6.3 Tier (c): batch on the folder or on the vault

7. Worked Example: Automating the First Sheet of a Part Family

8. Drawing Quality Checks After Generation

9. Where AI Fits

10. Measuring a Pilot and the Adoption Path

Frequently Asked Questions

What is NX drawing automation?

Does the master model concept work with Teamcenter?

NX journal vs NXOpen program: which one for drawing automation?

How much does an NX drawing automation pilot cost?

Can drawing views inherit PMI from the model automatically?

Next Step

Related Topics

Sources