The Last 10% Problem: Why ERP Integration Onboarding Stalls and How to Fix It

The worst moment in any integration project arrives silently. You've spent weeks building robust technical infrastructure. Your API connectors work flawlessly in testing. Your data mapping logic handles edge cases. Your engineers have shipped clean code that passes security audits. Everything looks perfect from a technical standpoint. Then you hit production.

A customer needs to connect their NetSuite instance. Simple enough. You ask for an API key. They have to file a ticket with their finance team. The finance team escalates to NetSuite administration. Someone's on vacation. Two weeks pass. When the key finally arrives, it's the wrong one. It requires specific IP whitelisting that conflicts with their VPN configuration. Your customer starts asking why what you promised would take hours is now entering week three.

This isn't a rare edge case. This is the industry standard. I call it the "last 10% problem," and it's the reason enterprise integration projects explode in cost and duration, even when the underlying technical architecture is sound.

At Ampersand, we work with companies across procurement platforms, vertical SaaS solutions, and enterprise automation tools. Through dozens of conversations with engineering leaders and procurement platform teams deploying deep ERP integrations, we've learned that the biggest challenge in ERP onboarding isn't complex data transformation or API authentication. It's the operational friction that emerges once customers are in the real world, with real infrastructure, real governance policies, and real organizational friction.

This post breaks down why the last 10% matters more than the first 90%, and why traditional integration approaches fail to address it.

What Is the "Last 10%" Problem?

Let me be precise about what I mean. The first 90% of ERP integration work is technical architecture—API design, field mapping, error handling, security protocols. This is where most integration platforms focus. It's where most documentation lives. It's measurable, repeatable, and can be automated.

The last 10% is everything that happens when a real customer tries to connect a real ERP system in their real production environment. This includes:

• Securing API access credentials from customers who don't have them and don't know where to request them
• Mapping custom fields that exist only in their specific NetSuite instance and don't follow standard naming conventions
• Understanding their unique business processes and how they map to your data model
• Handling schema drift as customers update their ERP configuration mid-integration
• Navigating internal approval processes and compliance requirements specific to their organization
• Providing technical education so customer teams understand what permissions are required
• Joining customer calls to troubleshoot issues that only their system administrator can reproduce
• Creating documentation tailored to their specific use case
• Supporting multiple technical stakeholders on the customer side (finance, IT, systems admin, data team)

This last 10% is what delays ERP onboarding by months. Not technical complexity. Operational friction.

Across our work with engineering leaders building procurement platforms, supply chain tools, and vertical SaaS solutions that integrate with NetSuite, SAP, or Dynamics, we see the same pattern consistently. These teams can build the integration logic in weeks. But getting a customer's CFO to allocate time for their finance admin to coordinate with IT to provision API access? That takes months. And during those months, the customer sees no value. Their team is confused about next steps. Your sales team is answering the same questions repeatedly. Your engineering team is context-switching between five customers who are all stuck at slightly different points in the same onboarding process.

The result: enterprise sales cycles extend by 60-90 days. Implementation costs spike. Customer satisfaction suffers. Worse, by the time the integration finally goes live, the customer has lost enthusiasm. They're just trying to get it over with, not maximize the value.

This is the last 10% problem.

Why Traditional Integration Platforms Miss This

The current landscape of integration solutions falls roughly into two camps: generic iPaaS platforms and purpose-built ERP connectors.

Generic iPaaS platforms like Zapier, Integromat, or even enterprise solutions like Workato focus on providing flexibility for anyone to build anything. They excel at lightweight integrations—connecting CRM to email, triggering Slack messages from form submissions, syncing spreadsheet data. But they lack domain expertise. When you hit the last 10% in an ERP context, you're alone. There's no NetSuite specialist who understands that the custom field you're trying to map only exists in a specific subsidiary. There's no accountant who can explain why their revenue recognition process requires a specific sequence of API calls. You get comprehensive documentation, but it's generic. It's not tailored to the unique operational complexity of your customer's organization.

Purpose-built ERP connectors (often baked into specialized point solutions) go the other direction. They're deeply specialized but narrowly scoped. If you're integrating with NetSuite specifically and your use case matches their template, they work beautifully. But the moment your customer has custom fields, non-standard configurations, or unique business logic, you're constrained. These solutions often require professional services to customize, which defeats the purpose of moving faster. Plus, if you need to integrate with multiple ERPs—NetSuite and Dynamics, for instance—you're managing multiple point solutions, multiple vendor relationships, and multiple data synchronization strategies.

What's missing is a middle ground: deep technical infrastructure with genuine domain expertise.

This is what Ampersand represents in the modern integration landscape. It's not trying to be an all-purpose no-code platform. It's infrastructure for teams building native product integrations with ERPs, CRMs, and other mission-critical systems. It combines declarative YAML-based configuration (meaning you define what needs to integrate, and the platform handles the how) with genuine domain expertise from people who have spent years in accounting, finance operations, and enterprise systems implementation.

The ERP Integration Landscape Has Changed

To understand why this matters now, it's worth acknowledging how the ERP integration market has evolved.

Five years ago, ERP integrations were the domain of large system integrators. If you wanted your SaaS product to work with SAP or Oracle, you hired Deloitte or Accenture. They'd send a team of consultants, spend six months understanding your requirements, and hand you off with a custom integration that worked—eventually. Companies accepted this model because there weren't alternatives.

Then the market shifted. Smaller, more specialized companies started building vertical SaaS solutions that had to integrate with ERPs but couldn't afford traditional system integrators. They needed to move faster and more cost-effectively. This created demand for better integration infrastructure.

But the infrastructure evolved slowly. Most integration platforms were designed for data movement between databases or for workflow automation within a single category of system. They didn't account for the unique operational complexity of ERP integrations: the governance requirements, the financial implications of data inconsistency, the organizational silos between IT and Finance, the regulatory requirements around data handling.

What we're seeing now is a third wave: specialized integration infrastructure designed specifically for teams building deep ERP integrations. This infrastructure combines the flexibility of modern APIs with the domain expertise to handle the "last 10%" friction that causes real-world deployments to stall.

Why Operational Friction Matters More Than Technical Complexity

Here's an uncomfortable truth: the technical part of ERP integration isn't that hard anymore.

Modern APIs are well-documented. Error handling is standardized. OAuth, API key management, and security protocols have matured. If you have a competent backend engineer, they can build a functional NetSuite connector in a few weeks. The technical architecture itself is solvable.

But operational friction is expensive and unpredictable. It's the difference between a customer signing on March 15th and going live on March 20th versus signing on March 15th and going live on June 15th. It's the difference between 20 hours of engineer time versus 200 hours.

The source of this friction is structural. Your customer's NetSuite instance isn't just a generic ERP system—it's a specific configuration built over years, modified repeatedly, with custom fields and processes that exist nowhere else in the market. It's governed by compliance requirements specific to their industry. It's integrated with seven other systems already. It's maintained by someone who has a day job. It's understood by maybe two people in their entire organization.

When you ask for an API key, you're not asking for a simple credential. You're asking your customer to:

1. Identify who has access rights (usually not obvious in any given organization)
2. Navigate internal approval processes (which may require Finance sign-off, IT review, or compliance clearance)
3. Provision the access without breaking existing integrations
4. Understand what permissions are actually required (which varies based on your specific use case)
5. Document the process so future administrators understand what happened

For a customer with fewer than 500 employees, someone in finance is doing this in their spare time. They're learning your domain as they go. They have no mental model for why you need read access to custom fields or why NetSuite requires specific security tokens.

The organizations that solve the last 10% problem don't just provide APIs. They provide the full operational context required to close that final gap. They include:

• Domain expertise: People who understand not just ERP APIs but how ERPs are actually used. Accountants who understand why revenue recognition logic matters. Systems architects who know why schema changes cause problems.
• Customer-specific documentation: Not generic "how to provision an API key" guides, but documentation tailored to this specific customer's use case.
• Embedded support: The ability to join customer calls, walk through their specific NetSuite configuration, and provide technical guidance directly.
• Configuration flexibility: The ability to handle custom fields, business-specific mappings, and non-standard data transformations without professional services engagements.
• Change management: The ability to evolve configurations as customers update their ERP without breaking existing integrations.

This is why teams we've advised across procurement automation, supply chain optimization, and enterprise operations benefit from working with specialized integration infrastructure partners. They're building solutions for their core domain. Their customers are manufacturing companies and large enterprises with complex NetSuite deployments. Neither the product team nor their customers have time to manage the operational complexity of ERP integration alone.

How Modern Integration Infrastructure Reduces Friction

Let's talk about what actually works.

Modern integration infrastructure designed for this problem—what we call integration infrastructure—combines a few key elements:

First, declarative configuration: Instead of writing custom integration code for each customer, you define the integration once in a structured way (typically YAML, sometimes JSON or proprietary formats). This definition can then be reused, versioned, and evolved. Configuration changes don't require code deployment. This matters enormously in the last 10%, where you're constantly adjusting field mappings based on customer-specific requirements.

Second, bi-directional read/write with custom object support: Most integrations are one-directional. Data flows from system A to system B. But real business processes are circular. A customer receives a purchase order from your system, updates it in NetSuite, and those updates need to flow back. You need to be able to read custom fields that only exist in their NetSuite instance and write custom fields that exist only in your system. Generic integration platforms struggle here. Purpose-built ERP infrastructure handles it natively.

Third, managed authentication and security: API key management is tedious and scary for customers. They worry about credential exposure. They're not sure what permissions are actually needed. Modern integration infrastructure abstracts this. It supports industry-standard protocols like OAuth. It manages tokens server-side. It provides clear documentation about what permissions are actually required. This dramatically simplifies the last 10% friction.

Fourth, schema management and handling drift: This is less visible but enormously important. When a customer updates their NetSuite configuration—adds a new custom field, changes how a field is calculated, modifies access permissions—your integration needs to adapt. This isn't a one-time setup. It's ongoing. Modern integration infrastructure provides tools to detect schema changes, alert on breaking changes, and manage migrations.

Fifth, webhooks and real-time data synchronization: The speed at which data moves between systems matters more than people think. When a customer submits a purchase order, they expect to see it in their ERP quickly. Not hours later. Not the next day. Seconds. If your integration uses batch processing with hourly updates, customers notice. They perceive it as slow and unreliable. Sub-second webhooks change the perception entirely.

Sixth, domain expertise bundled with technology: This is the differentiator most integration platforms miss. It's not enough to provide APIs. You need to provide people who understand ERPs, understand your specific domain, understand accounting, and can bridge the gap between your technical team and the customer's operational team. This is expensive to build but invaluable in practice.

A Real-World Example: Why Orb Built Deep NetSuite Infrastructure

Orb is a billing and metering platform serving usage-based commerce companies. Their customers are typically SaaS companies with complex billing logic. Many also use NetSuite for accounting and financial consolidation.

A few years ago, Orb realized that building a "good enough" NetSuite integration—one that handled 90% of use cases—wasn't viable. Their customers had non-standard billing models. They had custom revenue recognition logic. They had specific compliance requirements. A standard NetSuite connector couldn't handle the complexity.

So Orb invested in deep NetSuite integration infrastructure. They hired people with NetSuite expertise. They built configuration-driven systems capable of handling custom field mapping, complex data transformations, and multi-instance deployments. They joined customer calls to understand specific requirements. This is a fundamental principle behind why usage-based billing platforms need specialized integration infrastructure—the operational complexity of handling diverse financial models at scale.

The result: what used to take three months to implement could be done in three weeks. Their engineering team's burden decreased. Their customers could launch faster. Their perception improved.

This is what happens when companies get serious about solving the last 10% problem.

Why This Matters Now

ERP integrations are no longer a luxury feature or a nice-to-have. They're table stakes for any vertical SaaS solution serving customers with established enterprise systems.

Teams building procurement platforms, supply chain tools, accounting solutions, and operations automation are optimizing workflows for companies with complex NetSuite, SAP, and Dynamics deployments. Their value is entirely dependent on connecting deeply with these systems. If they solve their core logic but make integration a six-month nightmare, they fail. Their customers have other options. They need fast, frictionless onboarding.

This is true across nearly every vertical SaaS market. Accounting platforms need to integrate with QuickBooks, NetSuite, and Sage. HR platforms need to integrate with Workday and ADP. Project management platforms need to integrate with Jira, Asana, and Monday. Operations platforms need to integrate with Salesforce, HubSpot, and Pipedrive.

But here's what most product teams realize too late: they can't build this in-house effectively. It's not a core competency. It's a necessary capability that distracts from actual product development. Every engineer working on integration infrastructure is an engineer not working on product features that differentiate you in the market.

This is why the category of specialized integration infrastructure is emerging. It provides a middle path: you get deep ERP capabilities without building them yourself. You get domain expertise without hiring NetSuite experts full-time. You get operational support for customer onboarding without building a professional services team.

The Current State of ERP Integration Solutions

Let me put this in perspective with a quick comparison of how different approaches handle the last 10% problem—and which tools actually work best for enterprise integration.

Traditional ERP Vendors (NetSuite, SAP, Dynamics)

These companies provide APIs, documentation, and certification programs for partners. If you're building a specialized solution, you can become a NetSuite certified connector partner. The advantage: direct access to vendor expertise. The disadvantage: you're constrained by what the vendor prioritizes. If the vendor doesn't support your specific use case, you're on your own. Plus, you need to maintain separate relationships with NetSuite, SAP, and Dynamics. That's three different integration models, three different authentication approaches, three different documentation standards.

Generic iPaaS (Zapier, Workato, Integromat)

These platforms excel at democratizing integration. They let anyone build integrations without coding. The advantage: low barrier to entry, broad platform support. The disadvantage: lack of domain expertise. When you run into edge cases—custom fields, non-standard configurations, complex business logic—you're in territory where generic solutions struggle. Documentation is comprehensive but generic. Support is helpful but not specialized. For ERP integrations specifically, you'll likely hit the limits of what generic platforms can do.

Point Solution ERP Connectors

Some vertical SaaS companies build NetSuite or Salesforce connectors specifically for their domain. These are custom-built, deeply specialized, and work well for template use cases. The advantage: highly tailored, purpose-built. The disadvantage: not reusable across platforms, requires in-house engineering expertise to maintain, limits your ability to support multiple ERPs. If your customer uses Dynamics instead of NetSuite, you're building a new connector.

Integration Infrastructure (like Ampersand)

This is a relatively new category. It's neither generic iPaaS nor point solution. It's infrastructure specifically designed for teams building deep, native ERP integrations. It combines technical depth (bi-directional read/write, custom objects, schema management) with operational support (domain expertise, customer guidance, change management). The advantage: you get both technical capabilities and operational support without building everything yourself. You can support multiple ERP platforms without duplicating engineering effort. The disadvantage: requires more upfront configuration than generic iPaaS, requires more technical capability than point solutions. It's for serious integrations, not simple data syncs.

For product teams with significant customer demand for deep ERP integration and limited appetite to build specialized integration infrastructure in-house, this category makes the most sense.

How to Evaluate Integration Infrastructure

If you're building a product that requires deep ERP integrations, here are the questions to ask when evaluating solutions:

Technical Capability: Can the platform handle bi-directional data flow? Does it support custom fields and objects? Can it manage schema changes? Does it provide sub-second webhooks or batch synchronization? Does it support the specific ERPs your customers use?

Operational Support: Does the vendor understand your domain? Can they join customer calls? Can they provide domain-specific guidance? Do they have experience with the specific ERPs and configurations your customers use?

Configuration vs. Code: How much configuration can you handle declaratively, and at what point do you need custom code? For the last 10% problem, you want to minimize the "custom code" path. Every customer requiring code engagement means slower onboarding and higher professional services costs.

Change Management: How does the platform handle schema drift? When a customer updates their ERP configuration, how does your integration adapt? Can the platform alert you to breaking changes? Can you roll back configurations?

Security and Compliance: Does the platform provide the credentials and security posture your customers require? Can you meet SOC 2, GDPR, ISO 27001 requirements? Can you support IP whitelisting, VPN access, and other infrastructure requirements your enterprise customers demand?

Proof Points: Has the vendor solved similar problems for other companies? How fast can they help you onboard customers? What do reference customers say about onboarding speed?

These aren't exotic requirements. They're table stakes for enterprise integration infrastructure in 2026.

The Ampersand Approach to Solving the Last 10% Problem

Ampersand was built specifically to address the last 10% problem for teams building deep product integrations.

Instead of asking you to choose between technical breadth (generic iPaaS) and technical depth (point solutions), Ampersand provides integration infrastructure with depth. You define your integration configuration once in YAML—what systems connect, what data flows, what fields map—and deploy it across multiple customer instances. That configuration is version-controlled, CI/CD compatible, and evolved based on customer feedback.

On the technical side, Ampersand provides bi-directional read/write with support for custom objects and dynamic field mapping. It handles the boring stuff—authentication, token management, error handling, retry logic—so you don't have to. It supports 250+ open-source connectors across CRMs, ERPs, and other enterprise systems. That means if your customers use NetSuite today but someone requests Dynamics support tomorrow, you're not building a new integration from scratch. You can explore how we approach building modern customer-facing integrations to understand the workflow better.

On the operational side, Ampersand isn't just infrastructure. It's a team of integration experts, many with deep ERP and accounting backgrounds. They understand why the last 10% causes friction. They've lived it. This translates into practical support: help designing customer-specific configurations, documentation tailored to specific use cases, the ability to join customer calls and accelerate onboarding, expertise to handle edge cases that generic solutions can't address.

For teams implementing this at scale, Ampersand's documentation provides the technical depth required—everything from schema management to real-time synchronization patterns. This is where our product differs fundamentally from lighter-weight iPaaS solutions: we assume you're building serious integration infrastructure, not simple data syncs.

This is why product teams building vertical solutions benefit from this approach. They're focused on their core domain—whether that's procurement optimization, supply chain logic, or accounting automation. Ampersand handles the operational complexity of ERP integration. The result: faster customer onboarding, less engineering distraction, higher customer satisfaction.

Frequently Asked Questions

Q: Is Ampersand just another iPaaS?

No. iPaaS platforms prioritize flexibility and breadth—the ability to build almost any integration anyone might want. Ampersand prioritizes depth and purpose-building. We're designed specifically for teams building deep, native integrations with ERPs, CRMs, and other mission-critical systems. That focus means we can provide capabilities and expertise that generic platforms can't.

Q: What's the difference between Ampersand and building the integration myself?

Building integrations in-house is viable if you have a dedicated team and ERP expertise. But most product teams don't. You're diverting engineering resources from product development. You're rebuilding authentication and error-handling logic that others have solved. You're solving the last 10% problem alone, without domain expertise. Ampersand lets you focus on your product while we handle the operational complexity of integration. The companies that have tried building in-house often end up in a cycle of integration debt that breaks at scale—it's why specialized infrastructure has become table stakes.

Q: Does Ampersand support multiple ERPs?

Yes. Our infrastructure supports NetSuite, SAP, Dynamics, and other enterprise systems. You define your integration logic once, and we handle the platform-specific details. If your customer base spans multiple ERPs, this saves enormous engineering effort.

Q: How quickly can we onboard customers?

With purpose-built integration infrastructure and domain expertise, onboarding timelines compress dramatically. Companies like Orb went from three-month to three-week implementations. The exact timeline depends on your specific use case and customer complexity, but the reduction is typically 50-70%.

Q: Is the YAML-based configuration approach limiting?

No. Declarative configuration handles the vast majority of real-world integrations. For unusual edge cases, you have the option to extend with custom logic. But the goal is to minimize that path, because custom code increases onboarding time and maintenance burden.

Q: How does Ampersand handle data security?

Ampersand is SOC 2 Type II compliant, GDPR compliant, and ISO 27001 certified. We manage API credentials server-side so customers never need to share keys. We support IP whitelisting, VPN access, and other enterprise security requirements. We provide clear documentation about what permissions are actually required so customers can provision minimal necessary access.

Conclusion: The Last 10% Is the First Priority

ERP integration is a table-stakes capability for any vertical SaaS solution. The last decade of market evolution has made that obvious. What's less obvious—but increasingly critical—is that the technical part of integration isn't the bottleneck. The operational part is.

The companies winning in specialized markets are the ones who've figured out how to compress onboarding timelines, manage customer-specific complexity, and handle the operational friction that emerges in production. They're doing this not by hiring more engineers to build custom integrations, but by adopting integration infrastructure that was purpose-built for this problem.

If you're building a product that requires deep ERP integrations—whether you're optimizing procurement workflows, managing billing, or serving any other enterprise use case—the last 10% problem is the thing between you and rapid customer deployment.

The best path forward isn't to solve it alone. It's to work with infrastructure partners who've already solved it dozens of times before.

Ampersand provides the technical infrastructure and operational expertise to close that gap. We handle authentication, data synchronization, schema management, and the integration complexity that distracts from your actual product. Our team joins customer calls, provides domain-specific guidance, and accelerates onboarding.

The result: your customers go live faster, your engineering team focuses on product, and your company can scale customer acquisition without scaling operational burden.

If you're interested in exploring how Ampersand could accelerate your integration roadmap, schedule time with an engineer to discuss your specific use case. We can show you how other companies have compressed their onboarding timelines and what integration infrastructure can unlock for your product.