What is a NetSuite transaction? GL impact, posting rules, and the full transaction lifecycle

What is a NetSuite transaction?

In NetSuite, a transaction is any record that creates a financial or operational event: including sales orders, purchase orders, work orders, item receipts, fulfillments, invoices, and assembly builds. Most NetSuite transactions are non-posting when created, meaning they have no GL impact until a downstream trigger (fulfillment, receipt, or completion) is hit.

The four key transaction types covered in this guide:

• Service Orders (order-to-cash)
• Manufacturing and Work Orders
• Assembly Builds
• Item order execution (procure-to-pay)

This guide from Charted, a leader in intelligent AP automation built natively for NetSuite, covers the core transaction lifecycle in NetSuite’s standard and manufacturing modules. Specific behavior may vary based on your enabled features, costing method, and configuration. It goes through how transactions move through NetSuite, what happens to inventory along the way, and how it all connects to your financial records.

Introduction

If you’re working with NetSuite, or in the process of evaluating it, one of the most important things to understand is how transactions flow through the system. A “transaction” in NetSuite isn’t just an invoice. It’s any record that creates a financial or operational event: a sales order, a purchase order, a work order, an item receipt, a fulfillment, an assembly build. They’re all transactions, and they’re all connected (and if they’re not connected, then that’s a whole separate conversation).

This guide walks through the full lifecycle of four key transaction types:

1. Service Orders (Sales Order → Fulfillment → Invoice → Payment)
2. Manufacturing and Work Orders (Planning → Production → Completion → Invoice)
3. Assembly Builds (Simple BOM-based assembly without full manufacturing)
4. Item Order Execution (Purchase Order → Receipt → Bill → Payment)

For each, we’ll cover what the transaction does, how inventory is affected, and what exactly hits the general ledger.

Understanding NetSuite’s transaction philosophy

Before diving into each type, there’s one principal worth internalizing: most transactions in NetSuite are non-posting until a specific trigger is hit.

A sales order, for example, has zero accounting impact when it’s created. It records a commitment, allocates inventory, and drives fulfillment workflows; nothing posts to your books until goods ship or services are completed. This is intentional, as it separates the operational record from the financial event.

Here’s a quick reference to understand when key transactions post to the GL:

Transaction	Posts to GL	When
Sales Order	No	– (operational only)
Item Fulfillment	Yes	When shipment is confirmed
Invoice	Yes	When created (increased A/R)
Customer Payment	Yes	When applied
Purchase Order	No	– (operational only)
Item Receipt	Yes	Increases Inventory Asset & Accrued Purchases
Vendor Bill	Yes	Moves from Accrued Purchases to A/P
Work Orders	No	– (operational only)
Work Order Completion	Yes	Moves WIP to Finished Goods
Assembly Build	Yes	Consumes components, added finished assembly

Section 1: Service Orders: The Order-to-Cash cycle

A Service Order in NetSuite is the standard sales cycle: a customer wants something, you commit to deliver it, you deliver it, you invoice them, and you collect payment. The backbone is the Sales Order, which then spawns fulfillment and billing transactions.

Step 1: Sales Order created (pending fulfillment)

A sales order records your commitment to sell items or services to a customer. At this stage:

• No GL impact—the order is non-posting.
• Inventory is soft-allocated (committed but not yet reduced).
• The order status is Pending Fulfillment.
• Available inventory drops (committed quantity increases), but on-hand inventory does not change.

Navigation: Transactions → Sales → Enter Sales Orders

Sales Order status flow: Pending Approval → Pending Fulfillment → Partially Fulfilled → Fulfilled → Partially Billed → Billed/Invoiced

Step 2: Approval (optional but recommended)

If your account uses workflow-based approvals, the order moves through an approval queue before it can be fulfilled. Orders with status Pending Approval cannot be fulfilled or billed.

Step 3: Item Fulfillment (inventory decreases here)

The Item Fulfillment is the transaction that officially records the shipment of goods. This is where inventory actually moves.

Pick, Pack, Ship (with Advanced Shipping enabled): If you use the Advanced Shipping feature, the fulfillment process breaks into three discrete steps:

1. Pick: Items are picked from the warehouse bins.
2. Pack: Items are packed for shipment.
3. Ship: Shipment is confirmed, Item Fulfillment record is created.

Each step updates the order status and creates operational records. The inventory impact (COGS debit, Inventory credit) happens at the ship step.

Navigation: Transactions → Sales → Fulfill Orders

Step 4: Invoice created → AR posted

Once the order is fulfilled, you bill the customer by creating an Invoice (or a CashSale for immediate-pay customers).

With Advanced Shipping enabled, the fulfillment and invoice are separate transactions. Without it, invoicing happens automatically at fulfillment.

Navigation: Transactions → Sales → Bill Sales Orders

Step 5: Customer Payment (AR Cleared)

Complete Service Order flow

[Sales Order Created]

        ↓ (inventory committed, no GL impact)

[Approval]

        ↓

[Item Fulfillment / Pick-Pack-Ship]

        ↓ (GL: Debit COGS / Credit Inventory)

[Invoice Generated]

        ↓ (GL: Debit A/R / Credit Revenue)

[Customer Payment Applied]

        ↓ (GL: Debit Bank / Credit A/R)

[Order Closed]

Section 2: Manufacturing Orders (work orders)

A work order is the instruction to manufacture something. It is the central record driving material consumption, production tracking, and cost accumulation in NetSuite manufacturing.

Important: Full work order management requires the Manufacturing module (a paid add-on). Basic assembly production is available through Assembly Builds (see Section 3 to learn more about Assembly Builds).

Step 1: Work order created (planning)

Work orders can originate from multiple sources:

• Manually by a production planner.
• From a Sales Order (make-to-order: a customer ordered the item).
• From MRP (Material Requirements Planning, based on demand/reorder points).
• From planned orders converted to firmed work orders.

When created, NetSuite automatically:

• Explodes the Bill of Materials (BOM), listing every required component and quantity.
• Checks component availability against current stock.
• Calculates expected completion date based on routing and lead times.

Work order types include:

Type	Description
Standard	Produce a quantity for stock (make-to-stock)
Make-to-Order	Linked to a specific sales order
Make-to-Stock	Driven by forecast or reorder points
Disassembly	Breaks a finished assembly back into components

Step 2: BOM explosion & component management

The work order reads the BOM and calculates all required component quantities scaled to the production quantity.

Example: BOM for “Widget A” requires: 2× Steel Plate, 4× Bolt M6, 1× Motor Unit Work Order for 100× Widget A therefore requires: 200 Steel Plates, 400 Bolts M6, 100 Motor Units

Component strategies:

• Reserve inventory: allocate existing stock so other transactions can’t consume it.
• Back-flush: don’t reserve upfront; consume components automatically at completion based on BOM quantities.
• Manual issuance: issue components to the work order as they become available (most control).

Step 3: Release (work begins)

Releasing the work order signals to the production floor manufacturing can start. Released orders appear on shop floor dashboards and production schedules.

Status flow:

Planned → Released → In Process → Built → Closed

Step 4: Component issuance → first inventory impact

As production begins, components are issued from raw materials inventory to the work order.

Step 5: Work order completion → WIP moves to Finished Goods

When finished goods come off the production line, record a work order Completion for the quantity produced.

Step 6: Scrap and variance handling

Manufacturing isn’t perfect. Some of the offsets that need to be recorded include:

• Component scrap: damaged material goes to a Scrap Expense account (not into the finished good cost).
• Yield loss: if 100 items were planned but only 95 were produced, the 5 lost units’ WIP cost posts to a Yield Loss account.
• Production variances: actual vs. standard cost differences are posted to variance accounts at close.

Step 7: Work order closed

Once all quantities are completed (or cancelled), the work order is closed with the following actions taking place:

• Remaining WIP balances are written off to variance accounts.
• Component allocations are released.
• The work order becomes non-editable.

Step 8: Invoicing (make-to-order)

For make-to-order work orders linked to a sales order, completion triggers the fulfillment and billing cycle as described in Section 1.

Complete manufacturing order flow

[Work Order Created (Manual / MRP / Sales Order)]

        ↓ (BOM exploded, components checked, no GL impact)

[Work Order Released]

        ↓

[Component Issuance]

        ↓ (GL: Debit WIP / Credit Raw Materials)

[Labor Recording (per routing step)]

        ↓ (GL: Debit WIP / Credit Labor Payable)

[Work Order Completion]

        ↓ (GL: Debit Finished Goods / Credit WIP)

[Scrap / Variance Posted]

        ↓

[Work Order Closed]

        ↓ (if make-to-order → triggers Item Fulfillment → Invoice → Payment)

Section 3: Assembly Builds

An Assembly Build is NetSuite’s simpler, single-step alternative to full work orders. It’s available in the base NetSuite license (no Manufacturing module required).

Think of it as: select the finished item, enter the quantity to build, and NetSuite consumes the components and adds the finished assembly to inventory, all in one step.

When to use Assembly builds vs. Work orders

	Assembly build	Work order
License required	Base NetSuite	Manufacturing module
Routing / multi-step	No	Yes
WIP tracking	No	Yes
Labor recording	No	Yes
Partial completions	No	Yes
Scheduling	No	Yes
Best for:	Kitting, light assembly, complex manufacturing

The Assembly Build transaction

Navigation: Transactions → Manufacturing → Build Assemblies

1. Select the assembly item
2. Enter the quantity to build
3. NetSuite reads the BOM and verifies component availability
4. Save; components are consumed and finished assemblies are added to inventory

Disassembly

Assembly Builds can be run in reverse to disassemble a finished item back into components; useful for rework, recycling, or inventory rebalancing. The BOM runs backwards: the finished assembly is consumed, and components are returned to inventory.

Section 4: Item Order Execution: The purchase-to-pay cycle

Item Order Execution covers how you acquire inventory from vendors: from raising a purchase order, through receiving goods into stock, to paying the vendor. This is the procure-to-pay cycle.

Step 1: Purchase Order created (no GL impact)

A Purchase Order (PO) is your commitment to buy from a vendor. Like a sales order, it has no GL impact when created, as it is non-posting.

What happens at PO creation:

• A formal record is created for the vendor.
• Items are flagged as “on order” (visible in inventory reports).
• Approval routing can be enforced before the PO is sent to the vendor.

Navigation: Transactions → Purchases → Enter Purchase Orders

Step 2: Item Receipt (inventory increases here)

When the vendor delivers your goods, you record an Item Receipt against the open PO. This is the critical moment when inventory physically (and financially) enters your warehouse.

Navigation: Transactions → Purchases → Receive Orders

After receiving:

• PO status moves to Pending Billing.
• Items are immediately available in inventory.
• Items can be automatically allocated to open sales orders, backorders, or production builds.

Step 3: Vendor bill created →AP posted

When the vendor’s invoice arrives, you record a Vendor Bill against the item receipt. This is when Accounts Payable is formally recorded.

Navigation: Transactions → Payables → Enter Bills (or Bill from the PO)

Step 4: Vendor bill variances (when quantities or prices differ)

In practice, the PO price, received quantity, and vendor invoice amount don’t always match. NetSuite handles this through Vendor bill variances:

• Quantity variance: received more or fewer units than ordered.
• Price variance: vendor billed at a different price than the PO.
• Exchange rate variance: for multi-currency POs.

Variances post to dedicated variance accounts (set on the item record), keeping your inventory costing clean.

Step 5: Vendor payment →AP cleared

When you pay the vendor:

Complete item order execution flow

[Purchase Order created]

        ↓ (items flagged “on order,” no GL impact)

[Vendor Approval / PO Sent to Vendor]

        ↓

[Item Receipt Recorded]

        ↓ (GL: Debit Inventory / Credit Accrued Purchases)

        ↓ (on-hand quantity increases immediately)

[Vendor Bill Created]

        ↓ (GL: Debit Accrued Purchases / Credit A/P)

[Vendor Bill Variances Posted (if any)]

        ↓ (GL: Variance accounts adjusted)

[Vendor Payment Made]

        ↓ (GL: Debit A/P / Credit Bank)

[PO closed]

Inventory impact summary at a glance

Transaction	Inventory effect	GL account movement
Sales Order Created	Soft commit (no physical change)	None
Item Fulfillment	Decreases on-hand	Debit COGS/Credit Inventory
Purchase Order	Increases “on order” quantity	None
Item Reciept	Increases on-hand	Debit Inventory/Credit Accrued Purchases
Assembly Build	Components decrease, finished good increases	Debit Assembly/Credit Component Inventories
Word Order Component Issuance	Components decrease	Debit WIP/Credit Raw Materials
Work Order Completion	Finished goods increase	Debit Finished Goods/Credit WIP
Customer Return (RMA)	Increases on-hand	Debit Inventory/Credit COGS
Vendor Return	Decreases on-hand	Debit AP or Accrued Purchases/Credit Inventory

Key concepts to know

Costing methods

NetSuite calculates inventory cost using one of these methods, set per item:

• Average Cost: the default; COGS = average of all units in stock.
• FIFO: (First In, First Out) oldest units sold first.
• LIFO: (Last In, First Out) newest units sold first.
• Standard Cost: a pre-set expected cost; variances are posted separately.
• Specific Identification: cost tracked per individual lot or serial number.

The costing method determines what gets debited to COGS on every fulfillment and assembly transaction.

Lot and serial tracking

For regulated industries or high-value items, NetSuite tracks individual units by lot number or serial number. These flow through every transaction—receipts, builds, fulfillments—giving full traceability from supplier to customer.

Multi-location inventory

With the Advanced Inventory module, inventory is tracked by location. A transfer order moves stock between locations, creating a two-sided inventory transaction:

Debit: Destination Location Inventory

Credit: Source Location Inventory

Non-posting transactions

Remember: Sales Orders, Purchase Orders, and Work Orders are non-posting. They are operational commitments that drive workflows but have no direct GL impact until a downstream transaction (fulfillment, receipt, completion) is triggered.

Putting it all together: How the transaction cycles interconnect

In a manufacturing company, these cycles often interlock in a single chain:

1. A Sales Order is placed for a finished product.
2. The sales order triggers a Work Order (make-to-order).
3. The work order’s BOM reveals a component shortage, triggering a Purchase Order.
4. The PO is received via an Item Receipt (inventory increases).
5. Components are issued to the Work Order (inventory shifts to the WIP).
6. Production completes and Finished Goods are received from the WIP.
7. The finished goods are fulfilled against the Sales Order (inventory decreases).
8. An Invoice is generated and the customer pays.
9. The Vendor Bill is matched and paid.

Every step in this chain is a transaction in NetSuite, and every transaction either moves inventory, posts to the GL, or both. The power of a properly configured NetSuite implementation is that all of this flows automatically, from demand signal to cash receipt, with a complete audit trail at every step.

Final tips for working with NetSuite transactions

1. Don’t skip transaction steps. Jumping from a work order straight to “in process” bypasses the release checkpoint. The release gate exists to prevent the starting of work that can’t be completed due to material or capacity constraints.

2. Close work orders promptly. Open work orders with remaining WIP balances distort inventory valuation. If a work order won’t be completed, cancel the remaining quantity and close it.

3. Match bills to receipts. Enable “Match Bill to Receipt” on purchase order lines. This ensures variance accounts are populated correctly and simplifies reconciliation.

4. Understand your costing method. Every fulfillment and build transaction posts a cost to the GL based on your costing method. Errors in item setup (wrong costing method, wrong cost) are hard to fix after the fact.

5. Use the GL impact view. Every posting transaction in NetSuite has a “GL impact” tab showing exactly which accounts were debited and credited. This is your best debugging tool when something looks off in the books.

6. Leverage saved searches. NetSuite’s transaction reporting can feel overwhelming. Saved searches across transaction types (e.g., “all open work orders with WIP > $0”, “items received but not billed”) are essential operational tools.

Frequently asked
questions