Choosing the Right Vendor

Who’s actually on the GP+Shopify managed integration shortlist — and how do I evaluate them?

Three categories of vendors come up in almost every GP+Shopify evaluation. Understanding what each one actually does — not what they claim — is where the shortlist sorts itself.

  1. Native GP Module Vendors
    • Installs directly inside the GP environment and reads GP’s data layer natively
    • Strong on the GP side — that part of the claim is accurate
    • The gap: the Shopify side runs on an API that changes quarterly, and “native GP module” says nothing about who handles that
    • When Shopify deprecates an API version, updating the connector is either a support request or your IT team’s project
    • The pattern: works well for two or three years, then a Shopify update lands when the person who managed it has moved on
  2. Self-Configure iPaaS Platforms
    • Generic integration infrastructure with pre-built GP connectors you configure yourself
    • Your team or a partner builds the GP-specific logic — Price Levels, Dexterity fields, multi-warehouse routing
    • Whoever builds that configuration owns it indefinitely
    • The pattern: when GP or Shopify changes something the configuration depends on, reconfiguring is your team’s job, not the platform’s
  3. Managed Integration — i95Dev Connect
    • Purpose-built for GP-Shopify — i95Dev configures the integration and owns both update surfaces
    • When Shopify’s API changes, i95Dev updates the connector. When GP releases a new version, i95Dev handles the fix.
    • For engineering teams that want direct code ownership post-go-live, i95Dev also builds the integration and hands it off — same GP expertise, your team operates from there
    • The trade-off: on the fully managed model, configuration changes go through i95Dev rather than your team directly — that’s the model, and it’s why your team isn’t debugging middleware on a Friday night

The question to hold through every vendor conversation: when something changes on either side of the integration after go-live, who does the work? If the answer is anything other than “we do, as part of what you’re paying,” the ownership model is different from what the pitch implies.

How do I tell a real answer from a rehearsed one?

A rehearsed answer is fluent and general. It sounds confident because it’s been said many times, not because it’s specific to you.

A real answer gets more specific when you push. A vendor who’s actually done this starts naming things — table types, common conflict patterns, what they typically find in a GP instance that looks like yours.

The tell isn’t confidence. It’s what happens on the follow-up.

What you askRehearsed answerReal answer
“Do you handle GP Price Levels?”“Yes, we support customer-specific pricing”“We read from the SOP and IV tables — here’s the field path for a B2B customer’s contract price in Shopify”
“Do you handle Dexterity customizations?”“Yes, we handle custom GP environments”“We scope your specific modifications before building — here’s what that process produces”
“Do you manage Shopify API updates?”“Yes, we stay current with Shopify”“We’re on , updated , here’s our timeline relative to Shopify’s published sunset”

Push every answer with: “Can you walk me through that specifically for our setup?” What happens next tells you everything.

What proof should I actually ask for — beyond what vendors claim?

Three things a vendor can’t talk their way around.

  1. A reference who came from a failed integration — not a first-timer
    • A first-time reference tells you the vendor can execute a clean implementation
    • A reference who switched from something that broke tells you whether this vendor solves the problem you’re trying to prevent
    • Ask specifically: “Can we speak with a customer who had a prior integration fail — and chose you as the replacement?”
  2. A documented example of a GP-to-BC migration they’ve completed
    • Not “we support BC” — a specific customer, before and after
    • Ask: “Can you show us what the migration looked like for a GP+Shopify customer who moved to BC+Shopify?”
    • If they can’t produce a specific example, their BC continuity claim is untested — factor that into your timeline risk
  3. A sample of what their pre-build Dexterity scoping produces
    • A real scoping process produces a real artifact — a mapping document, a scoping output, something you can review before signing
    • A process that’s just a conversation during implementation produces nothing you can evaluate upfront
    • Ask to see a redacted sample from a past customer

At i95Dev, we can produce all three. Ask us directly.

What does this actually cost across all three approaches?

Most buyers compare monthly fees. The real comparison is three-year total cost — including implementation, maintenance, and every reconfiguration event along the way.

ApproachYear 1Annual after3-year TCO
Managed — i95Dev Connect$10K–$50K$10K–$30K$30K–$110K
iPaaS$20K–$60K$18K–$48K$75K–$200K
Custom build$75K–$250K20–30% of build$105K–$400K+

What the table doesn’t show:

  • Custom build: when the developer who built it leaves, the clock resets. Rebuilding institutional knowledge isn’t in the TCO number.
  • iPaaS: every Dexterity customization your team configures is a maintenance event you own forever. The platform fee is fixed. Your configuration cost isn’t.
  • i95Dev Connect: Year 1 cost scales with GP customization complexity — more Dexterity modifications means more upfront scoping, but a lower ongoing cost because they’re designed around before go-live, not discovered after.

The lowest sticker price is almost never the lowest three-year cost. The variable is who owns the maintenance — and how many unplanned events that produces.

How do I make the internal case — and what is this actually costing us right now?

Finance will ask one question: what is this problem costing us today, and what does integration change?

Most IT Directors and ops leads know the answer intuitively — but can’t put a number on it fast enough to win a budget conversation. Here’s the framework Finance is actually asking for.

The real cost of manual integration has three parts

  1. Direct labor
    • Hours per week manually entering orders from Shopify into GP
    • Hours per week reconciling inventory discrepancies between the two systems
    • Hours per month on exception handling when something doesn’t match
    • Multiply by the fully-loaded hourly cost of the team doing it
  2. Revenue leakage
    • B2B customers who call a sales rep instead of ordering online because pricing is wrong in the storefront
    • Orders that don’t complete because a customer sees incorrect stock status
    • Sales rep time spent on manual quoting that should have been self-service
  3. Risk cost
    • Peak season oversell events when GP and Shopify inventory fall out of sync
    • Cost of one bad sync during a promotional period
    • The next Shopify API deprecation that breaks the connector your team is currently maintaining

Enter your current order volume and team hours. See your annual manual integration cost — the number Finance needs to make this decision obvious.

Most teams discover the manual integration cost is 2–3× the annual cost of a managed integration. That’s the conversation that moves budget.

What’s a dealbreaker versus a workable trade-off?

Not every imperfect thing in a vendor conversation should end the evaluation. Here’s how to sort them.

Workable trade-offs

  • Configuration changes go through a request rather than direct code access — tad slower than doing it yourself, but that’s the trade for not owning the maintenance
  • A pre-build scoping phase that adds two to four weeks upfront — that time prevents Dexterity conflicts from surfacing in production
  • A Year 1 cost that’s higher than a basic iPaaS subscription — the comparison is three to five year TCO, not month one

Dealbreakers

  • Can’t name which Shopify API version their connector runs on — the Shopify-side maintenance is unmanaged
  • Can’t describe what happens to your integration on a GP-to-BC migration when that migration is already on your roadmap — that’s two integration projects you’re about to pay for
  • No named contact after go-live, only a general support queue — for an integration processing every order your business takes, that’s the wrong place to find out your support model is generic
  • Pre-build Dexterity scoping doesn’t happen — you’ll discover customization conflicts in production, not before

i95Dev Connect clears every dealbreaker on this list. On the workable trade-offs: yes, configuration changes go through us. That’s the model. And it’s why your team isn’t working weekends after Shopify updates.

Is i95Dev Right For Our Setup — Or Should We Keep Looking?

If you’ve been through an integration that didn’t hold up, the last thing you want is another vendor conversation that sounds exactly like the one you had before it broke. So here’s a direct answer instead of a pitch.

We’re likely the right fit if

  • Your team has a reasonable sense of your Dexterity customizations — not necessarily documented, but known
  • Your B2B customers have account-specific pricing in GP that needs to appear correctly in Shopify
  • Your IT team wants visibility into the integration without owning the maintenance indefinitely
  • You have a dedicated integration engineering team that wants direct code access and configuration control — we build it for you, you own it post-go-live

We’re probably not the right fit if

  • You need something live with no scoping phase — our pre-build audit takes a week or two, and that time is what prevents post-launch surprises

The only way to know for certain

Bring your specific GP configuration — your version, your Dexterity customizations, your B2B pricing structure, your BC migration timeline. We’ll tell you in 30 minutes whether we’re the right fit. If we’re not, we’ll say so directly and tell you why.

30 minutes. Your configuration, specifically. We’ll tell you where we fit — and where we don’t.

FREE . 4 QUESTIONS
Tell Us About Your GP Setup. We'll Tell You What Fits.

Four questions about your GP version, Dexterity customizations, B2B pricing, and migration timeline. We come back to you with a specific recommendation, not a generic one.

Talk to someone about your GP setup ? 30 minutes. Specific to your configuration.