Why Marketplaces Need Deep ERP Integrations to Scale Upmarket

When marketplace operators close deals with Fortune 500 brands, the celebration in sales often ends abruptly in engineering. The phone rings. "They won't go live until we integrate with their NetSuite instance." Or SAP. Or their legacy Syn7 system buried inside a holding company's IT infrastructure.

This is the hidden tax on marketplace scaling. Every wholesale marketplace that tries to move upmarket discovers the same reality: enterprise brands will not treat a disconnected marketplace as their system of record. They have inventory in their ERP. They have orders flowing through their ERP. They have fulfillment workflows connected to their ERP. Adding a new sales channel means integrating with that ERP—and your marketplace's ability to support it becomes your ability to close the deal.

We've worked with marketplace platforms that connect thousands of suppliers with retailers but aspire to work with the largest brands in commerce. For these platforms, this constraint is both a blocker and an opportunity. The winning marketplaces won't be the ones that require brands to manually sync data across systems. They'll be the ones that make ERP integration invisible.

The Hidden Cost of Marketplace Scaling Without Integration Infrastructure

Most marketplaces begin life under a reasonable assumption: brands will love us enough to enter data twice. Once in their ERP, once in us. Reality introduces itself around Series B.

As your marketplace grows, two things happen simultaneously. First, you attract larger suppliers and brands—the ones with real volume, real margins, real sticky relationships. Second, those larger players bring non-negotiable requirements: "We need to connect our ERP to your platform." Not as a feature request. Not as a future roadmap item. As a prerequisite to signing.

The operational cost of being unprepared for this moment is brutal. Sales teams spend months with legal, IT, and procurement teams, watching deals sit in the pipeline while engineering tries to cobble together a custom integration. The brand's CIO demands SOC 2 compliance. Their IT director wants webhook signatures. Their operations team needs to map custom fields because their subsidiary in Brazil uses different inventory buckets.

Each custom integration takes weeks to build. Each one uses a different approach. One team uses scheduled syncs; another uses APIs; another uses webhooks. Field mapping gets hardcoded in different ways. Some integrations are pull-only; others need bidirectional sync. Documentation drifts. Testing becomes unreliable. When the next brand wants the same ERP but in a different configuration, you start almost from zero. This is exactly the problem that emerges when building integrations in-house breaks at scale.

This is where marketplace platforms hemorrhage. Not in user acquisition. Not in seller onboarding. But in the 90-day period between a sales handoff and the brand going live. This is where integration sprawl—the ungoverned collection of custom, one-off integrations—becomes your limiting growth factor.

The winners we've worked with recognize this early. They build integration infrastructure as a core product capability, not an afterthought for big deals. They make ERP integration fast, reliable, and repeatable. They treat integrations as a first-class product concern.

Why Marketplaces Can't Treat Integration as an Afterthought

The problem with bolting on integrations after you've built a marketplace is architectural. Marketplaces ingest data from two sides: suppliers pushing catalog and inventory data in, and retailers pulling orders and fulfillment data out. Add brands to the equation, and you've doubled the complexity.

Now a brand's ERP is not just a source of catalog data. It's a source of truth for inventory. It's a destination for orders. It's the system that drives fulfillment. The brand's operations team runs their entire logistics operation through that ERP. When inventory changes in the ERP, it needs to reflect in your marketplace in real time—not 6 hours later, not with a 15-minute lag. Orders placed on your marketplace need to flow back into their ERP immediately so their warehouse can pick and pack.

This is not a reporting problem. It's not solved with ETL tools or middleware designed for analytics pipelines. This is a synchronous operational requirement. Reliability at this level means handling authentication properly (ERP tokens expire), managing rate limits (their system might slow down), handling retries (networks fail), and debugging failures (your customer's operations team is waiting for the orders to appear).

Marketplaces also rarely account for the variety of ERP systems in production. NetSuite dominates mid-market, but enterprise brands live in SAP, Infor CloudSuite, Oracle NetSuite (different from regular NetSuite), custom Syn7 implementations, and industry-specific systems like IFS or MAPICS. Each has different data models, different authentication schemes, different capabilities. You can't write one integration and expect it to work across all of them.

Then add multi-subsidiary support. A holding company with brands in different countries, different industries, or different distribution channels often keeps separate ERP instances for each subsidiary. Your integration needs to understand that the parent company is one entity, but the integration might be pulling inventory from five different ERPs, each with different field mappings and custom business logic.

Without integration infrastructure designed from first principles, this compounds into a scaling problem that gets worse with every new large customer you acquire. Understanding what integration infrastructure actually is—and how it differs from point tools—is essential before you decide whether to build or buy.

The ERP Integration Landscape: DIY, Traditional Platforms, and Native Integrations

If you're a marketplace operator reading this, you've probably considered your options. Most teams land in one of three categories.

The DIY Path: Build integrations in-house. This works for your first two or three enterprise brands. Your team gets intimate with NetSuite API documentation. You build a web of custom code, environmental variables, and hacky field mapping logic. You handle authentication somehow—maybe stored database credentials, maybe OAuth tokens you manually refresh. Testing happens in production if you're being honest. By the time you've deployed your third integration, the initial one is already drifting and needs maintenance. Your engineers are writing integration code instead of working on your core product. This approach hits a wall around the 4th or 5th custom integration, at which point you've spent enough engineering time that you could have licensed a platform instead.

The Traditional iPaaS Route: Platforms like Zapier, Tray, or Dell Boomi. These excel at connecting SaaS applications in low-code environments. They have strong marketplaces of pre-built integrations and easy visual builders. But they were not designed for the continuous data movement that operational marketplaces require. Latency is often measured in minutes, not seconds. Pricing scales with the volume of data, which becomes prohibitive when you're syncing inventory changes across thousands of products every minute. Custom field mapping requires expensive professional services engagements. And they lack the deep bidirectional sync and webhook infrastructure you need for real operational integration. For a detailed comparison of modern integration tools, see our guide to the best tools for CRM integration in 2026.

Native Integration Infrastructure: This is the category that wins. A platform purpose-built for product teams to embed deep integrations as a core feature. It treats integrations as application logic, not external automation. You define your data flows in configuration—what to sync, when to sync it, how to transform fields—and the platform handles the ERP connections, authentication, retries, webhooks, and reliability. You get native SDK support, embeddable UI components for your customers to configure their integrations, and a control plane for managing all your integrations at once. This is where you can move from "90 days to go live" to "30 minutes to configure."

The difference between these approaches compounds. DIY costs you engineering velocity. Traditional iPaaS costs you in pricing, latency, and customization overhead. Native integration infrastructure costs you upfront to evaluate and integrate, but pays back in customer acquisition, customer success, and product differentiation.

What Enterprise Brands Expect from Marketplace ERP Integration

If you're building a marketplace trying to close enterprise deals, understand what your buyer's ERP integration requirements actually are.

First: Bidirectional sync at operational latency. Catalog and inventory data flow from their ERP to your marketplace, but with seconds of latency, not hours. Orders placed on your marketplace flow back into their ERP in real time. This isn't hypothetical—their warehouse operations are waiting for those orders to appear. A 30-minute delay means pickers and packers are standing idle.

Second: Support for their specific ERP system. "We'll integrate with NetSuite" sounds good until they tell you they're on a heavily customized Syn7 instance, or they have multiple SAP B1 implementations across subsidiaries. You need either pre-built connectors for the major ERP systems, or the flexibility to build custom connectors fast.

Third: Custom field mapping per brand. No two brands structure their ERP the same way. One might use custom dimensions for region, another for product tier, another for cost center. Their field in the ERP that maps to "product category" might be called "category," "prod_class," or "line_type." You need mapping that's configurable without code, but flexible enough to handle custom fields and complex transformations.

Fourth: Multi-subsidiary support. Large brands often have different legal entities, different countries, different cost centers. They need separate integration instances—one per subsidiary—but from a unified control plane. Understanding how to build multi-tenant CRM integrations at scale applies directly to marketplace scenarios, where isolation and shared infrastructure both matter.

Fifth: SOC 2, GDPR, and compliance. They're trusting you with their operational data. They want SOC 2 Type II certification. They want to know that data is encrypted in transit and at rest. They want to understand how long you retain data.

Sixth: Support for scheduled AND real-time sync. Some data (like daily inventory counts) can sync on a schedule. Others (like orders) need real-time webhooks. They need both options, sometimes on the same integration.

These aren't nice-to-haves. They're entry requirements to close a deal with any brand doing more than a few thousand dollars in annual volume.

How to Build Marketplace ERP Integration That Scales

Building this capability in-house is possible, but it requires architectural clarity from the start.

You need a configuration-driven approach. Instead of writing a new integration for each ERP and each brand, you define integrations declaratively—in YAML, in JSON, in a visual builder, or all three. You specify which entities to sync (catalog, inventory, orders, returns, refunds), which direction (pull, push, bidirectional), what frequency (scheduled, real-time, on-demand), and how to map fields. This configuration becomes the source of truth for your integration. It should be version-controlled, reviewable, and portable.

You need flexible authentication and token management. ERPs use different auth schemes (OAuth, API keys, basic auth, custom schemes). You need a platform that handles token refresh automatically, secure storage, and key rotation. Credentials should never live in your codebase or environment files. They should flow through a secure integration platform that your customer can control.

You need webhook infrastructure for real-time sync. Webhooks are how operational systems signal changes. When inventory updates in their ERP, they send a webhook to you. When an order is placed on your marketplace, you webhook to their ERP. Webhooks are simple in theory, complex in practice. You need to manage retry logic, handle duplicate delivery, ensure idempotency, and provide debugging tools so you can diagnose what went wrong when a webhook fails to deliver.

You need field mapping that doesn't require code. Custom field mapping should be expressible in UI, not buried in your codebase. Your customer should be able to configure how a field from their ERP maps to your data model without waiting for an engineering cycle. This includes transformations—converting an integer priority code into a text label, aggregating multiple ERP fields into one unified field, and parsing custom JSON fields.

You need multi-tenant isolation with shared infrastructure. Multiple brands will be running integrations simultaneously. Their data needs to be completely isolated—not because they don't trust you, but because you need to be able to guarantee performance. One brand's integration should not impact another brand's. And you should be able to onboard a new brand with a new integration instance without new infrastructure.

You need debugging and monitoring. When something breaks at 2 AM—and it will—your customer needs visibility. They need logs showing which records synced, which failed, and why. They need to understand latency. They need to be able to replay failed syncs. Your support team needs the same visibility.

The companies doing this well recognize that integration infrastructure is not a product extension. It's a platform. And like any platform, it's best built by platform specialists.

Comparison: DIY vs. Traditional iPaaS vs. Native Integration Infrastructure

The cost difference becomes stark when you onboard your fifth large enterprise brand. DIY integration costs accumulate. iPaaS pricing per transaction becomes untenable. Native integration infrastructure amortizes across your customer base.

Native Product Integrations: How Integration Infrastructure Solves the Marketplace Problem

Marketplace operators we've consulted with consistently identify one core requirement: the ability to offer true native product integrations without multiplying engineering headcount. This means moving beyond generic iPaaS platforms and toward integration infrastructure purpose-built for operational use cases.

What makes native product integrations different? First, they treat ERP connectivity as a first-class application concern, not a reporting afterthought. Second, they support the low-latency, bidirectional data flow that marketplace operations demand. Third, they enable your customers to configure integrations through embedded UI—no professional services required.

Ampersand is built exactly for this problem. It's a deep integration platform designed specifically for product teams that need to embed native integrations into their applications. Rather than asking you to build and maintain 20+ ERP connectors yourself, Ampersand provides them as configuration. Rather than asking your customers to work with external consultants, they configure integrations directly in your product using embedded UI components. You can explore the capabilities of Ampersand by reviewing its technical documentation.

The platform uses YAML-based configuration that becomes your integration source of truth. You define which entities sync, in which direction, on what schedule, and how fields map. This configuration is version-controlled and lives in your CI/CD pipeline alongside your code. When a customer adjusts their field mapping, they're adjusting your configuration—not asking you to write code.

Ampersand handles 250+ native product integrations to ERP systems (NetSuite, SAP B1, Infor, IFS, Oracle), CRMs, and operational tools. If you need to integrate a custom or niche ERP, you can build custom connectors using Ampersand's SDK—you handle the ERP-specific logic, Ampersand handles the platform concerns (auth, retries, webhooks, field mapping UI).

The platform manages token refresh and authentication automatically. Your customer connects their ERP once. Ampersand securely stores credentials, refreshes tokens before they expire, and handles key rotation without customer intervention. This alone eliminates a major source of production failures in marketplace integrations.

Bidirectional sync at sub-second latency is native to the platform. Scheduled reads (pull inventory every 5 minutes) work the same way as real-time webhooks (push orders immediately when placed). Multiple sync patterns can run simultaneously on the same integration.

On security and compliance: Ampersand is SOC 2 Type II certified, GDPR-compliant, and ISO 27001 certified. Enterprise brands can audit the platform directly.

The proof of this architecture is in real customer results. Hatch, the Yelp-owned marketplace platform, told us plainly: "Ampersand is core to how we grow." They use Ampersand to power CRM integrations at scale across their customer base. In one case, a customer reduced their integration setup latency from 60 seconds to 5 seconds—an 11x improvement—by switching to Ampersand. Another customer (an AI phone agent platform called 11x) deployed a deep NetSuite integration in two weeks instead of the months of custom engineering it would have taken in-house.

These are not hypothetical metrics. They represent the difference between a sales deal shipping in weeks versus slipping for months.

Why Your Marketplace Needs This Before Your Next Enterprise Deal Lands

The cost of not having integration infrastructure is not linear. Your first enterprise brand might take months to integrate. Your second might take 6 weeks. But the third, fourth, and fifth accumulate technical debt that slows you down with each new integration. Meanwhile, your sales team is closing larger and larger deals. Each one has the same requirement: "We're not going live until you can pull our inventory from our ERP and push orders back in real time."

You have two paths forward:

Build it yourself. This works for your first 2-3 large customers. By customer 4, your engineering team will be split between core product work and integration maintenance. By customer 10, you'll have realized that integration infrastructure should have been a platform from the start, not a collection of one-off scripts.

Use a platform. This costs you upfront to evaluate and integrate, but compresses the time from sales handoff to go-live from 90 days to 30 minutes. It removes integration work from your engineering roadmap. It gives your customers a configurable, self-service experience. And it scales with you as you add more brands and more ERP systems.

The decision is not binary—you can use a platform for large enterprise brands while building smaller integrations yourself. But if you're serious about scaling upmarket, you need to build integration infrastructure as a product capability. To understand how integration infrastructure works at a deeper level, read more about what integration infrastructure actually is.

FAQ: ERP Integration for Marketplaces

Q: How long does it actually take to integrate a new ERP system into our marketplace?

A: With a native integration platform, you're looking at 2-3 days for a pre-built connector (NetSuite, SAP B1, etc.). Your customer can configure their specific field mappings and sync frequencies through UI, with no engineering involvement. Total time from sales handoff to go-live: 30 minutes to a few hours, depending on how much configuration is involved. Compare this to DIY, which typically takes 4-8 weeks, or traditional iPaaS, which takes 2-4 weeks but with ongoing latency and cost constraints.

Q: What if we need to support a custom or legacy ERP system?

A: This is where platform flexibility matters. Platforms like Ampersand support building custom connectors if the ERP system has an API or can export data via middleware. The platform handles the hard parts—authentication, retries, webhook delivery, field mapping UI—while you focus on the ERP-specific logic. This is still faster than building from scratch, but it requires engineering input. Most marketplaces find that 80% of their demand is concentrated in 5-10 ERP systems (NetSuite, SAP, Infor, Oracle, Syn7), so pre-built connectors handle the majority of deals.

Q: How do we handle custom field mapping when every brand structures their ERP differently?

A: Declarative configuration with UI-based field mapping. Your customer connects their ERP, and the platform introspects their custom fields. They then map those fields to your data model through a visual UI. No code required. Multiple customers can have completely different field mappings simultaneously, and the platform isolates them from each other.

Q: Can we run real-time integrations without spiking our infrastructure costs?

A: Yes, but only if your integration platform is designed for it. Traditional iPaaS charges per transaction, which becomes prohibitive at operational scale (thousands of records syncing daily). A native integration platform uses fixed pricing regardless of volume, so your cost structure is predictable. You can run as many webhooks as you need without price shocks.

Q: How do we debug when an integration breaks at 2 AM and our customer is waiting for their orders?

A: Logging, visibility, and webhook replay. Your integration platform should surface detailed logs showing which records synced successfully, which failed, and why. You should be able to replay failed syncs without re-triggering the source system. And you should have webhook delivery tracking so you can see if the issue is on their end or yours. This is table stakes for any platform you evaluate.

Q: What's the difference between building integrations ourselves versus using a platform like Ampersand?

A: The fundamental difference is velocity and cost. Building integrations in-house breaks at scale—your team will spend 6 months building integration infrastructure that a platform like Ampersand has already built, then 18 months maintaining it. You'll make the same mistakes platforms solved years ago (token refresh, webhook retries, multi-tenancy). A platform lets you focus on your marketplace—what you're actually good at—while specialists handle the plumbing. The ROI typically shows up in your second or third large enterprise deal. For a deeper understanding of the CRM API integration build process, the principles apply directly to ERP work.

The Market Reality: Integration Infrastructure as Competitive Advantage

The wholesale marketplace space is consolidating. Larger platforms are expanding upmarket, competing for brands with volumes that matter. The brands they're competing for don't care about marketplace UI or brand positioning. They care about one thing: can this marketplace integrate with our ERP without disrupting our operations?

Platforms that can answer "yes" and actually prove it—30 minutes from signed agreement to live integration—will win upmarket deals that others lose. Platforms that can't will watch sales cycles extend, deals slip, and revenue get blocked by engineering constraints.

The good news: this is solvable. You don't have to build it yourself. You don't have to compromise with slow, expensive tools designed for a different use case. You can build a marketplace with integration infrastructure that scales because it was designed to scale from the start.

To learn more about how to approach this problem, discover how integration infrastructure works in practice, or if you're ready to move faster on enterprise integrations, speak with an engineer at Ampersand to explore what's possible with your specific marketplace.

The marketplace that wins upmarket won't be the one with the fanciest brand or the largest seller base. It will be the one that makes ERP integration invisible. Start building that infrastructure now, before your next enterprise deal arrives.