Major

NetSuite Integration: Automate the Manufacturing Handoff

Connect NetSuite sales orders to manufacturing planning with a controlled workflow that checks item and inventory context, routes exceptions, and keeps production updates reviewable.

Ritvij GautamUpdated
Major x NetSuite integration for a governed manufacturing order handoff.

TL;DR: what you'll build. Production teams that run NetSuite as the system of record for sales orders often have someone retyping order details into a planning spreadsheet or MRP screen. This NetSuite integration reads new sales orders, checks them against your BOM and inventory rules, and creates or updates the matching work order. A planner approves anything the rules can't resolve on their own.

Why the manufacturing handoff needs automating

If your production team runs NetSuite as the system of record for sales orders, the handoff to the shop floor is usually manual. A person retypes order and item details into a planning spreadsheet or a separate MRP screen.

You can automate that handoff with NetSuite's own SuiteTalk REST Web Services. The flow is short:

  • Read new sales orders and their items.
  • Check them against your BOM and inventory rules.
  • Create or update the matching work order.
  • Send anything the rules can't resolve on their own to a person for approval.

This article sits one layer below the broader survey in AI agent use cases for manufacturing. Here the scope is one connector and one workflow.

How a NetSuite integration connects sales orders to production

NetSuite exposes its records through SuiteTalk REST, a resource-oriented API. It supports CRUD operations (create, read, update and delete), SuiteQL queries, and record transformations on standard objects like the sales order, item and work order records.

Oracle's own REST Web Services overview documents more on top of that base:

  • Full metadata discovery.
  • Record filtering.
  • Asynchronous request processing.

The bounded workflow

The workflow worth automating is narrow. It has four steps:

  • Detect a new or updated sales order.
  • Pull its line items.
  • Check those items and quantities against configured BOM and inventory data.
  • Either create a work order record or flag the order for a person to review.

Who owns what

NetSuite is the system of record for both the order and the resulting work order. Nothing about that changes.

A Major app holds the state of each handoff in progress. It tracks which orders have been read, which passed validation automatically, which are sitting in an exception queue, and what was ultimately written back.

The agent's only job is judgment on the exceptions a rules engine can't resolve. Everything repeatable runs as deterministic code: the reads, the field mapping, the status transitions and the retries. Deterministic code means the same input always produces the same output, with no model reasoning involved.

Which manufacturing handoffs are worth automating

Order intake into production planning is the clearest candidate. It is high-frequency, rule-governed, and currently manual in most shops that haven't built custom middleware.

A few adjacent patterns are worth naming so you don't try to automate all of them in one pass.

Patterns to build, in order

  • Order and item validation against BOM and inventory context: deterministic, runs on every order, and is the core of this workflow.
  • Work order status visibility back to sales or customer service: a read-only reporting layer. It is lower risk and makes a good second phase.
  • Exception routing for orders with missing items, unconfigured BOMs or ambiguous descriptions: this is where an agent's judgment earns its keep, not in the first two.

The pattern to avoid

Avoid automatic work order release without review. NetSuite's own Work Order record documentation requires the Work Orders feature to be enabled.

Account-specific fields, item configuration and approval rules also vary enough that blind automation creates bad production data fast. A wrong work order on the shop floor costs more to unwind than a short review step costs to keep.

A note on savings

Don't promise savings figures here. Actual impact depends on order volume and how often your orders are clean versus requiring judgment, and that is account-specific.

What to verify in NetSuite before you connect it

Authentication comes first, because nothing else works until the integration can sign in.

Authentication options

SuiteTalk REST supports two authentication setups:

  • OAuth 2.0: Oracle now recommends this as the preferred method.
  • Token-based authentication (TBA): the older alternative.

Both require creating an integration record inside NetSuite and noting a credential pair. For OAuth 2.0 that is a client ID and secret. For TBA it is a consumer key and secret. REST web services do not accept plain user credentials.

Account checks

Before you wire anything up, confirm these in your own account:

  • Field names and operations: check the exact fields and operations available on the sales order, item and work order records using the account's REST API Browser. Oracle links this from each record's documentation page, for example the sales order reference and the work order reference. Record IDs are lowercase (salesorder, workOrder), and fields differ by which features and custom records your account has enabled.
  • Work Orders feature: confirm it is turned on. It is a stated prerequisite for the work order record, not a given on every account.
  • Role permissions for the integration user: read access on sales orders and items, write access scoped to work orders only, and nothing broader.
  • SuiteTax: confirm it is enabled if your sales orders carry tax, since REST web services don't support legacy tax handling.

How you learn about new orders

Oracle's public SuiteTalk REST documentation does not describe a native webhook mechanism for record changes. A webhook is a push notification: the source system calls you when something changes, instead of you asking.

The documented alternatives are SuiteScript RESTlets or Workflow Action scripts configured inside the account. These are account-specific builds rather than a universal subscription endpoint. That leaves two real options:

  • Scheduled polling (the default): query sales orders with a SuiteQL filter on last-modified date or status. It is simple to build and works on every account without extra NetSuite-side scripting. The tradeoff is a few minutes of latency between order creation and detection.
  • A SuiteScript-based workflow action that calls out on order save: lower latency, but it requires a script deployed and maintained inside NetSuite itself. Oracle doesn't document it as a drop-in feature. Choose this only if your team already owns SuiteScript development and near-real-time matters more than simplicity.

Think of polling like checking your mailbox on a schedule, while a webhook is a doorbell. The mailbox is a little slower, but it works at every address without installing anything.

Rate limits and the item group gotcha

Oracle's guide does not publish a universal rate limit. Concurrency and request limits vary by account tier, so check your account's governance settings rather than assuming a number.

One gotcha is worth flagging up front. You can create a work order with an ItemGroup member item on the initial POST, but you can't change that item's quantity, rate or amount in the same request.

You have to follow up with a PATCH. This matters if your validation logic tries to correct quantities in one pass.

Build the sales-order handoff on Major

NetSuite has no catalogued native connector in Major today, so you build this as a custom API connector. The app, agent and trigger then sit on top of it.

What the app stores per order

The app behind the workflow is the part that makes the handoff auditable. For each order it stores:

  • The source sales order ID and line items.
  • The normalized item mapping.
  • The BOM and inventory check result.
  • An exception reason, when one exists.
  • Who approved it and when.
  • The resulting work order reference.
  • Retry state.
  • A full audit trail of every action taken.

That table is also the screen a production planner works from. It is a queue of orders waiting on review, not a raw API log.

Build steps

  1. Connect NetSuite as a custom API connector, with the base URL pointed at your account's SuiteTalk REST endpoint, OAuth 2.0 client credentials held by Major's credential proxy rather than embedded in code, and scopes limited to the integration role you set up for sales orders, items and work orders; attach the Slack connector too if planners will review there. You should see the NetSuite connector configured with credentials stored in the proxy, not in your workflow code.
  2. Build the app's state table with the per-order fields listed above, and lay it out as a review queue for planners. You should see a screen that lists orders by status, with exception reasons and approval details visible on each row.
  3. Add the agent so it runs only on the orders deterministic validation leaves over: orders with ambiguous item descriptions or inconsistencies the rules can't cleanly classify, where it drafts a plain-language summary of what's wrong and what it would do next instead of writing anything itself. You should see exception orders arrive in the queue with a drafted summary attached, while clean orders pass through without agent involvement.
  4. Set the workflow trigger as a scheduled poll, on a cadence you agree with your NetSuite admin, that pulls orders modified since the last successful run, runs deterministic validation (does every line item exist, does its quantity make sense against configured BOM and inventory records, do the subsidiary and location match), and marks each order processed to avoid reprocessing. You should see new orders appear in the app after each run, with each order processed only once.
  5. Test the approval and write path by having a planner approve and reject sample exceptions in the app or in Slack, then confirm that only approved orders lead to a POST that creates a work order, that item group quantity corrections go through a follow-up PATCH, and that retries are recorded. You should see every write, approval and retry logged in the app's audit trail against the right order.
  6. Roll out with permissions locked down: keep the NetSuite integration role at read on sales orders and items and write on work orders only, give planners role-based access to the review queue, and use the documented transform endpoints only for converting a work order to a work order issue or completion. You should see IT able to trace which connector made which call, under whose approval, without digging through NetSuite's own system notes.
Summarize what's wrong with this sales order, which line items fail the BOM or inventory check, and what you would do next. Do not write anything to NetSuite.

Why scoped credentials matter here

Scoped credentials work like a building key cut for one door. The integration role can read orders and items, but it can only write work orders, so even a bad decision can't touch anything else.

Only after a planner approves does that narrowly scoped NetSuite role permit the write. That write is a POST to create a work order, or the documented transform endpoints for converting it to a work order issue or completion.

The governance pattern

This is the same governance pattern covered in governed cross-system workflow automation and in auditable finance workflows. Three things sit between the agent's judgment and anything that touches a system of record:

  • Scoped credentials.
  • Role-based access.
  • An audit log.

Reason once, run forever

This is the mechanism behind "reason once, run forever" in this workflow. The agent reasons about how to classify an exception once, and that becomes part of the app's exception-handling logic.

Every later order with a similar pattern runs through code instead of a fresh round of model reasoning. Over time, the share of orders that need the agent should shrink as more patterns move into deterministic rules.

Before you go live

  • [ ] The Work Orders feature is enabled in your NetSuite account.
  • [ ] The integration uses OAuth 2.0 (or TBA) through an integration record, with credentials held in Major's credential proxy.
  • [ ] The integration role has read access on sales orders and items and write access on work orders only.
  • [ ] SuiteTax is enabled if your sales orders carry tax.
  • [ ] Field names were confirmed in your account's REST API Browser, including the lowercase record IDs.
  • [ ] The polling cadence was agreed with your NetSuite admin and checked against your account's governance limits.
  • [ ] Item group quantity, rate or amount corrections use a follow-up PATCH, not the initial POST.
  • [ ] No work order is written without a planner's approval, and every write, approval and retry shows in the audit trail.

Start building on Major

Build the sales-order-to-work-order handoff as a governed Major app: a custom NetSuite connector, a state table planners actually work from, and an agent that only touches the orders that need a human call.

Related articles

About the author

Ritvij Gautam is Head of Growth at Major.

Last reviewed November 7, 2026 by Ritvij Gautam.

Frequently asked questions

How do you integrate NetSuite with a manufacturing system?
Connect through NetSuite's SuiteTalk REST Web Services using OAuth 2.0 or token-based authentication. Read sales order and item records, map them to your account's BOM and inventory fields using the REST API Browser, and handle errors and retries in code. Keep write access scoped to the specific records the workflow needs.
Can NetSuite sales orders create manufacturing work orders?
Yes. SuiteTalk REST exposes a `workOrder` record you can create from validated sales order data, but the Work Orders feature must be enabled on your account first. Field availability and the order-to-work-order relationship vary by configuration, so don't assume every sales order should auto-release a work order without review.
Does NetSuite SuiteTalk REST support webhooks?
Oracle's public SuiteTalk REST documentation does not describe native webhooks for record changes. Event-driven integration instead relies on account-specific SuiteScript RESTlets or Workflow Action scripts, so scheduled polling is the more portable default unless your team already builds and maintains those scripts.
How can AI help with a NetSuite manufacturing integration?
Keep the repeatable work (reading orders, validating fields, writing work orders) in deterministic code. Reserve the AI agent for judgment calls, like summarizing why an order's item description doesn't match a configured BOM, and require a person to approve before any write happens.