How Dialpad Built an AI-First Integration System That Enables Configurability and Scale

Goals

• Support long-tail integration requests for 38+ platforms in their backlog
• Reduce the time to create native, enterprise-level integrations that could handle complex multi-tenant scenarios
• Build integration infrastructure for Dialpad’s agentic AI initiative – enabling agents to rapidly define and build integrations with any external tool

Highlights

• 8x faster delivery: Reduced integration timeline from 2 months to 2 weeks end-to-end
• Enterprise complexity solved: One codebase handling multi-tenant deployments – scenarios that were previously “a world of pain”
• AI-first architecture enabled: Became the backbone of their biggest launch, with more agentic integrations built than traditional workflows
• Long-tail unlocked: 38+ integration requests now buildable ‘on the fly’, enabling expansion into new verticals

Company Overview

Founded: 2011
Industry: AI-Powered Communications Intelligence Platform
HQ: United States (Global)
Website: https://www.dialpad.com

Dialpad is the leading AI-powered communications intelligence platform creating human-first, AI-enhanced solutions that will drive the next wave of how businesses communicate with and serve their customers.

With 458 customers using 25 different ATS systems and complex multi-tenant deployments, integrations are fundamental to Dialpad’s business model. Their ~50-person integration team had built 16 native integrations with major platforms like Salesforce and Zendesk. But the real opportunity lay in the long tail. Dialpad had 38+ integration requests in their backlog – but at 2 months per build, the maths didn’t work.

The Challenge

Dialpad’s frameworks were designed for very sophisticated integrations with very specific workflows. Those worked for their major integrations with Salesforce, HubSpot and other complex CRMs, but posed challenges when it came to ramping up very simple integrations. Their existing solutions were too cumbersome to accommodate simple customer requests like ‘one API call to log call details’, making it expensive and time-consuming to scale to all the integrations in their backlog.

Our goal was to basically collapse the time it takes to build all these integrations natively.

— Vineet Sinha, Product Management Lead

The critical requirement was multi-tenancy. As a contact centre solution, each of Dialpad’s integrations were deployed across different customers, all of which had different contact centers. This created complexity at the back end.

A bank has many branches and locations – the retail branch, back office, the number you call when your card gets stolen. Those are different contact centers, and we needed an integration that can handle that level of user nesting and complexity.

— Vineet Sinha, Product Management Lead

Then came the agentic shift. Dialpad’s agentic AI initiative – their biggest product launch – required integrations that AI agents could orchestrate dynamically. This meant the platform needed to support not just traditional workflow-based integrations, but discrete operations that LLMs could understand, call, and chain together in real-time.

Finding the Right Platform

Vineet began by evaluating just under 30 integration vendors, eventually narrowing to Merge, Workato, Tray and Membrane. The Dialpad team built proof-of-concept demos – a Pipedrive CRM integration for call logging – on each platform to stress-test their capabilities.

Initial Technical Requirements

Vineet’s team needed a platform that could handle the core enterprise integration challenges:

• Multi-tenant architecture: Deploy one integration across hundreds of customers, each with different contact centers, user hierarchies, and authentication flows
• Developer-grade observability: Detailed logging and troubleshooting tools to diagnose failures across complex, nested systems
• Environment management: Separate dev, test, and production instances with version control
• Rapid deployment: Fast onboarding and integration with existing systems

The Agentic Requirements

As Michele Sama, Director of Engineering, launched Dialpad’s agentic AI initiative, the requirements evolved.

The success of their AI agent hinged critically on its ability to connect with external tools and systems at scale – Dialpad couldn’t afford to lose deals while spending three months building custom integrations. What they needed was a “teach a man to fish” approach: the ability to empower their field engineers to build integrations on the fly as customer needs arose.

This required entirely new capabilities:

• MCP (Model Context Protocol) support: Native integration with AI agent architectures – the emerging standard for agent-to-system communication
• Action-level abstraction: Structured schemas with clear input/output definitions that LLMs can understand and orchestrate, not just pre-built workflows
• Deep configurability: Programmatic control to build and customize integrations rapidly as the agentic product evolved

These requirements reopened the evaluation and brought N8N into consideration – an open-source platform with growing MCP support that Dialpad already used internally. However, limitations became clear quickly.

Why Other Solutions Failed

As Dialpad stress-tested each platform, critical gaps emerged:

Merge: Architectural constraints

• Batches API calls to reduce their own costs. For customers expecting near-instant call logging, this meant degraded experience.

Workato and Tray: Workflow-first, not agentic-ready

• Built for workflow automation, not multi-tenant enterprise complexity.

• Lacked the developer-centric troubleshooting tools Dialpad needed for debugging integration scenarios across nested contact centers.

• Authentication restrictions created friction.

N8N: Multi-tenancy breaks at scale

• Offered MCP support and open-source flexibility, but its architecture couldn’t handle Dialpad’s multi-tenant reality.

N8N can create a workflow starting with an MCP entrypoint, but to deploy in a multi-tenant environment, you have to copy every change into every customer. If I have 200 workflows and 200 customers, I end up with 40,000 instances. It’s not scalable.

— Michele Sama, Director of Engineering

Why Membrane?

When Michele evaluated Membrane, it addressed every requirement – both the original enterprise needs and the new agentic capabilities. Three critical differentiators emerged:

1. Per-customer configurability

Traditional iPaaS platforms force customers into rigid frameworks. When each customer needs unique logic, this doesn’t work. Membrane’s architecture allows deep customization while maintaining enterprise reliability.

As Michele noted, the configurability is what’s going to unlock the scale for you. The ability to build connectors programmatically gave Dialpad confidence they could enable engineers to build any integration on demand.

2. MCP-native with proper abstraction

Membrane’s action abstraction – originally designed for API operations – naturally fit what LLMs need. It was also flexible enough to enable the Dialpad team to work around the limitations in the way the MCP protocol designs security.

Dialpad’s agentic team built demos and found the abstraction layer provided exactly what AI agents require.

3. Multi-tenant architecture that scales

Unlike N8N’s approach of duplicating workflows per customer, Membrane’s design meant one codebase could support multiple CRMs with minimal modifications. It handles different event types and iterates quickly without managing thousands of separate instances – scaling independently of engineering headcount.

Beyond these core capabilities, Membrane delivered enterprise observability, self-hosting for data sovereignty, and a strategic partnership approach – making it the clear choice for Dialpad’s agentic vision.

Implementation Journey

Dialpad’s core use case was straightforward but critical: when users make phone calls through Dialpad’s contact center platform, those calls need to be logged automatically into whatever CRM system the customer uses. The call details – transcript, recording, duration, outcome, contact information – must flow seamlessly into the customer’s system of record.

Universal Flows

Dialpad built an event-driven system. When a call connects or ends, an event fires with the payload – transcript, recording, metadata. The event triggers a Membrane flow via API.

The flow is event-specific, not integration-specific. One call logging flow handles conditional logic across CRMs: Should this log? Which contact center? What format? How should fields map?

This enables non-linear scale. Add a new CRM? Same flow, different connector. Deploy to three contact centers? Same flow, different tenant settings.

The architecture scales well. We handle different event types quickly and iterate quickly.

Agentic integrations

With Membrane, Dialpad has built more agentic than traditional workflow-based integrations – working directly with our API and MCP server to create 274 actions across 12 apps.

Example: Create Contact in HubSpot

1. The agent performs semantic search against the MCP-tools index (tools from the user’s connected apps)
2. It finds create-contact-hubspot is available because the user has HubSpot connected
3. The LLM identifies that it has all required fields: first name, last name, email, and company
4. The agent calls Membrane’s MCP Server with the tool name and structured input
5. Membrane executes the HubSpot API call via the user’s authenticated connection
6. The contact appears in the user’s HubSpot CRM immediately

Example: Find Vendors in Zoho

1. The agent searches the MCP-tools index for vendor-related tools
2. It identifies search-vendors-zoho is available (user has Zoho connected)
3. The LLM recognizes this is a search/filter operation, not a create operation
4. The agent determines the search parameter: category: “cloud infrastructure”
5. Membrane’s MCP Server calls Zoho’s vendor API with the structured query
6. Results are returned to the agent in structured JSON format

Example: Update Appointments in ServiceNow

1. The agent searches MCP-tools for appointment-related ServiceNow tools
2. It finds update-appointment-servicenow and send-notification-servicenow are both available
3. The LLM recognizes this requires two sequential actions:
   • First: Update the appointment time
   • Second: Trigger a customer notification
4. The agent prompts for any missing information
5. Membrane executes both actions in sequence via the user’s ServiceNow connection

The Results

With Membrane, Dialpad has seen an 8x improvement in speed. Their Integration timeline has collapsed from 2 months to 2 weeks end-to-end, enabling rapid response to customer needs

Dialpad isn’t just building integrations faster – they now have an integration system that scales independently of engineering headcount and enables their agentic AI vision.

The Dialpad team is driving towards a future where enterprise applications simply integrate themselves on demand. Rather than queuing months of engineering work when a customer needs a new connection, an AI agent would be pointed at any API and automatically configure the necessary operations, mappings, and error handling.

If you let people have the tools you will be amazed at what they can build.

— Michele Sama, Director of Engineering

But the ultimate goal is to go even further – enabling AI to build integrations autonomously by analyzing API schemas and runtime behavior. Dialpad chose Membrane because our roadmap of AI agents that can construct connectors and learn from integration patterns aligned with this vision of truly self-integrating applications.

Membrane’s Agent capabilities enable a future where apps are self-integrating:

• AI-powered integration builder: Engineers describe what they want at a high level, and Membrane’s Agent handles the technical implementation – reducing integration build time from weeks to hours
• Visual workflow composition: Intuitive builders that let non-technical stakeholders participate in integration design, accelerating the feedback loop
• Autonomous integration maintenance: AI agents that monitor, diagnose, and repair integration issues without human intervention, ensuring 24/7 reliability
• Real-time adaptation: AI agents that can modify and scale integrations based on changing customer requirements, creating truly frictionless, on-demand connectivity

This vision of frictionless, on-demand integration – where sales teams can close deals knowing that whatever integration the customer needs can be built immediately – represents a fundamental shift from traditional iPaaS approaches.

Michele sees Membrane positioning as an enabler of truly agentic enterprise software. The next evolution isn’t about connecting systems faster – it’s about building integration systems that AI agents can orchestrate, modify, and scale without human intervention.

Dialpad isn’t just using Membrane to build integrations – they’re building the integration layer for AI-first business software.