ERP extensions and integrations,without touching the core.

Every sync is tested end to end against a sandbox, and a person approves each write to your ERP.

We build the apps your ERP doesn't do well (quoting, scheduling, customer portals, approvals, B2B ordering and the syncs between them) on Steer by Pento, our own platform. They run beside NetSuite, SAP, Odoo or Dynamics and talk to it through its API, so the ERP keeps the books and its upgrades stay simple. After a free audit, an integration with a clear scope gets a fixed price, and a Pento team can take on a longer run of apps.
Illustrative Steer project around an ERP. The ERP stays the system of record and its core is untouched. A wholesale quoting app runs beside it and syncs inventory, customers and orders through the ERP's API, against a sandbox. The goal 'Quote approvals with credit limit check' is built, passes 38 integration tests and review, waits for a person because it writes to the ERP, is approved and merged, and is verified once CI is green on main.

Nothing changes inside the ERP

Satellite apps live in their own repository and reach the ERP through its API with scoped credentials. Nothing changes inside the ERP, so its upgrade path stays as it is.

A person approves every write

Reads from the ERP flow freely. A change that writes to it is an external change under the merge policy, so a person approves it before it merges.

We run it on our own ERP

We are replacing our own ERP with Steer, module by module: invoicing, projects and allocation moved first, each piece specced, evidenced and approved before the next.

What are ERP extensions and integrations?

An ERP extension adds a workflow your ERP doesn't cover, like quoting, scheduling, approvals or a customer portal, and an ERP integration keeps data such as orders, inventory and customers in sync between the ERP and the systems around it. Pento builds both as satellite apps: separate applications that read from and write to NetSuite, SAP, Odoo or Dynamics through their APIs, while the ERP stays the system of record. On Steer, each app is specced as goals with acceptance criteria, built by AI agents in isolated sandboxes and shipped with integration tests as evidence.
An ERP project, with the work split up
  1. 01Discover
    • YouShow us the spreadsheets and email threads
    • Forward deployed engineersMap the records, fields and APIs the app needs
    • Steer + AI agentsKeep the map in the project's Context, versioned
  2. 02Spec
    • YouApprove the scope before any code exists
    • Forward deployed engineersWrite each feature as a goal with criteria
  3. 03Build
    • YouGrant scoped credentials to a sandbox
    • Steer + AI agentsBuild against the ERP's sandbox, not your books
  4. 04Check
    • Forward deployed engineersJudge each pull request against the spec
    • Steer + AI agentsRun integration tests against the ERP sandbox
    • Review + checksAn independent model reviews every pull request
  5. 05Merge
    • YouApprove each change that writes to the ERP
    • Steer + AI agentsClass every ERP write as an external change
    • Review + checksMerge the rest under the autonomy level you set
  6. 06Maintain
    • YouOwn the app, its tests and its history
    • Forward deployed engineersKeep it running, or work your backlog as a team
    • Review + checksIntegration tests catch an upgrade's API changes

The ERP keeps the books the whole time, and the next app starts again at Discover.

Why ERP work stalls

The ERP keeps the books. The work around it lives in spreadsheets.

Customizing the ERP's core is slow, and it makes every upgrade harder. Waiting for the vendor means waiting on a roadmap you don't control. So quoting, approvals and scheduling end up in spreadsheets and email threads. We build those pieces as satellite apps around the ERP, one bounded project at a time.
Customization

Changing the ERP's core

The usual quoteCore customization · consultant hours · upgrades that break it
On SteerSatellite app · the ERP's API · core untouched

Customizations inside the ERP get harder to carry with every upgrade. A satellite app lives in your own repository and talks to the ERP through its API, so the core and its upgrade path stay as they are.

See internal tools →
Vendor roadmap

Waiting on the vendor's next release

The usual quoteFeature request · next release, maybe · their priorities
On SteerYour workflow · priced before any code

The quoting rules, credit checks and approval chains that make your business different are rarely on a vendor's roadmap. We build them for your process, and a piece with a clear scope gets a fixed price before any code exists.

See how we price →
Integrations

The sync nobody owns

The usual quoteNightly CSV export · brittle scripts · a customer finds the gap
On SteerEvent sync · integration tests · results on every PR

Orders, inventory and customers move between the ERP and the systems around it as events, tested end to end against a sandbox. Every pull request shows the tests that ran, so you can check that a sync works instead of hoping it does.

See the evidence →

✳ We build around NetSuite, SAP, Odoo, Microsoft Dynamics and other ERPs with an API. The free audit shows which parts of yours are worth extending first.

How it runs on Steer

Satellite apps, built next to the ERP, not inside it.

Each app is its own project on Steer, with its own spec, its own repository and the ERP's API as the contract.
  1. 01

    Discovery maps the ERP and its edges

    A discovery session documents the ERP records, fields and APIs the app needs, plus the spreadsheets and email threads it replaces. All of it goes into the project's Context, versioned.

  2. 02

    Goals with integration criteria

    Each feature becomes a goal with acceptance criteria, like “quotes over the customer's credit limit route to finance” or “approved quotes become sales orders in the ERP.”

  3. 03

    Agents build against a sandbox

    Claude Code agents build in fresh isolated sandboxes, against the ERP's sandbox or a test instance with scoped credentials, not your production books.

  4. 04

    Integration tests are the evidence

    An independent review model and a forward deployed engineer check each pull request against the spec, and the evidence report shows the integration tests that ran against the ERP.

Illustrative Steer session. An agent reads the quote approvals spec, edits the credit check and the sales order code, passes 38 integration tests against the ERP sandbox and the review, and stops because the change writes to the ERP, so a person approves it before it merges.
Merge policy

Reads flow. Writes to the ERP ask a person.

You set the project's autonomy level. Depending on the level, low-risk changes can merge on a green review and CI, but a change that writes to an external system, your ERP included, waits for a person at every level.
  • External changes always ask

    A pull request that creates or updates records in the ERP is classed as an external change, so a person on your team or ours approves it before it merges.

  • Every decision is on the record

    Who approved what, when and on which evidence is kept in the project's audit trail, which your team can read and export.

Merge policy · wholesale quoting appIllustrative
Autonomy level
Changes waitingmin 0.80
  • Quote form shows the credit limitMerge
    Risk class Low · safe 0.95because low risk
  • Read stock levels from the ERPMerge
    Risk class Low · safe 0.91because low risk
  • Store the quote approval historyAsk a person
    Risk class Data · safe 0.87because data risk
  • Backfill open quotesAsk a person
    Risk class Data · safe 0.64because data risk
  • Approved quotes become ERP sales ordersAsk a person
    Risk class External · safe 0.93because external risk

Gated: 2 merge3 ask a person0 report

Illustrative Steer merge policy. Pick an autonomy level: Observe, Propose, Gated or Autonomous. Sample changes with a risk class (Low, Data or External) and a safe-to-merge score show whether each one merges, asks a person, or is only reported. External changes always ask a person, and a change rated under 0.80 asks even under Autonomous.
What you get

What every ERP project on Steer includes

Whether it's one integration or a full satellite app, the ERP stays the system of record and every pull request carries its test results.

Every ERP extension or integration includes:

A free audit of the ERP, the work done by hand around it and the first piece worth building
A written quote before any code exists: a fixed price for an integration with a clear scope, or a monthly fee for a team
A satellite app in your GitHub, connected through the ERP's API, with no changes to its core
Integration tests against an ERP sandbox, run on every pull request and kept in your repository
A merge policy where every change that writes to the ERP waits for a person
A seat in the Steer workspace for your team from day one
Stories

We're replacing our own ERP the same way.

Before we build around your ERP, we did it to ours. Client stories are anonymized, because their systems are theirs.
Case studies →

3 modules

Our own ERP, replaced module by module

We run Steer on ourselves first: invoicing, projects and allocation moved off our old system one bounded piece at a time, each specced, evidenced and approved before the next.

8 days

An 8-day MCP integration into a client's CRM

A custom agent workflow wired into systems that were never designed for agents, with end-to-end behavioral tests included.

How we engage

Two ways to work with us. Neither is hourly.

Both start with the free audit, which sets the scope and the shape of the team.
Monthly · set by pod size

A team we build for you

Pento forms a pod of forward deployed engineers for your work, for example four engineers or whatever machine learning, software, DevOps and MLOps talent you need. They work with Steer alongside, and the fee depends on the pod's size.

Best for
An ongoing roadmap, a large project such as a migration, or scope that will change as you learn
Who carries the risk
Shared: you set the priorities, and we own how the work is built and the evidence that it's done
Talk to us about a team
One price · a clear scope

A fixed-price project

For integrations and smaller projects you can scope up front. After the free audit we write the scope with you as goals with acceptance criteria and fix the price. Evidence on every pull request shows when each goal is done.

Best for
Integrations and smaller projects with a clear scope. First projects ship in weeks
Who carries the risk
Pento: the price is fixed, so an overrun is ours to absorb
Get a fixed-price quote
How pricing works →
FAQ

Questions about ERP extensions and integrations

Not covered here? Bring the question to a discovery call. An engineer reads every request.

Book a discovery call

Contact us

Build what your ERP doesn't do

Tell us which ERP you run and what lives in spreadsheets around it. The audit is free: we map the workflows, the APIs and the first app worth building, and quote it, at a fixed price when the scope is clear. An engineer reads every request.