How to Scope Complex Integrations You've Never Built Before (Using AI to Look Like an Expert)

You're on a sales call. The prospect mentions they need an integration with some obscure ERP system you've never heard of. Your stomach drops. You smile and nod while internally panicking about how you're going to build this thing.

Sound familiar?

Here's the reality: you don't need years of experience with every legacy system out there. You need to know how to ask the right questions and understand the integration requirements well enough to scope it properly. And modern AI tools with large context windows make this dramatically easier than it used to be.

The Problem with Traditional Integration Scoping

Traditionally, scoping an unfamiliar integration meant:

• Spending days reading through dense technical documentation
• Hoping you'd worked with something similar before
• Asking generic questions that make you sound inexperienced
• Either underselling (losing the deal) or overselling (losing money on delivery)

The prospect can smell uncertainty. When you ask vague questions like "So... how does your system work?" they lose confidence fast.

The AI-Powered Approach to Integration Scoping

Here's a better workflow that takes about 30-60 minutes and leaves you sounding like you've built this integration a hundred times before.

Step 1: Hunt Down the Documentation

Every system has documentation somewhere, even if it's ancient. Here's where to look:

For commercial ERPs: Check the vendor's website for PDF manuals, API documentation, or developer guides. Most legacy systems have surprisingly comprehensive documentation it's just that nobody reads 500-page PDFs anymore.

For industry-specific software: Search "[System Name] API documentation" or "[System Name] integration guide." Industry forums and Reddit often have links to resources the vendor doesn't prominently advertise.

For desktop applications: Look for SDK documentation, ODBC driver guides, or database schema documentation. Many desktop apps expose data through SQL databases or file exports.

For bespoke internal systems: Ask the prospect to describe the system. What does it do? What data does it store? How do users interact with it? Even a rough description gives AI enough to work with.

Pro tip: If you find multiple documents, grab them all. Large context window models can process hundreds of pages at once.

Step 2: Upload Everything to a Large Context Window AI

This is where the magic happens. Tools like Gemini 2.5 Pro, Claude 3.5 Sonnet, or GPT-4 Turbo can read your API specs and their system documentation simultaneously.

What to upload:

• Their system's documentation (PDF, web pages, API specs)
• Your platform's API documentation
• Any relevant integration examples or case studies

How to frame it:

I need to scope an integration between [Your System] and [Their System].

Here's what needs to happen:
- When a sales order is created in [Their System], we need to create a corresponding order in [Your System]
- Order line items, customer information, and pricing need to sync
- We need to handle [specific business logic or edge case]

Please analyze both systems and tell me:
1. What's the technical approach for this integration?
2. What are the potential challenges?
3. What information do I need from the client to scope this accurately?


The AI will digest both documentation sets and give you a technical overview that would have taken you days to piece together manually.

Step 3: Generate a Sequence Diagram

Ask the AI to create a sequence diagram showing how data flows between the systems:

Create a sequence diagram showing the step-by-step flow for:
1. Order creation in [Their System]
2. Data extraction
3. Transformation
4. Sending to [Your System]
5. Confirmation and error handling


Why this matters: This visual gives you (and your prospect) a clear mental model of the integration. You'll understand what happens when, where potential failure points are, and what needs to be configured on both sides.

Even if you're not presenting the diagram to the prospect, having it in your head transforms how you talk about the integration. You go from vague hand-waving to specific, confident explanations.

Step 4: Map Data Transformations and Edge Cases

This is where integrations get complex. The devil is in the details of how data maps between systems.

Ask the AI:

Map the data transformations between these systems:
- How does a "Customer" in [Their System] map to a "Client" in [Your System]?
- What fields are required vs optional in each system?
- How do we handle cases where data exists in one system but not the other?
- What are the date/time format differences?
- How do currency, units of measurement, or other standardized fields differ?


The AI will flag potential issues like:

• "Their system allows null values for customer email, but your system requires it"
• "Their system uses customer numbers as strings, yours uses integers"
• "They track inventory at the warehouse level, you track at the SKU level"

These edge cases become your best questions for the prospect. Instead of "How do you handle customers?" you ask "Your system allows customers without email addresses how should we handle those cases in our integration?"

The prospect hears: "This person has clearly thought through the details."

Step 5: Generate a Plain English Specification

Now have the AI write a concise specification document:

Write a 300-word technical specification for this integration that:
- Explains what the integration does in simple terms
- Lists the technical approach at a high level
- Identifies key requirements from both systems
- Flags potential risks or complications
- Provides a rough timeline estimate

Write this for an audience that includes both technical and non-technical stakeholders.


This document becomes your internal reference and can be adapted for proposals. It keeps your sales team and delivery team aligned on what was actually promised.

Example output structure:

• Integration Overview: 2-3 sentences on what it does
• Technical Approach: VM-based API, scheduled sync, real-time webhooks, etc.
• Data Flow: Orders flow from A to B, inventory updates flow from B to A
• Requirements: Access to their system, API credentials, test environment
• Timeline: 2-4 weeks for development, 1-2 weeks for testing
• Risks: Their system rate limits, data format inconsistencies

Step 6: Extract System-Specific Questions

This is the secret weapon. Generic questions make you sound like you're learning on their dime. Specific questions make you sound like an expert.

Ask the AI:

Based on this integration, what specific technical questions should I ask the prospect's IT team to scope this accurately?


The AI will generate questions tailored to their specific system and your integration approach.

Generic question (sounds inexperienced):"How does your system work?"

Specific question (sounds experienced):"Is your QuickBooks Desktop installation running in single-user or multi-user mode? We'll need multi-user mode to connect our integration without locking out your team."

Example Questions for Desktop ERP Integrations

Here's what system-specific questions look like in practice:

Infrastructure questions:

• "Where is [System] installed? On a VM or a physical machine?"
• "Is that machine connected to the internet, or is it on an isolated intranet?"
• "What's the operating system and version running [System]?"

Access and permissions questions:

• "Who's your IT contact that can help us install the [SDK/connector/agent]?"
• "Will someone with administrator access be available during our initial setup?"
• "Can we create a dedicated service account for the integration, or do we use an existing user?"

Testing and development questions:

• "Can we get a backup or export of your [System] data to build a sandbox environment?"
• "Do you have a test/staging instance of [System], or will we need to test carefully in production?"
• "Can we get temporary access to the system to test connectivity and data extraction?"

Integration history questions:

• "Have you built other integrations with [System]? How did those work?"
• "Who built them, and can we talk to them about their approach?" (Great for stealing intel on what works and what doesn't)

System configuration questions:

• "Is [System] running in [specific mode] that affects how we can connect?"
• "Do you have [specific feature] configured? Like shipping line items, multi-currency, inventory tracking, etc."
• "What version of [System] are you running? Some features differ between versions."

These aren't pulled from a generic template. They're specific to the system architecture the AI identified in their documentation.

Why This Approach Works

The prospect perspective:

When you walk into a call and ask, "Is your QuickBooks Desktop running in multi-user mode, and will we need to install the SDK on the same machine or can we use a separate integration server?" the prospect thinks:

"Wow, they've clearly integrated with QuickBooks Desktop before. They know the technical constraints. We can trust them to deliver this."

The reality:

You spent 30 minutes with AI reading the QuickBooks Desktop SDK documentation and generating integration-specific questions. You've never actually built this integration before.

But here's the thing: by the time you close the deal, you will understand how to build it. The scoping document becomes your implementation roadmap. The questions you asked reveal the edge cases you need to handle. The sequence diagram guides your architecture.

You're not faking expertise you're rapidly building real expertise with AI as a force multiplier.

When This Approach Works Best

This workflow is especially powerful for:

Legacy systems with extensive documentation nobody reads: Think SAP Business One, QuickBooks Desktop, Sage, Microsoft Dynamics GP. These systems have 500-page PDF manuals that are incredibly detailed but impossibly dense. AI can extract the relevant 5% you actually need.

Industry-specific software you've never touched: Healthcare billing systems, construction management platforms, specialized manufacturing ERPs. You don't need domain expertise you need to ask the right technical questions.

Desktop applications without modern APIs: Many older systems don't have REST APIs but expose data through ODBC, file exports, or SDKs. The documentation exists, but the integration patterns aren't intuitive. AI helps you understand the available options.

Bespoke internal systems: The prospect has a custom-built system with no public documentation. Have them describe it in plain English, and AI can map out potential integration approaches based on common patterns.

The Confidence Factor

Here's what changes when you come prepared with AI-generated research:

Without preparation:

• You ask vague questions
• You hesitate when discussing technical details
• You promise to "get back to them" on basic questions
• The prospect worries you'll learn on their dime

With preparation:

• You ask specific, informed questions
• You discuss technical challenges confidently
• You provide preliminary timeline estimates on the call
• The prospect sees you as an expert in their system

The difference isn't years of experience it's 30 minutes of focused preparation with the right tools.

Best Practices and Warnings

Don't oversell capabilities: Understanding how an integration should work isn't the same as having built it ten times. Be honest about complexity and timelines.

Use this for scoping, not building: AI helps you understand requirements and ask smart questions. It doesn't write production-ready integration code. You still need to build and test properly.

Verify critical details: AI can misinterpret documentation or make assumptions. Double-check anything that seems unusual or contradictory.

Update your knowledge: After building the integration, document what you learned. The next time a similar opportunity comes up, you'll have real expertise to draw from.

Build internal documentation: As you deliver these integrations, maintain a knowledge base. Eventually you won't need AI to scope [System X] integrations because you've actually built five of them.

The Long-Term Play

The first time you integrate with QuickBooks Desktop using this approach, you're using AI to close the knowledge gap. The tenth time, you don't need AI anymore you have battle-tested experience.

But in the meantime, AI lets you confidently pursue opportunities you would have previously passed on or fumbled through.

This isn't about cutting corners. It's about using modern tools to:

• Compress the learning curve
• Ask better discovery questions
• Scope more accurately
• Win deals you'd otherwise lose to competitors with domain expertise

The prospects who need integrations with obscure legacy systems are often underserved precisely because most integration providers won't touch unfamiliar systems. By using AI to rapidly build scoping expertise, you can serve this market confidently.

Final Thoughts

Every integration expert started somewhere. They built their first QuickBooks integration without knowing QuickBooks. Their first SAP integration was a learning experience. The difference now is that you don't need to spend weeks reading documentation to ask intelligent questions.

Use AI to read the boring stuff, extract the critical details, and generate the right questions. Then show up to sales calls sounding like you've done this before. By the time you actually build the integration, you'll have transformed that AI-assisted scoping into genuine expertise.

The scoping document you create becomes your implementation roadmap. The questions you asked reveal the actual requirements. The sequence diagram guides your architecture. And the next time you encounter a similar integration, you'll need AI a little less.

That's not cheating that's learning efficiently.