Skip to content

NetSuite context intelligence · Preflight

Before you change NetSuite, know what you’ll break.

Point SuiteContext at a field, script, or workflow in an account you didn’t build — and get a deterministic verdict on what depends on it, what conflicts, and what to check before you deploy.

Read-only · Deterministic — no LLM · Never trained on your data

Exhibit A · what a preflight looks like

The conflict catch

Two scripts writing one field on the same trigger — found by static analysis across every active deployment.

Graded by confidence

Confirmed, observed, inferred, unknown-risk. What we know, separated from what we can’t see.

Preflight report

№ 0042 · read-only

Proposed change: repurpose custbody_priority_code on Sales Order

  • ■ blockingCross-script write conflictConfirmed

    UE_set_priority.js and SL_order_sync.js both write this field on afterSubmit. Execution order unmanaged — last writer wins.

  • ▲ checkSaved-search dependencyObserved

    3 saved searches filter on this field; one feeds the nightly revenue report a controller reads every morning.

  • · noteWorkflow interactionInferred

    An active workflow transitions on the same record type; user-event scripts complete before its afterSubmit actions — verify the state it expects.

  • ▲ checkConfigured script orderUnknown-risk

    Not readable via any API. Confirm on the Scripted Records page before deploying.

Do not deploy yet

1 blocking · 2 checks · same input, same verdict — every run

Illustrative sample — labeled findings, graded by confidence

Honest about the gaps

When something isn’t readable via any API, the report says so — and tells you exactly where to look.

Deterministic

No model in the path. Same input, same verdict, every run — showable to a client.

“Who changed this, and why?”

System notes say what and when — never why, and never across the whole account at once.

“What breaks if I touch this field?”

There’s no native view of what depends on what. You find out in production, after the deploy.

“How do I onboard onto this?”

Mature accounts are tribal knowledge nobody wrote down. The person who built them left.

The catch nothing else surfaces

Two scripts write the same field on the same trigger. Which one wins?

In most accounts, script execution order is unmanaged and invisible — grouping rules silently override naive expectations, and the configured order isn’t readable via any API. So when two user-event scripts write the same field on the same trigger, last writer wins — and nobody chose the winner.

static analysis · script source

UE_set_priority.js · afterSubmit

rec.setValue('custbody_priority_code', score)

SL_order_sync.js · afterSubmit

rec.setValue('custbody_priority_code', extVal)

■ Both deployments active on Sales Order. Execution order unmanaged — last writer wins.

  • Found by reading the code, not guessing

    SuiteContext statically analyzes every script source against every active deployment — cross-script write collisions joined on record type and entry point. Not something you can eyeball across a few hundred files.

  • The bug that looks like a ghost

    These conflicts don’t error. They produce intermittent wrong values that pass UAT, then surface in month-end reports. Teams burn days on them because no tool points at the collision.

  • Verdict, not vibes

    You get the colliding scripts, the field, the trigger, and what to check — cited and repeatable. Field explorers show IDs. SuiteContext explains consequences.

The honesty model

We label what we know — and what we can’t see.

No tool can know everything about a NetSuite account, and the ones that pretend to are the ones that get you. Every SuiteContext finding carries one of four grades. That’s the difference between a senior consultant and a confident guess.

Confirmed

Read directly from the account: script source, deployments, field definitions, system notes.

Observed

Seen in structure or history — present and real, but its runtime behavior isn’t guaranteed.

Inferred

Follows from how NetSuite executes — entry-point grouping, script/workflow ordering rules — applied to your inventory.

Unknown-risk

A landmine no API exposes — like the configured Scripted Records order. We flag it and tell you exactly where to look.

The AI era

NetSuite’s MCP gives your AI access to your account. SuiteContext gives it judgment about your account.

Oracle’s free MCP, Copilot, and Cursor made agents able to read and change NetSuite — which makes a neutral, deterministic check more necessary, not less. Ask an LLM “what breaks if I change this field” and it improvises from raw rows, differently every run. We ride the MCP; we don’t compete with it.

Access — what the official MCP returns

> query: scripts on salesorder

rows: 47 · scriptdeployment · …

rows: custbody_priority_code · …

… 312 more rows. Your AI improvises from here.

Judgment — what SuiteContext returns

Conflict: 2 scripts write custbody_priority_code on afterSubmit.

Confirmed from source · execution order unmanaged — last writer wins · check the Scripted Records page before deploying.

Deterministic. Cited. The same answer every time.

How it works

A 30-minute checklist. Then minutes, not weeks.

The same read-only role + token setup every integration vendor asks for — no install in your account, nothing in the browser’s data path.

  1. Step 1 · Connect

    A read-only role you control

    Create a read-only role and token over NetSuite’s supported APIs (SuiteQL, SDF). Metadata and script structure — record values stay opt-in. Revoke in one click.

  2. Step 2 · Analyze

    Deterministic engine, no model

    Fixed rules, static analysis of script source, and encoded tribal knowledge — entry-point grouping, script/workflow interaction — run server-side. No LLM in the path.

  3. Step 3 · Preflight

    A verdict you can act on

    Dependencies, conflicts, risk flags, and what to check — graded Confirmed / Observed / Inferred / Unknown-risk. Export it as grounded, cited context for your own AI.

Why ERP teams can trust it

Your audit data is never sent to an AI — because it isn’t sent anywhere to be analyzed.

Everyone wants AI help with NetSuite. Nobody wants their ERP feeding a model. So the analysis is deterministic TypeScript end to end — and AI is something you opt into, with context that’s grounded and cited, never trained on.

  • Deterministic analysis

    Fixed rules, not a model. Same input, same verdict.

  • Never trained on your data

    Not for training, not for “improvement,” not ever.

  • Metadata-first

    Field IDs, types, script structure. Record values are opt-in; PII redacted.

  • Read-only, supported APIs

    A role you create and revoke. Nothing installed in your account.

  • Access you control

    Subscription key — stop paying, revoke, and it all goes dark.

  • Confidence labels on everything

    Confirmed, observed, inferred, unknown-risk.

Who it’s for

Built for the people who hold the account together.

Consultants & partners

“I just got a client account and need to understand it fast — without burning unbilled hours.”

Understand an unfamiliar account in the first session. Scope and quote engagements on evidence, and hand the client a risk map that sells the next phase.

Inheriting admins

“The last admin left. Nobody knows what half of this does.”

The documentation the last admin never wrote — grounded in what’s actually in the account, not what anyone remembers.

SuiteScript developers

“I need to change this script and I don’t know what I’ll break.”

Impact and conflict analysis before the deploy — plus grounded, cited context to hand your AI before it writes a line.

The honest map

Use the free tools. Then ask the question they can’t answer.

We position around the job, not against anyone. Here’s what each alternative is genuinely good at — and the job SuiteContext exists for.

What each alternative is good at, and where SuiteContext fits
AlternativeWhere SuiteContext fits
Governance suites (Strongpoint, Salto)Compliance, change management, full documentation.Different job: fast, self-serve preflight in minutes — at mid-market price, not a multi-week rollout.
Free field explorers & FlashlightField IDs, hidden fields, free dependency visibility.They depict; we interpret. Which scripts collide, what’s risky, what to check — graded by confidence.
Official NetSuite MCP · Copilot · CursorGiving your AI access, and generating SuiteScript fast.We supply the judgment layer they don’t: deterministic, cited verdicts about this account. We ride the MCP.
By hand (the current default)Free, fully flexible.Stop reverse-engineering accounts by hand. Minutes instead of days, and it catches what a human skims past.

Start here

Bring us one scary customization.

We’re pre-launch and building with design partners. Two ways in — one available this week, one that locks your price for life.

The founding teardown

$300one-time · if it doesn’t show you something you didn’t know, you don’t pay

Pick the field, script, or workflow you’re most afraid to touch. We hand-run the full Preflight on it and walk you through the findings live.

  • A written Preflight report — findings graded Confirmed / Observed / Inferred / Unknown-risk
  • The conflict catch: every script that writes your target, joined across deployments
  • A 30-minute walkthrough call with the founder
  • Collection via SDF export or a read-only role — nothing installed
  • Credited in full toward a founding subscription if you continue

Founding access · first 50 teams

$99/mo · per account, unlimited users

The automated product, as it ships to design partners: connect a read-only token, get the inventory, dependency maps, conflict catches, and risk audit in minutes.

  • Founding price grandfathered for life
  • Direct say in the roadmap
  • Priority onboarding when your account is supported
  • A build-in-public note every week or two

Indicative founding price — final plans set with design partners. No launch date promised; access and influence are.

Why I’m building this

“I’m a software engineer who’s spent five-plus years deep inside NetSuite — not just administering it, but understanding why it’s built the way it is. I’ve lost too many days reverse-engineering accounts I didn’t build. SuiteContext is the tool I kept wishing existed, and the teardown is me proving it on your account before asking you to believe anything.”

J

Jorge — founder, SuiteContext

Software engineer · 5+ years inside NetSuite

FAQ

The questions ERP teams ask first.

What access does SuiteContext need?

A read-only role and token over NetSuite’s own supported APIs (SuiteQL, SDF) — the same ~30-minute checklist Celigo or Boomi asks for. No install in your account. Metadata and script structure, not record values; revoke in one click. For a teardown, an SDF export or files you send work too.

Does my NetSuite data get sent to an AI?

No. The analysis is deterministic TypeScript — there is no model in the path, so your audit data is never sent to an AI because it isn’t sent anywhere to be analyzed. AI explanations are opt-in, off by default, grounded in the engine’s findings, cited, and never trained on your data.

Why not just use free Flashlight?

Use it — it’s great free documentation and dependency visibility. Flashlight depicts; SuiteContext interprets: which scripts collide, what’s risky, what to check, graded by confidence. Different job.

NetSuite has an official MCP now. My AI can already read the account.

Exactly — and we ride it. The MCP gives your AI access: raw records and SuiteQL. It doesn’t give it judgment: ask “what breaks if I change this field” and it improvises from raw rows, differently every run. We return a deterministic, cited verdict — the same answer every time.

Why not point Claude at an SDF export?

Great for one script. Account-level questions — cross-script write collisions across every deployment — need static analysis, and an LLM’s answer changes every run. Ours is repeatable and showable to a client.

Can you really know everything in my account?

No — and we don’t pretend to. Findings are labeled Confirmed, Observed, Inferred, or Unknown-risk, and the report tells you exactly where to verify the things no API exposes. That honesty is the point.

When does the product launch, and what will it cost?

We’re building with founding design partners and promise access and influence, not a date. Teardowns run now at $300. Founding subscriptions start at $99/mo per account (unlimited users), grandfathered for life for the first 50 teams.

The next change someone deploys blind could be yours.

Bring one scary customization. We’ll run the Preflight by hand and show you exactly what SuiteContext would catch — for $300, credited if you stay.