Why is your ERP or CRM still a black box?

Open the black box

Painless change management for core systems.

Splotch is the knowledge graph on top of your core systems.

Coming soon

Splotch is the knowledge graph on top of your core systems, starting with NetSuite ERP. The graph provides the foundation for both humans and agents to trust when it's time to make a change.

See how it works

Companies are held hostage by their core systems.

68%

Of ERP implementations fail to meet their objectives. (100% of them take too long.)

The system is a black box.

The people who own it can't see the components, rules and automations that actually run the business, so every change starts blind.

That makes change slow, expensive and risky.

Teams spend more time confirming nothing will break than they do making the actual fix, limiting their ability to implement strategic business goals quickly and effectively.

And there's no reliable source of truth.

When a change ships, there is no permanent record of what happened or why. The next change starts with even more complexity and less context.

A platform to map and execute system change.

Splotch sits across your core systems, shows you how your system currently works, helps you identify where it doesn't and turns business goals into system changes with confidence, always keeping a record of what changed and why.

Discover

Our ingestion engine opens the black box, mapping your business processes and every customization visually, then indexing each component to documentation that anyone in the business can read (not just the people who built it).

Build

It creates a “diff” between what your system does now and what you want it to do, producing a change plan that's already scoped and sequenced to account for dependencies, ready for deployment.

Govern

It gives you the governance you never had, a full version history for the system itself, so you always know what changed, who approved it, and how to undo it.

One graph underneath everything.

Splotch builds a durable, current map of your systems, then uses it to show what a change touches and to keep the record of what changed.

Splotch builds a durable, current map of your systems and the business logic layered on top of them, giving both humans and agents a trusted layer to act on.

Splotch map of a NetSuite account: the Credit & Collections Management cluster with its scripts, records and saved searches, and their dependencies drawn as lines

Without a knowledge graph, every change, whether an agent makes it or a person does, risks a downstream impact nobody saw coming. Splotch shows you the blast radius before anything moves. You see what the change touches directly, and everything further out that depends on it.

A Splotch workstream mid-audit: the plan's stages, what Splotch found in the account, and the choices it offers before changing anything

Splotch becomes that record, tracking every change, what it touched, who signed off, and why. That memory survives long after someone leaves the company, and it means your team can try things it would never have risked before, because every change can be traced, versioned, and rolled back if it doesn't work.

Splotch version history for a NetSuite workflow: each deployment, who made it, drift observed, and a roll back to previous version button

Claude and GitHub weren't built to see the whole system.

Splotch works directly with Claude, GitHub, and whatever else is already in your stack. The knowledge graph fills in the relationships between components that those tools can't see on their own, then uses this analysis to make sure that your tools respect your system's schema and address every affected component of any changes they make. Inside the Splotch interface, you get a human-friendly graph that helps you follow along with what the AI is doing, so you can visualize, govern, and collaborate on everything that's changing. It's an agentic approach to ERP change, with a human approving every step.

Here's what's missing if you're working in your stack alone, and what changes once the knowledge graph sits underneath it.

Your stack todayWith Splotch

Business logicNot visibleMapped & current

Dependencies & blast radiusNot visibleShown upfront

Edit configurationsRisky guessworkImpact previewed first

Create & edit customizationsManual or ad hocGuided, with full context

VersioningSpotty or missingAlways versioned

Deployment approvals & governanceNo paper trailLogged & traceable

Customization & process documentationNoneAuto-generated

This is how ERPs should work.

Andrew Skidmore

Built for the people who own the change.

When you own your systems, you can turn business goals into system changes.

You're the one who answers for a change. Splotch gives you a live map of your ERP, so you can see what a change will touch before you approve it, and a record of what happened once it's done. Splotch provides the map and the process to manage change well.

You're responsible for the system, but you can't see inside it. Every change request turns into a meeting because the map of what your ERP actually does lives in someone's head, if it lives anywhere at all.

Half the work, twice the sales.

Making changes is not hard. Making changes safely is hard. When you sit down for your discovery meeting with a client, Splotch has already scoped the changes they want, and uncovered adjacent work that needs to be done. It plugs straight into the stack you already deliver on, so you don't have to change how you work to use it.

Before you can propose a change, you have to reconstruct what the system already does. That reconstruction eats hours on every engagement, and both you and your customer end up paying for it.