I'd rather be the awkward third thing

I'm Dave Weiss, and I have done nothing but NetSuite work for twenty years.

Implementations, customizations, integrations — and then the long tail afterwards, which is the part nobody puts on a case study. A project gets signed off and the account keeps needing things: the process that changed, the report nobody can reproduce, the script written for a workflow the business stopped doing years ago and that everyone is now afraid to delete. Most of what I know came from that tail rather than from the launches.

Twenty years in a single system produces a specific kind of knowledge, and it isn't encyclopedic recall of the API. It's that you stop being surprised. You recognize the shape of a problem before the person describing it has finished, because you have watched it happen in eleven other accounts. You know which of the things that look hard are actually easy, and — more usefully — which of the things that look easy will consume two weeks.

That is the part that doesn't transfer to someone who learned NetSuite last year in order to sell an AI product into it.

Every company running NetSuite has a list of problems it decided not to solve. Not because the problem was unclear — because the quote came back at six figures and living with the spreadsheet was cheaper.

That calculation was correct when it was made. It is also out of date.

The cost of building software has moved, and it has moved most for the unglamorous parts. Sign-in, roles and permissions, an audit trail, deployment, environments, testing, an API — the scaffolding that used to consume the first two months of any project. When all of that already exists before anyone writes a feature, what's left to build is only the part that was ever specific to your problem.

So the threshold moved. Problems that sat just underneath the old one — worth solving, never worth six figures — are above the new one.

The other half of this is honesty about what's actually true, even when it costs me the sale. There's a version of this business that inflates urgency to close a deal — a deadline that doesn't really exist, a risk that isn't really there. I'd rather tell you the thing that talks you out of hiring me and be the person you call when something is genuinely wrong.

The application I spend most of my time developing, Program Manager, doesn't do anything for a NetSuite account directly. It builds the apps and tools that do.

You describe an application to it — what it's for, who uses it, what it has to keep track of. It works the idea into features, and the features into something that runs. What makes that fast isn't the code generation, which everyone has now. It's that every application it produces inherits the same wiring: AI API communication, single sign-on, roles and scoped permissions, an audit trail, revision history, media handling, deployment, release management, and an MCP interface an AI agent can drive as safely as a person can.

Two dozen of those capabilities arrive before a line of the actual product is written. So the work left is the part that's genuinely yours — the consignment rules, the fit-gap scoring, the script conversion — and that part is the only part I spend time on.

Two consequences worth knowing about:

An application can live inside NetSuite instead of beside it. When you define one, you choose whether it's built as a web application or as a SuiteApp — running on your data, under your roles, in the navigation your people already use. Not another system to log into.

The guardrails are in the wiring, not bolted on afterwards. Approval, audit and scoped access are inherited by everything, which means no application ends up shipping without them because a deadline got tight.

Nothing an AI produces in any of this is applied on its own authority. It proposes; a named human accepts or rejects; the decision is recorded as a distinct act. That is a property of the platform rather than a policy I promise to follow, which is the difference between a guardrail and a good intention.

In practice, across every engagement:

Nothing is written back to your systems on its own. Whatever the AI produces — a script conversion, a requirements document, a pricing rule — lands outside your system or in a NetSuite sandbox first, where you look at it and test it before anything happens.

Your approver accepts the work, not me. This one matters more than it sounds. If I both produced something and accepted it, your audit trail would record the vendor approving the vendor's own work — which is precisely the finding an IT controls review exists to catch. With someone in your organization on the acceptance, the same trail becomes evidence instead of a problem.

Anything that would change a live system gets verified against a sandbox first. Not because the tooling is untrustworthy, but because that is what you would require of any developer, and a tool shouldn't get an exemption a person wouldn't.

Approval only means something if the approver has time to read. Which is why I would rather a project ran slowly. Work arriving faster than anyone can review it doesn't make approval quick — it makes it ceremonial, and a ceremonial approval is worse than none, because it looks like control in the audit trail.