Chapter 7: Integration & Intelligent Routing

Phase 1: Integration Architecture & Playbook

---

Table of Contents - Phase 1

• 7.1 Integration Architecture Overview
• 7.1.1 Integration Strategy and Principles
• 7.1.2 Integration Patterns and Methods
• 7.1.3 Security and Authentication Framework
• 7.1.4 Integration Layer Architecture
• 7.1.5 Data Flow and Event Management

• 7.1.6 Integration Governance

• 7.2 Integration Playbook

• 7.2.1 Integration Summary Matrix
• 7.2.2 CRM Integrations
• 7.2.3 Workforce Management (WFM) Integrations
• 7.2.4 SIEM and Security Monitoring Integrations
• 7.2.5 Call Recording and Compliance Integrations
• 7.2.6 Ticketing and ITSM Integrations
• 7.2.7 Communication and Collaboration Integrations
• 7.2.8 Analytics and Business Intelligence Integrations
• 7.2.9 Integration Validation and Testing
• 7.2.10 Integration Troubleshooting Guide

---

7.1 Integration Architecture Overview

7.1.1 Integration Strategy and Principles

Overview

The integration architecture for Webex Contact Center migration follows a comprehensive strategy that ensures seamless connectivity between the contact center platform and all enterprise systems. This section establishes the foundational principles and architectural patterns that guide all integration implementations.

Core Integration Principles

1. API-First Design - Prioritize RESTful APIs for all new integrations - Leverage Webex Contact Center public APIs for extensibility - Implement proper API versioning and backward compatibility - Use OpenAPI/Swagger specifications for API documentation - Design for rate limiting and throttling compliance

2. Event-Driven Architecture - Implement real-time event streaming for critical updates - Use webhooks for asynchronous notifications - Leverage message queues for decoupled integration - Enable event replay for reliability and debugging - Implement proper event ordering and idempotency

3. Security-First Approach - Zero-trust security model for all integrations - OAuth 2.0 / OpenID Connect for authentication - API keys and secrets managed in vault solutions - End-to-end encryption for sensitive data - Regular security audits and penetration testing

4. Resilience and Fault Tolerance - Circuit breaker patterns for external system failures - Retry mechanisms with exponential backoff - Graceful degradation when integrations are unavailable - Health checks and monitoring for all integration points - Disaster recovery procedures for integration failures

5. Scalability and Performance - Horizontal scaling for integration middleware - Caching strategies to reduce API calls - Bulk operations for batch data synchronization - Connection pooling for database integrations - Performance baselines and SLA monitoring

6. Maintainability and Observability - Comprehensive logging with correlation IDs - Distributed tracing across integration flows - Metrics and dashboards for integration health - Automated alerting for integration failures - Documentation and runbooks for support teams

Integration Strategy Phases

Phase	Focus	Timeline	Key Deliverables
Phase 0: Assessment	Current state analysis	Weeks 1-2	Integration inventory, dependency mapping
Phase 1: Design	Architecture and patterns	Weeks 3-4	Integration architecture document, API specifications
Phase 2: Core Integrations	CRM, WFM, telephony	Weeks 5-10	CRM integration, WFM integration, PSTN connectivity
Phase 3: Supporting Systems	Recording, SIEM, ITSM	Weeks 11-14	Recording platform, SIEM integration, ITSM tickets
Phase 4: Analytics & AI	Reporting, AI/ML	Weeks 15-18	Analytics platform, AI virtual agent, predictive routing
Phase 5: Optimization	Performance tuning	Weeks 19-20	Performance optimization, monitoring dashboards

Integration Architecture Principles

Principle 1: Minimize Point-to-Point Integrations - Use integration platforms (MuleSoft, Dell Boomi, Azure Logic Apps) when possible - Implement canonical data models for system interoperability - Centralize integration logic for easier maintenance - Avoid tightly coupled integrations that create dependencies

Principle 2: Design for Hybrid On-Premises and Cloud - Support coexistence during Avaya to Webex migration - Enable gradual cutover with bidirectional data sync - Maintain integration functionality during migration phases - Plan for eventual decommissioning of Avaya integrations

Principle 3: Data Privacy and Compliance - Implement data masking for PII in logs and monitoring - Ensure GDPR, CCPA, and regional compliance requirements - Define data retention policies for integration logs - Audit trail for all data access and modifications

Principle 4: Self-Service Integration Capabilities - Low-code/no-code integration tools for business users - Pre-built connectors and templates for common systems - Self-service dashboards for integration monitoring - Documented APIs and SDKs for custom development

Integration Success Criteria

Criterion	Target	Measurement Method
Integration Uptime	99.9%	Monthly availability reports
API Response Time	<500ms (95th percentile)	APM monitoring
Data Synchronization Lag	<5 seconds for real-time	Integration monitoring
Error Rate	<0.1% of transactions	Error logging and alerting
Mean Time to Resolve (MTTR)	<2 hours for critical issues	Incident management system
Integration Test Coverage	>90% of scenarios	Test automation reports

---

7.1.2 Integration Patterns and Methods

Integration Pattern Overview

Webex Contact Center supports multiple integration patterns to accommodate diverse enterprise architectures and use cases. Selecting the appropriate pattern is critical for performance, maintainability, and scalability.

Pattern 1: RESTful API Integration

Description Synchronous HTTP-based integration using REST APIs with JSON payloads. This is the most common pattern for CRM, ticketing systems, and custom applications.

Use Cases - CRM screen pops (Salesforce, Microsoft Dynamics, ServiceNow) - Customer profile lookups during call routing - Real-time ticket creation and updates - Agent desktop custom widgets

Architecture

┌─────────────────┐         ┌──────────────────┐         ┌─────────────────┐
│  Webex Contact  │         │   Integration    │         │   Target System │
│     Center      │◄───────►│    Middleware    │◄───────►│   (CRM/ITSM)   │
│   (API Client)  │  HTTPS  │  (API Gateway)   │  HTTPS  │                 │
└─────────────────┘         └──────────────────┘         └─────────────────┘
         │                           │                             │
         │                           │                             │
         ▼                           ▼                             ▼
    OAuth 2.0                   Rate Limiting                  API Endpoint
    Bearer Token                Circuit Breaker                Authentication

Implementation Steps

1. API Discovery and Documentation
2. Obtain API documentation from target system vendor
3. Review authentication methods (OAuth 2.0, API keys, SAML)
4. Identify required API endpoints (GET, POST, PUT, DELETE)

5. Document rate limits and throttling policies

6. Middleware Configuration

7. Deploy API gateway or integration platform
8. Configure authentication credentials securely
9. Implement rate limiting and retry logic

10. Set up connection pooling and timeout values

11. Webex Connect Flow Design

12. Create HTTP Request nodes in Webex Connect
13. Configure request headers (Authorization, Content-Type)
14. Build request payload with dynamic variables

15. Parse response and handle error codes

16. Error Handling and Resilience

17. Implement retry logic with exponential backoff
18. Circuit breaker pattern for repeated failures
19. Fallback behavior when API is unavailable
20. Error logging with correlation IDs

Validation Steps

• Test successful API call with valid credentials
• Verify error handling for 4xx and 5xx HTTP codes
• Validate retry mechanism under API failure
• Confirm timeout handling (default: 30 seconds)
• Test with production-like data volumes
• Verify response time meets SLA (<500ms)

Troubleshooting

Issue	Root Cause	Resolution
401 Unauthorized	Invalid or expired credentials	Refresh OAuth token or validate API key
429 Too Many Requests	Exceeded rate limit	Implement rate limiting, reduce call frequency
504 Gateway Timeout	Target system slow response	Increase timeout, investigate target system performance
CORS errors	Browser security policy	Configure CORS headers on API gateway

---

Pattern 2: Webhook-Based Event Integration

Description Asynchronous push-based integration where Webex Contact Center sends HTTP POST requests to external endpoints when events occur (e.g., call ended, agent status changed).

Use Cases - Real-time call recording triggers - Agent state synchronization to workforce management - Analytics and reporting data export - Custom notifications and alerting

Architecture

┌─────────────────┐         ┌──────────────────┐         ┌─────────────────┐
│  Webex Contact  │         │   Webhook        │         │   External      │
│     Center      ├────────►│   Receiver       ├────────►│   System        │
│  (Event Source) │  HTTPS  │   (API Endpoint) │         │   (Processor)   │
└─────────────────┘         └──────────────────┘         └─────────────────┘
         │                           │                             │
         │                           │                             │
         ▼                           ▼                             ▼
    Event Trigger               Webhook Signature              Data Processing
    (Call End, etc.)            Validation                     (Store, Forward)

Implementation Steps

1. Webhook Endpoint Creation
2. Deploy HTTPS endpoint to receive webhook events
3. Implement webhook signature verification (HMAC-SHA256)
4. Configure authentication (API key, mutual TLS)

5. Set up request payload validation schema

6. Event Subscription Configuration

7. Navigate to Webex Contact Center Admin Portal
8. Configure webhook URL and authentication
9. Select event types to subscribe (call events, agent events)

10. Configure retry policy and failure handling

11. Event Processing Logic

12. Parse incoming JSON payload
13. Validate event schema and required fields
14. Transform data for target system format

15. Store event in queue for asynchronous processing

16. Reliability and Monitoring

17. Implement idempotency to handle duplicate events
18. Log all incoming events with correlation IDs
19. Monitor webhook delivery success rate
20. Alert on repeated webhook failures

Validation Steps

• Test webhook with sample event payload
• Verify signature validation with correct secret
• Confirm event is processed within SLA (<10 seconds)
• Test idempotency with duplicate event delivery
• Validate error response handling (4xx, 5xx)
• Verify retry mechanism after transient failures

Troubleshooting

Issue	Root Cause	Resolution
Webhook not received	Firewall blocking inbound HTTPS	Whitelist Webex IP ranges on firewall
Signature validation failed	Incorrect webhook secret	Re-generate and update webhook secret
Duplicate events processed	No idempotency check	Implement event ID deduplication
High latency	Slow processing in receiver	Offload to async queue, return 200 OK quickly

---

Pattern 3: Pre-Built Connector Integration

Description Native connectors provided by Webex Contact Center or third-party vendors that simplify integration with popular platforms (e.g., Salesforce Service Cloud Voice, Microsoft Teams).

Use Cases - Salesforce CRM integration (Service Cloud Voice) - Microsoft Dynamics 365 integration - ServiceNow ITSM integration - Workforce management platforms (NICE, Verint)

Architecture

┌─────────────────┐         ┌──────────────────┐         ┌─────────────────┐
│  Webex Contact  │         │   Pre-Built      │         │   Target        │
│     Center      │◄───────►│   Connector      │◄───────►│   Platform      │
│                 │         │   (Managed by    │         │   (CRM/WFM)     │
└─────────────────┘         │    Cisco/Vendor) │         └─────────────────┘
         │                  └──────────────────┘                  │
         │                           │                            │
         ▼                           ▼                            ▼
    API Configuration            Data Mapping                 OAuth/SAML
    (No custom code)             Field Sync                   Authentication

Implementation Steps

1. Connector Provisioning
2. Purchase and activate connector license
3. Install connector package (e.g., Salesforce managed package)
4. Configure authentication (OAuth 2.0, connected app)

5. Map organizational units and user roles

6. Field Mapping and Configuration

7. Define field mappings (Webex Contact Center ↔ CRM)
8. Configure screen pop rules and layouts
9. Set up click-to-dial and activity logging

10. Enable contact record creation and updates

11. User Provisioning and Permissions

12. Assign licenses to agents and supervisors
13. Configure role-based access control (RBAC)
14. Set up single sign-on (SSO) if available

15. Train users on integrated desktop experience

16. Testing and Validation

17. Test screen pop with various call scenarios
18. Validate data synchronization (inbound, outbound)
19. Verify activity logging and call history
20. Confirm reporting and analytics integration

Validation Steps

• Test inbound call screen pop with existing contact
• Test inbound call with new contact (auto-create)
• Validate click-to-dial from CRM interface
• Confirm call activity logging in CRM timeline
• Test agent status synchronization
• Verify reporting data in CRM dashboards

Troubleshooting

Issue	Root Cause	Resolution
Screen pop not appearing	Field mapping misconfiguration	Verify ANI field mapping and search logic
Click-to-dial fails	Telephony permissions in CRM	Grant call control permissions to user profile
Data not syncing	OAuth token expired	Re-authenticate connector with CRM
Performance degradation	Too many custom fields	Optimize field mapping, use selective sync

---

Pattern 4: Middleware Integration Platform

Description Enterprise integration platforms (e.g., MuleSoft, Dell Boomi, Azure Logic Apps) that provide visual design tools, pre-built connectors, and orchestration capabilities for complex integration scenarios.

Use Cases - Multi-system data synchronization - Complex business process orchestration - Legacy system integration (SOAP, FTP, database) - Data transformation and enrichment

Architecture

┌─────────────────┐         ┌──────────────────────────────────┐         ┌─────────────────┐
│  Webex Contact  │         │   Integration Middleware         │         │   Enterprise    │
│     Center      │◄───────►│   (MuleSoft/Boomi/Logic Apps)   │◄───────►│   Systems       │
│                 │  REST   │                                  │  Various│   (CRM, ERP,    │
└─────────────────┘  API    │  ┌────────────────────────┐     │ Protocols│    WFM, etc.)  │
                             │  │  Orchestration Engine  │     │         └─────────────────┘
                             │  ├────────────────────────┤     │
                             │  │  Data Transformation   │     │
                             │  ├────────────────────────┤     │
                             │  │  Error Handling        │     │
                             │  ├────────────────────────┤     │
                             │  │  Logging & Monitoring  │     │
                             │  └────────────────────────┘     │
                             └──────────────────────────────────┘

Implementation Steps

1. Platform Selection and Setup
2. Evaluate integration platform options (MuleSoft, Boomi, Logic Apps)
3. Provision integration environment (dev, test, prod)
4. Configure connectivity to Webex Contact Center APIs

5. Set up connections to target enterprise systems

6. Integration Flow Design

7. Map business requirements to integration flows
8. Design data transformation and mapping logic
9. Implement error handling and retry mechanisms

10. Configure logging and monitoring

11. API Management and Security

12. Expose reusable APIs through API gateway
13. Implement OAuth 2.0 or API key authentication
14. Configure rate limiting and throttling

15. Set up API documentation and developer portal

16. Deployment and Operations

17. Deploy integration flows to production
18. Configure alerts and notifications
19. Set up operational dashboards
20. Document runbooks for support teams

Validation Steps

• Test end-to-end integration flow with sample data
• Verify data transformation accuracy
• Validate error handling and retry logic
• Confirm logging and monitoring dashboards
• Test failover and disaster recovery procedures
• Verify performance under expected load

Troubleshooting

Issue	Root Cause	Resolution
Integration flow timeout	Complex transformation logic	Optimize transformation, increase timeout
Data loss during failure	No retry mechanism	Implement retry with message queue
High latency	Sequential processing	Enable parallel processing where possible
Monitoring gaps	Insufficient logging	Add logging at all integration points

---

Pattern 5: Database Direct Integration

Description Direct database connectivity for real-time or batch data synchronization. Used when APIs are not available or for high-volume data exchange.

Use Cases - Historical reporting data export - Customer data synchronization from enterprise data warehouse - Agent roster and skills import from HR systems - Call detail records (CDR) export to billing systems

Architecture

┌─────────────────┐         ┌──────────────────┐         ┌─────────────────┐
│  Webex Contact  │         │   ETL Tool       │         │   Enterprise    │
│     Center      │────────►│   (SSIS, Talend, │────────►│   Database      │
│   (Data Export) │  SFTP/  │    Azure Data    │  JDBC/  │   (SQL Server,  │
│                 │  API    │    Factory)      │  ODBC   │    Oracle, etc) │
└─────────────────┘         └──────────────────┘         └─────────────────┘
         │                           │                             │
         │                           │                             │
         ▼                           ▼                             ▼
    Scheduled Export            Data Transformation          Database Load
    (Daily, Hourly)             Validation                   (Insert/Update)

Implementation Steps

1. Database Connectivity Setup
2. Configure database connection strings
3. Set up service accounts with least privilege
4. Establish VPN or private connectivity for security

5. Test database connectivity and permissions

6. ETL Job Design

7. Design extraction queries from Webex Contact Center
8. Implement data transformation logic
9. Configure incremental vs full load strategy

10. Set up error handling and data validation

11. Scheduling and Orchestration

12. Configure job scheduler (cron, Windows Task Scheduler)
13. Set up dependency management between jobs
14. Implement job monitoring and alerting

15. Configure retry logic for failed jobs

16. Data Quality and Validation

17. Implement data quality checks (completeness, accuracy)
18. Set up reconciliation reports
19. Configure alerts for data anomalies
20. Document data lineage and transformation rules

Validation Steps

• Test database connectivity and authentication
• Verify data extraction completeness
• Validate data transformation accuracy
• Confirm incremental load logic (new/updated records)
• Test error handling for database failures
• Verify data reconciliation reports

Troubleshooting

Issue	Root Cause	Resolution
Connection timeout	Database firewall rules	Whitelist ETL server IP address
Slow query performance	Missing indexes	Optimize queries, add indexes
Data duplication	No primary key check	Implement upsert logic (insert or update)
Job failure overnight	Database maintenance window	Adjust job schedule to avoid maintenance

---

7.1.3 Security and Authentication Framework

Security Architecture Overview

The integration security framework for Webex Contact Center ensures confidentiality, integrity, and availability of data exchanged between systems. All integrations must adhere to enterprise security policies and compliance requirements.

Authentication Methods

Method 1: OAuth 2.0 (Recommended)

OAuth 2.0 is the industry-standard protocol for authorization and the preferred method for Webex Contact Center integrations.

OAuth 2.0 Grant Types

Grant Type	Use Case	Security Level	Typical Users
Authorization Code	Web applications, CRM connectors	High	End users, agents
Client Credentials	Machine-to-machine integrations	High	Backend services, APIs
Implicit	Single-page applications (deprecated)	Low	Legacy web apps
Resource Owner Password	Legacy systems, trusted applications	Medium	Batch jobs, scripts

OAuth 2.0 Implementation Flow (Authorization Code)

1. Application redirects user to Webex authorization endpoint
   GET https://webexapis.com/v1/authorize?
       client_id=YOUR_CLIENT_ID&
       response_type=code&
       redirect_uri=https://yourapp.com/callback&
       scope=spark:all spark-compliance:webhooks_read

2. User authenticates and grants permissions

3. Webex redirects back with authorization code
   https://yourapp.com/callback?code=AUTHORIZATION_CODE

4. Application exchanges code for access token
   POST https://webexapis.com/v1/access_token
   Body: 
     grant_type=authorization_code&
     client_id=YOUR_CLIENT_ID&
     client_secret=YOUR_CLIENT_SECRET&
     code=AUTHORIZATION_CODE&
     redirect_uri=https://yourapp.com/callback

5. Webex returns access token and refresh token
   {
     "access_token": "ZDI3MGEyYz...",
     "token_type": "Bearer",
     "expires_in": 3600,
     "refresh_token": "MDEyMzQ1Njc..."
   }

6. Application uses access token for API calls
   GET https://webexapis.com/v1/people/me
   Header: Authorization: Bearer ZDI3MGEyYz...

OAuth 2.0 Configuration Checklist

• Register application in Webex developer portal
• Configure redirect URIs (whitelist)
• Request appropriate OAuth scopes (least privilege)
• Implement token refresh logic before expiration
• Securely store client secrets (vault, key management)
• Implement token revocation on logout
• Log authentication events for audit

Token Management Best Practices

Practice	Description	Implementation
Token Storage	Never store tokens in client-side code or logs	Use secure backend storage (encrypted database, vault)
Token Expiration	Access tokens expire (typically 1 hour)	Implement automatic refresh using refresh token
Token Revocation	Revoke tokens on security events	Call revoke endpoint when user logs out or credentials change
Scope Minimization	Request only required OAuth scopes	Review and remove unnecessary scopes during integration design

---

Method 2: API Keys

API keys are simpler than OAuth but less secure. Use only for low-risk integrations or when OAuth is not supported.

API Key Security Requirements

• Store API keys in environment variables or secret management vault
• Rotate API keys every 90 days
• Never commit API keys to version control systems
• Use different API keys for dev, test, and production environments
• Monitor API key usage for anomalies

API Key Usage Example

GET https://api.example.com/v1/contacts
Headers:
  X-API-Key: your-api-key-here
  Content-Type: application/json

---

Method 3: SAML 2.0 / Single Sign-On (SSO)

SAML 2.0 enables federated authentication between Webex Contact Center and enterprise identity providers (IdP) like Okta, Azure AD, Ping Identity.

SAML Integration Architecture

┌─────────────┐        ┌──────────────┐        ┌─────────────────┐
│    User     │        │   Identity   │        │  Webex Contact  │
│   (Agent)   │◄──────►│   Provider   │◄──────►│     Center      │
│             │  SAML  │  (Okta, AD)  │  SAML  │  (SP)           │
└─────────────┘        └──────────────┘        └─────────────────┘
       │                      │                         │
       ▼                      ▼                         ▼
   Login Request         Authentication            Assertion
   to Webex             SAML Response              Verification

SAML Configuration Steps

1. Identity Provider Configuration
2. Configure Webex Contact Center as Service Provider (SP)
3. Exchange SAML metadata (XML files)
4. Map SAML attributes to Webex user fields

5. Configure name ID format (email, user principal name)

6. Attribute Mapping

SAML Attribute	Webex Contact Center Field	Required
email	Email address	Yes
firstName	First name	Yes
lastName	Last name	Yes
roles	User role (Agent, Supervisor, Admin)	Yes
team	Team assignment	No

1. Just-In-Time (JIT) Provisioning
2. Enable automatic user creation on first login
3. Map SAML attributes to user profile fields
4. Assign default roles and permissions
5. Configure user deprovisioning rules

SAML Troubleshooting

Issue	Root Cause	Resolution
User cannot login	SAML assertion signature validation failed	Verify IdP certificate in Webex admin portal
User created with wrong role	SAML attribute mapping incorrect	Review and correct attribute mapping rules
Infinite redirect loop	SSO configuration mismatch	Verify ACS URL and Entity ID configuration
Session timeout too short	Session duration misconfigured	Adjust session timeout in IdP settings

---

Encryption and Data Protection

Transport Layer Security (TLS)

All integrations must use TLS 1.2 or higher for data in transit.

TLS Requirements

• Minimum TLS version: 1.2 (TLS 1.3 preferred)
• Certificate authority: Public CA (Let's Encrypt, DigiCert, etc.)
• Certificate key length: 2048-bit RSA or 256-bit ECDSA
• Cipher suites: Strong ciphers only (no RC4, DES, MD5)

TLS Configuration Example (NGINX)

server {
    listen 443 ssl http2;
    server_name api.example.com;

    # TLS certificate and key
    ssl_certificate /etc/ssl/certs/api.example.com.crt;
    ssl_certificate_key /etc/ssl/private/api.example.com.key;

    # TLS protocols
    ssl_protocols TLSv1.2 TLSv1.3;

    # Strong cipher suites
    ssl_ciphers 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256';
    ssl_prefer_server_ciphers on;

    # HSTS (HTTP Strict Transport Security)
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
}

---

Data Encryption at Rest

Sensitive data stored in integration middleware or databases must be encrypted at rest.

Encryption Requirements

Data Type	Encryption Method	Key Management
PII (Personally Identifiable Information)	AES-256 encryption	Customer-managed keys (CMK) in cloud KMS
PCI Data (Credit card, CVV)	Tokenization preferred, AES-256 if stored	PCI-DSS compliant key management
Authentication Credentials	Hashed with bcrypt/Argon2 (not reversible)	Not applicable (hashing, not encryption)
API Keys / Secrets	AES-256 encryption	HashiCorp Vault, Azure Key Vault, AWS KMS

Data Masking for Logging

Implement data masking to prevent sensitive data exposure in logs and monitoring systems.

Masking Rules

// Example: Mask credit card number in logs
function maskCreditCard(ccNumber) {
  return ccNumber.replace(/\d(?=\d{4})/g, "*");
}

// Input: 1234567812345678
// Output: ************5678

// Example: Mask email address
function maskEmail(email) {
  const [localPart, domain] = email.split('@');
  return `${localPart.charAt(0)}***@${domain}`;
}

// Input: john.doe@example.com
// Output: j***@example.com

---

Network Security and Firewall Rules

IP Whitelisting

Restrict inbound and outbound connections to authorized IP addresses.

Webex Contact Center IP Ranges (US Region)

Service	IP Ranges	Ports	Protocol
API Endpoints	170.72.0.0/16, 170.133.0.0/16	443	HTTPS
Media (Voice)	64.68.96.0/19, 66.114.160.0/20	8000-48199	UDP
Webhooks (Outbound)	170.72.0.0/16	443	HTTPS
Control Signaling	64.68.96.0/19	5060-5062	TCP/TLS

Firewall Configuration Example (Palo Alto)

<entry name="Webex-Contact-Center-Inbound">
  <source><member>170.72.0.0/16</member></source>
  <destination><member>Internal-API-Server</member></destination>
  <service><member>service-https</member></service>
  <action>allow</action>
  <log-start>yes</log-start>
  <log-end>yes</log-end>
</entry>

---

Web Application Firewall (WAF)

Deploy WAF to protect integration APIs from OWASP Top 10 vulnerabilities.

WAF Rules

• SQL injection protection
• Cross-site scripting (XSS) prevention
• Rate limiting and DDoS protection
• Bot detection and mitigation
• Geographic access restrictions

---

Compliance and Audit Requirements

Compliance Frameworks

Framework	Requirements	Integration Impact
PCI-DSS	No credit card storage in logs or middleware	Tokenize credit card data before integration
GDPR	Data subject access, right to erasure	Implement data deletion APIs for customer requests
HIPAA	PHI encryption, access logging	Use BAA-compliant integration platforms
SOC 2 Type II	Audit logging, change management	Log all integration configuration changes

Audit Logging Requirements

All integrations must log the following events:

• Authentication attempts (success and failure)
• API calls (endpoint, user, timestamp, response code)
• Data access and modifications
• Configuration changes
• Error and exception events

Audit Log Format (JSON)

{
  "timestamp": "2025-11-09T10:15:30Z",
  "event_type": "API_CALL",
  "user": "service-account@example.com",
  "source_ip": "10.0.1.100",
  "integration": "Salesforce-CRM",
  "endpoint": "/api/v1/contacts",
  "method": "POST",
  "status_code": 200,
  "response_time_ms": 345,
  "correlation_id": "abc123-def456-ghi789"
}

Audit Log Retention

• Production logs: 2 years minimum (7 years for financial services)
• Debug logs: 90 days
• Security logs: 2 years minimum
• Compliance logs: Per regulatory requirements

---

7.1.4 Integration Layer Architecture

Integration Layer Components

The integration layer provides a centralized, scalable, and secure framework for all Webex Contact Center integrations. It decouples the contact center platform from enterprise systems, enabling flexibility and maintainability.

Architecture Diagram

┌──────────────────────────────────────────────────────────────────┐
│                    Webex Contact Center                          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │   Webex      │  │   Webex      │  │   Webex      │          │
│  │   Connect    │  │  Management  │  │  Analyzer    │          │
│  │  (IVR/Flow)  │  │   Portal     │  │  (Reporting) │          │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘          │
│         │                  │                  │                  │
└─────────┼──────────────────┼──────────────────┼──────────────────┘
          │                  │                  │
          │ REST APIs        │ Admin APIs       │ Reporting APIs
          ▼                  ▼                  ▼
┌──────────────────────────────────────────────────────────────────┐
│                  Integration Layer (Middleware)                  │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │              API Gateway & Load Balancer                   │ │
│  │  - Rate Limiting  - Authentication  - TLS Termination      │ │
│  └────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │  Integration │  │   Event      │  │   Data       │         │
│  │  Orchestration│  │  Processing  │  │  Transformation│        │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘         │
│         │                  │                  │                  │
│  ┌──────┴──────────────────┴──────────────────┴───────┐        │
│  │         Logging, Monitoring & Alerting              │        │
│  └─────────────────────────────────────────────────────┘        │
└──────────────────────────────────────────────────────────────────┘
          │                  │                  │
          ▼                  ▼                  ▼
┌──────────────────────────────────────────────────────────────────┐
│                   Enterprise Systems                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
│  │   CRM    │  │   WFM    │  │   SIEM   │  │  Other   │       │
│  │(Salesforce│  │ (NICE)  │  │(Splunk)  │  │ Systems  │       │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘       │
└──────────────────────────────────────────────────────────────────┘

---

API Gateway Component

Purpose The API gateway serves as the single entry point for all integration traffic, providing centralized security, rate limiting, and observability.

Key Features

1. Authentication and Authorization
2. OAuth 2.0 token validation
3. API key management
4. JWT token verification

5. Role-based access control (RBAC)

6. Rate Limiting and Throttling

7. Per-client rate limits (e.g., 1000 requests/minute)
8. Burst handling with token bucket algorithm
9. Circuit breaker for failing backend services

10. Quota management for API consumers

11. Request Transformation

12. Protocol translation (REST ↔ SOAP)
13. Header manipulation and injection
14. Request/response payload transformation

15. API versioning support

16. Monitoring and Analytics

17. Request/response logging
18. Latency tracking (p50, p95, p99)
19. Error rate monitoring
20. API usage analytics

API Gateway Configuration Example (Kong)

services:
  - name: salesforce-crm
    url: https://api.salesforce.com
    routes:
      - name: crm-route
        paths:
          - /api/v1/crm
    plugins:
      - name: rate-limiting
        config:
          minute: 1000
          policy: local
      - name: key-auth
        config:
          key_names: [apikey]
      - name: request-transformer
        config:
          add:
            headers:
              - X-Correlation-ID: $(uuid)

---

Integration Orchestration Engine

Purpose Orchestration engine coordinates multi-step integration workflows, handles retries, and manages state across distributed systems.

Capabilities

1. Workflow Orchestration
2. Sequential and parallel task execution
3. Conditional branching based on business logic
4. Error handling and compensation transactions

5. Long-running workflow support (saga pattern)

6. State Management

7. Workflow instance tracking
8. Checkpointing for recovery
9. Idempotency key management

10. State persistence in durable storage

11. Retry and Error Handling

12. Configurable retry policies (exponential backoff)
13. Dead letter queue for failed messages
14. Compensation actions for rollback
15. Circuit breaker integration

Orchestration Workflow Example (Apache Airflow DAG)

from airflow import DAG
from airflow.operators.http_operator import SimpleHttpOperator
from airflow.operators.python_operator import PythonOperator
from datetime import datetime, timedelta

default_args = {
    'owner': 'integration-team',
    'retries': 3,
    'retry_delay': timedelta(minutes=5),
}

with DAG('customer_sync_workflow',
         default_args=default_args,
         schedule_interval='@hourly',
         start_date=datetime(2025, 1, 1)) as dag:

    # Step 1: Fetch customers from Webex Contact Center
    fetch_customers = SimpleHttpOperator(
        task_id='fetch_customers',
        http_conn_id='webex_cc',
        endpoint='/api/v1/customers',
        method='GET',
        headers={'Authorization': 'Bearer {{ var.value.webex_token }}'},
    )

    # Step 2: Transform customer data
    def transform_data(**context):
        customers = context['task_instance'].xcom_pull(task_ids='fetch_customers')
        # Transform logic here
        return transformed_customers

    transform_customers = PythonOperator(
        task_id='transform_customers',
        python_callable=transform_data,
        provide_context=True,
    )

    # Step 3: Load customers into CRM
    load_to_crm = SimpleHttpOperator(
        task_id='load_to_crm',
        http_conn_id='salesforce_crm',
        endpoint='/services/data/v50.0/composite/sobjects',
        method='POST',
        data='{{ task_instance.xcom_pull(task_ids="transform_customers") }}',
    )

    # Workflow dependencies
    fetch_customers >> transform_customers >> load_to_crm

---

Event Processing Component

Purpose Event processing component handles asynchronous events from Webex Contact Center and other systems, enabling real-time integration and event-driven architectures.

Event Processing Architecture

Webex Contact Center Events
         │
         ▼
    Event Router
         │
         ├──────────┬──────────┬──────────┐
         ▼          ▼          ▼          ▼
    Queue 1    Queue 2    Queue 3    DLQ
    (Call      (Agent     (System    (Failed
     Events)    Events)    Events)    Events)
         │          │          │          │
         ▼          ▼          ▼          ▼
   Consumer 1  Consumer 2  Consumer 3  Alert
   (Recording) (WFM Sync) (SIEM Fwd)  System

Event Types and Handlers

Event Type	Description	Target System	Processing Time
call.started	Call initiated	SIEM, Recording	Real-time (<1s)
call.ended	Call completed	CRM, Analytics	Near real-time (<5s)
agent.state_changed	Agent status update	WFM, Dashboard	Real-time (<1s)
queue.alert	Queue threshold breach	Alerting system	Real-time (<1s)
ivr.completed	IVR flow completed	Analytics	Batch (hourly)

Event Processing Configuration (Apache Kafka)

topics:
  - name: webex-call-events
    partitions: 6
    replication_factor: 3
    config:
      retention.ms: 604800000  # 7 days
      compression.type: lz4

consumers:
  - name: call-recording-consumer
    group_id: recording-processors
    topics:
      - webex-call-events
    config:
      auto.offset.reset: earliest
      enable.auto.commit: false  # Manual commit for exactly-once
      max.poll.records: 100

---

Data Transformation Component

Purpose Data transformation component normalizes data formats between Webex Contact Center and enterprise systems, ensuring data quality and consistency.

Transformation Capabilities

1. Format Conversion
2. JSON ↔ XML ↔ CSV
3. Protocol buffers serialization

4. SOAP envelope wrapping/unwrapping

5. Data Mapping

6. Field-level mapping with default values
7. Complex object flattening/nesting

8. Array and list transformations

9. Data Validation

10. Schema validation (JSON Schema, XSD)
11. Business rule validation

12. Data quality checks (completeness, accuracy)

13. Data Enrichment

14. Lookup from reference data systems
15. Calculated fields and derived values
16. Geolocation and timezone conversions

Transformation Example (XSLT for Salesforce)

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/WebexContact">
    <sObjects xmlns="http://www.force.com/2009/06/asyncapi/dataload">
      <type>Contact</type>
      <xsl:for-each select="Contact">
        <sObject>
          <FirstName><xsl:value-of select="firstName"/></FirstName>
          <LastName><xsl:value-of select="lastName"/></LastName>
          <Email><xsl:value-of select="email"/></Email>
          <Phone><xsl:value-of select="phoneNumber"/></Phone>
          <Webex_Contact_ID__c><xsl:value-of select="@id"/></Webex_Contact_ID__c>
        </sObject>
      </xsl:for-each>
    </sObjects>
  </xsl:template>
</xsl:stylesheet>

---

7.1.5 Data Flow and Event Management

Data Flow Patterns

Pattern 1: Synchronous Request-Response

Used for real-time operations where immediate response is required (e.g., CRM screen pop during inbound call).

Sequence Diagram

Agent Desktop    Webex Connect    API Gateway    CRM System
    │                 │                │              │
    │─────Call───────►│                │              │
    │                 │────Lookup─────►│              │
    │                 │                │───Query─────►│
    │                 │                │◄───Data─────│
    │                 │◄───Contact─────│              │
    │◄───Screen Pop───│                │              │
    │                 │                │              │

Characteristics - Latency: <500ms end-to-end - Timeout: 30 seconds default - Error handling: Immediate retry or fallback - Use case: CRM lookups, validation checks

---

Pattern 2: Asynchronous Event-Driven

Used for non-blocking operations where immediate response is not required (e.g., post-call analytics).

Sequence Diagram

Webex CC     Event Bus    Analytics    Data Warehouse
    │            │            │               │
    │──CallEnd──►│            │               │
    │            │──Publish──►│               │
    │            │            │──Transform───►│
    │            │            │               │
    │            │◄──Ack──────│               │
    │            │            │               │

Characteristics - Latency: Seconds to minutes (acceptable) - Processing: Eventually consistent - Error handling: Retry with backoff, dead letter queue - Use case: Analytics, reporting, batch updates

---

Pattern 3: Batch Data Synchronization

Used for large-volume data exchange on scheduled intervals (e.g., nightly customer roster sync).

Sequence Diagram

Scheduler    ETL Job    Webex CC API    Data Warehouse
    │           │            │                │
    │─Trigger──►│            │                │
    │           │──Extract──►│                │
    │           │◄──Data─────│                │
    │           │─Transform─►│                │
    │           │────Load────────────────────►│
    │           │                              │
    │◄─Complete─│                              │

Characteristics - Frequency: Hourly, daily, weekly - Volume: Thousands to millions of records - Error handling: Full/partial retry, reconciliation report - Use case: Agent roster, skills matrix, historical data

---

Event Management Strategy

Event Schema Design

All events follow a standard schema for consistency and ease of processing.

Standard Event Schema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["eventId", "eventType", "timestamp", "source", "data"],
  "properties": {
    "eventId": {
      "type": "string",
      "description": "Unique event identifier (UUID)"
    },
    "eventType": {
      "type": "string",
      "enum": ["call.started", "call.ended", "agent.state_changed", "queue.alert"],
      "description": "Event type identifier"
    },
    "timestamp": {
      "type": "string",
      "format": "date-time",
      "description": "Event occurrence timestamp (ISO 8601)"
    },
    "source": {
      "type": "string",
      "description": "Event source system (e.g., webex-contact-center)"
    },
    "correlationId": {
      "type": "string",
      "description": "Correlation ID for related events"
    },
    "data": {
      "type": "object",
      "description": "Event-specific payload"
    },
    "metadata": {
      "type": "object",
      "description": "Additional context and metadata"
    }
  }
}

Example: Call Ended Event

{
  "eventId": "550e8400-e29b-41d4-a716-446655440000",
  "eventType": "call.ended",
  "timestamp": "2025-11-09T10:30:45.123Z",
  "source": "webex-contact-center",
  "correlationId": "call-12345",
  "data": {
    "callId": "12345",
    "sessionId": "session-67890",
    "ani": "+15551234567",
    "dnis": "+18005551000",
    "queue": "support-tier1",
    "agent": {
      "id": "agent-001",
      "name": "John Doe",
      "email": "john.doe@example.com"
    },
    "duration": {
      "total": 420,
      "ringing": 15,
      "talk": 380,
      "hold": 25
    },
    "disposition": "resolved",
    "wrapUpCode": "technical-support",
    "recording": {
      "recordingId": "rec-98765",
      "url": "https://recordings.webex.com/rec-98765"
    }
  },
  "metadata": {
    "region": "us-east-1",
    "tenant": "customer-abc",
    "version": "1.0"
  }
}

---

Event Delivery Guarantees

Delivery Guarantee	Description	Use Case	Complexity
At-Most-Once	Event may be lost, not duplicated	Low-value events, logs	Low
At-Least-Once	Event delivered one or more times (duplicates possible)	Most integrations	Medium
Exactly-Once	Event delivered exactly once (no loss, no duplicates)	Financial transactions, critical updates	High

Implementing Exactly-Once Delivery

1. Idempotency Keys
2. Include unique key in event payload
3. Receiver checks if key already processed
4. Skip processing if duplicate detected

{
  "eventId": "550e8400-e29b-41d4-a716-446655440000",
  "idempotencyKey": "call-12345-ended-20251109T103045",
  "data": { ... }
}

1. Database Transactions
2. Store processed event IDs in database
3. Check existence before processing
4. Wrap processing in database transaction

BEGIN TRANSACTION;

-- Check if event already processed
SELECT COUNT(*) FROM processed_events WHERE event_id = '550e8400-...';

-- If not processed, insert and process
IF @@ROWCOUNT = 0
BEGIN
  INSERT INTO processed_events (event_id, processed_at) VALUES ('550e8400-...', GETDATE());
  -- Process event logic here
END

COMMIT TRANSACTION;

---

Event Ordering

Ensure events are processed in the correct order when sequence matters.

Strategies for Event Ordering

1. Partition by Key (Kafka, EventBridge)
2. Assign events to partitions based on key (e.g., callId)
3. Events with same key always go to same partition

4. Single consumer per partition maintains order

5. Sequence Numbers

6. Include sequence number in event payload
7. Receiver processes events in sequence order

8. Buffer out-of-order events for reordering

9. Timestamp-Based Ordering

10. Use event timestamp for ordering
11. Account for clock skew across systems
12. Consider event generation vs publish time

---

7.1.6 Integration Governance

Governance Framework

Integration governance ensures consistency, quality, and compliance across all integrations throughout their lifecycle.

Governance Pillars

1. Standards and Policies
2. Change Management
3. Quality Assurance
4. Security and Compliance
5. Performance Management
6. Documentation and Knowledge Management

---

Integration Standards

Naming Conventions

Element	Convention	Example
Integration Name	{source}-{target}-{purpose}	webex-salesforce-screenpo
API Endpoint	/api/v{version}/{resource}	/api/v1/contacts
Event Type	{domain}.{action}	call.started, agent.state_changed
Configuration Key	{integration}.{component}.{property}	salesforce.auth.client_id

API Versioning Policy

• Use semantic versioning (v1, v2, v3)
• Maintain backward compatibility within major version
• Deprecation notice: 6 months before removal
• Support N-1 versions (current + previous major version)

---

Change Management Process

Integration Change Categories

Category	Description	Approval Required	Downtime
Low Risk	Configuration changes, parameter tuning	Team lead	No
Medium Risk	New integration endpoints, field mapping changes	CAB review	Possible
High Risk	Major version upgrades, architecture changes	CAB approval	Planned
Emergency	Security patches, critical bug fixes	Post-implementation review	Possible

Change Advisory Board (CAB) Review

All medium and high-risk integration changes must go through CAB review process:

1. Change Request Submission
2. Submit change request form with details
3. Include impact analysis and rollback plan

4. Attach test results and documentation

5. CAB Review

6. CAB meets weekly to review change requests
7. Evaluate business impact and technical risk

8. Approve, reject, or request more information

9. Implementation

10. Schedule change window (off-hours preferred)
11. Execute change according to approved plan

12. Monitor integration health post-deployment

13. Post-Implementation Review

14. Verify change objectives met
15. Document lessons learned
16. Update runbooks and documentation

---

Quality Assurance

Integration Testing Requirements

All integrations must pass the following test stages before production deployment:

Test Stage	Scope	Success Criteria	Responsibility
Unit Testing	Individual integration components	100% code coverage	Developer
Integration Testing	End-to-end integration flow	All test scenarios pass	Integration team
Performance Testing	Load and stress testing	Meet SLA requirements	Performance team
Security Testing	Vulnerability scanning, penetration testing	No critical/high vulnerabilities	Security team
UAT	Business process validation	Business sign-off	Business users

Test Case Template

test_case:
  id: TC-001
  name: CRM Screen Pop - Existing Contact
  description: Verify screen pop displays existing contact record on inbound call
  preconditions:
    - Contact exists in CRM with ANI +15551234567
    - Agent logged in and available
  steps:
    - step: 1
      action: Simulate inbound call from +15551234567
      expected: Call routed to agent
    - step: 2
      action: Verify CRM screen pop triggered
      expected: Contact record displayed with matching ANI
    - step: 3
      action: Verify call activity logged in CRM
      expected: Call start time, duration, and agent recorded
  pass_criteria:
    - Screen pop appears within 2 seconds
    - Correct contact record displayed
    - Call activity logged accurately

---

Performance Management

Integration Performance Metrics

Metric	Target	Measurement	Alert Threshold
API Latency (p95)	<500ms	APM tool	>1000ms
API Error Rate	<0.1%	API gateway logs	>1%
Event Processing Lag	<5 seconds	Event queue metrics	>30 seconds
Integration Uptime	99.9%	Availability monitoring	<99.5%

Performance Optimization Checklist

• Implement caching for frequently accessed data
• Use connection pooling for database integrations
• Enable gzip compression for API responses
• Implement pagination for large data sets
• Use asynchronous processing where possible
• Optimize database queries (indexes, query plans)
• Monitor and tune JVM/runtime parameters

---

Documentation Requirements

All integrations must maintain comprehensive documentation:

Integration Documentation Checklist

• Architecture Diagram - Component diagram showing integration flow
• API Specification - OpenAPI/Swagger documentation
• Configuration Guide - Step-by-step setup instructions
• Data Mapping - Field mappings and transformation logic
• Security Documentation - Authentication, encryption, compliance
• Runbook - Operational procedures for support teams
• Troubleshooting Guide - Common issues and resolutions
• Test Plan - Test scenarios and expected results
• Change Log - Version history and release notes

---

7.2 Integration Playbook

7.2.1 Integration Summary Matrix

This section provides a comprehensive overview of all integrations for the Avaya to Webex Contact Center migration. The matrix serves as a single source of truth for integration planning, execution, and validation.

Master Integration Matrix

#	System Name	Integration Type	Auth Method	Data Flow	Cutover Dependency	Validation Owner	Priority	Status
1	Salesforce CRM	Pre-built Connector	OAuth 2.0	Bidirectional	Pre-cutover	CRM Admin	P0	✅ Complete
2	Microsoft Dynamics 365	REST API	OAuth 2.0	Bidirectional	Pre-cutover	CRM Admin	P0	🟡 In Progress
3	ServiceNow ITSM	REST API + Webhook	OAuth 2.0	Bidirectional	Post-cutover	ITSM Team	P1	📋 Planned
4	NICE Workforce Management	REST API	API Key	Unidirectional (WxCC → WFM)	Pre-cutover	WFM Admin	P0	🟡 In Progress
5	Verint WFM	SFTP + REST API	SFTP Key + OAuth	Bidirectional	Pre-cutover	WFM Admin	P1	📋 Planned
6	Splunk SIEM	Syslog Forwarder	SIEM Token	Unidirectional (WxCC → SIEM)	Post-cutover	Security Team	P1	📋 Planned
7	IBM QRadar	REST API	API Key	Unidirectional (WxCC → SIEM)	Post-cutover	Security Team	P2	📋 Planned
8	NICE Recording	REST API + Webhook	OAuth 2.0	Bidirectional	Post-cutover	Compliance Team	P0	📋 Planned
9	Verint Recording	SIPREC	TLS Certificate	Unidirectional (WxCC → Recording)	Post-cutover	Compliance Team	P1	📋 Planned
10	Google Dialogflow CX	REST API + Webhook	Service Account	Bidirectional	Pre-cutover	AI/Bot Team	P1	📋 Planned
11	Microsoft Teams	Pre-built Connector	Azure AD	Unidirectional (WxCC → Teams)	Post-cutover	Collaboration Team	P2	📋 Planned
12	Slack	Webhook	Webhook Token	Unidirectional (WxCC → Slack)	Post-cutover	Collaboration Team	P2	📋 Planned
13	Tableau Analytics	REST API	Personal Access Token	Unidirectional (WxCC → Tableau)	Post-cutover	BI Team	P2	📋 Planned
14	Power BI	REST API	Service Principal	Unidirectional (WxCC → Power BI)	Post-cutover	BI Team	P2	📋 Planned
15	HR System (Workday)	REST API	OAuth 2.0	Unidirectional (HR → WxCC)	Pre-cutover	HR IT Team	P1	📋 Planned

Priority Definitions

• P0 (Critical): Must be completed before cutover. System cannot function without this integration.
• P1 (High): Required for full functionality. Should be completed within 30 days of cutover.
• P2 (Medium): Nice to have. Can be completed within 90 days of cutover.
• P3 (Low): Enhancement. Can be deferred to post-migration stabilization phase.

Status Definitions

• ✅ Complete: Integration tested and validated in production
• 🟡 In Progress: Currently under development or testing
• 📋 Planned: Scheduled but not yet started
• 🔴 Blocked: Waiting on dependency or blocker

---

Integration Phasing and Timeline

Phase	Timeline	Integrations	Success Criteria
Phase 1: Pre-Migration	Weeks 1-4	CRM, HR System	Screen pop working, agent roster synced
Phase 2: Core Migration	Weeks 5-8	WFM, Dialogflow CX	Workforce adherence <90%, IVR containment >70%
Phase 3: Post-Migration	Weeks 9-12	Recording, SIEM, ITSM	100% call recording, SIEM logs flowing
Phase 4: Optimization	Weeks 13-16	Analytics, Collaboration	Dashboards live, alerts working

---

7.2.2 CRM Integrations

Overview

CRM integration is a P0 (critical priority) integration that must be completed before cutover. It provides agents with real-time customer context through screen pops, click-to-dial, and automatic activity logging.

Integration 1: Salesforce CRM

Integration Summary

Attribute	Value
Integration Type	Pre-built Connector (Service Cloud Voice)
Authentication	OAuth 2.0 (Connected App)
Data Flow	Bidirectional (Webex ↔ Salesforce)
Latency SLA	<2 seconds for screen pop
Cutover Dependency	Must be completed 1 week before cutover
Validation Owner	CRM Administrator

Architecture Diagram

┌──────────────────┐         ┌──────────────────┐         ┌──────────────────┐
│  Webex Contact   │         │   Salesforce     │         │   Salesforce     │
│     Center       │◄───────►│   Service Cloud  │◄───────►│   CRM Database   │
│  (Contact Center │  OAuth  │   Voice Connector│  SOQL   │                  │
│   Platform)      │         │   (Managed Pkg)  │         │                  │
└──────────────────┘         └──────────────────┘         └──────────────────┘
         │                            │                            │
         ▼                            ▼                            ▼
  Call Events                   Screen Pop                  Contact/Case
  (Inbound/Outbound)            Click-to-Dial               Activity Log

Integration Components

1. Service Cloud Voice Managed Package
2. Pre-built Salesforce package from Cisco
3. Provides native Webex Contact Center integration

4. Includes Omni-Channel connector, call controls, activity logging

5. Connected App Configuration

6. OAuth 2.0 authentication between Webex and Salesforce
7. Scopes required: api, web, refreshtoken, offline_access

8. Callback URL: https://webexcc.com/auth/callback

9. Omni-Channel Configuration

10. Route voice calls through Salesforce Omni-Channel
11. Presence synced between Webex and Salesforce
12. Work assignment rules for intelligent routing

---

Step-by-Step Configuration

Step 1: Install Service Cloud Voice Package

1. Log into Salesforce as System Administrator
2. Navigate to Setup → AppExchange
3. Search for "Service Cloud Voice for Webex Contact Center"
4. Click Get It Now and install in production org
5. Select Install for All Users
6. Wait for installation to complete (5-10 minutes)

Step 2: Create Connected App

1. Navigate to Setup → App Manager → New Connected App
2. Configure basic information:
3. Connected App Name: Webex Contact Center
4. API Name: Webex_Contact_Center
5. Contact Email: admin@example.com
6. Enable OAuth Settings:
7. Callback URL: https://webexcc.com/auth/callback
8. Selected OAuth Scopes:
   • Access the identity URL service (id, profile, email, address, phone)
   • Access and manage your data (api)
   • Perform requests on your behalf at any time (refresh_token, offline_access)
   • Provide access to your data via the Web (web)
9. Click Save and note Consumer Key and Consumer Secret

Step 3: Configure Omni-Channel

1. Navigate to Setup → Omni-Channel Settings
2. Enable Omni-Channel: Toggle On
3. Create Service Channel:
4. Name: Voice - Webex Contact Center
5. Developer Name: Voice_Webex_CC
6. Channel Type: Phone
7. Create Presence Statuses:
8. Available (Online: Yes)
9. Busy (Online: Yes, Capacity: 0)
10. Break (Online: No)
11. Lunch (Online: No)
12. Offline (Online: No)

Step 4: Field Mapping Configuration

Configure ANI (Automatic Number Identification) to Contact/Lead search:

Webex Field	Salesforce Field	Match Type
ani	Contact.Phone	Exact
ani	Contact.MobilePhone	Exact
ani	Lead.Phone	Exact
ani	Lead.MobilePhone	Exact

Configuration in Salesforce Setup:

1. Navigate to Setup → Service Cloud Voice Settings
2. Click Field Mappings
3. Add mapping rules above
4. Set priority: Contact → Lead
5. Enable Auto-create Lead if no match found

Step 5: Authentication Setup in Webex Contact Center

1. Log into Webex Contact Center Admin Portal
2. Navigate to Provisioning → Integrations
3. Select Salesforce from integration catalog
4. Enter Salesforce org details:
5. Salesforce Instance URL: https://yourorg.my.salesforce.com
6. Consumer Key: [from Connected App]
7. Consumer Secret: [from Connected App]
8. Click Authorize and complete OAuth flow
9. Verify integration status shows Connected

---

Validation and Testing

Test Scenario 1: Inbound Call Screen Pop - Existing Contact

Step	Action	Expected Result	Validation
1	Agent in Available status in Salesforce	Agent presence: Online	✅ / ❌
2	Initiate test call from +15551234567 (existing contact)	Call routed to agent	✅ / ❌
3	Verify screen pop	Contact record pops up within 2 seconds	✅ / ❌
4	Verify call controls	Accept/Decline buttons visible	✅ / ❌
5	Accept call and complete interaction	Call connected, talk time recorded	✅ / ❌
6	Verify activity logging	Task created in Activity History with call duration	✅ / ❌

Test Scenario 2: Inbound Call - New Contact (Auto-Create Lead)

Step	Action	Expected Result	Validation
1	Initiate test call from +15559876543 (new number)	Call routed to agent	✅ / ❌
2	Verify screen pop	"New Lead" form displayed	✅ / ❌
3	Complete lead form (Name, Company)	Lead created successfully	✅ / ❌
4	Verify lead record	Lead record contains ANI +15559876543	✅ / ❌

Test Scenario 3: Click-to-Dial from Contact Record

Step	Action	Expected Result	Validation
1	Open contact record in Salesforce	Contact details displayed	✅ / ❌
2	Click phone number (click-to-dial)	Webex softphone dials number	✅ / ❌
3	Verify outbound call	Call connects to customer	✅ / ❌
4	Complete call	Call activity logged in Contact record	✅ / ❌

Test Scenario 4: Agent Status Synchronization

Step	Action	Expected Result	Validation
1	Agent changes status in Webex to "Break"	Salesforce presence: Break (Offline)	✅ / ❌
2	Agent changes status in Salesforce to "Available"	Webex status: Available	✅ / ❌
3	Verify no calls routed during "Break"	No incoming calls	✅ / ❌

---

Troubleshooting Guide

Issue 1: Screen Pop Not Appearing

Root Cause	Symptoms	Resolution Steps
Field mapping misconfigured	Screen pop not triggered, no error message	1. Verify ANI field mapping in Salesforce setup 2. Check phone number format (E.164: +15551234567) 3. Test with known contact phone number
OAuth token expired	Error: "Authentication failed"	1. Re-authenticate in Webex CC Admin Portal 2. Verify Connected App permissions 3. Refresh OAuth token
Firewall blocking Webex IPs	Intermittent failures, timeout errors	1. Whitelist Webex IP ranges in Salesforce 2. Check Security → Network Access in Salesforce setup

Issue 2: Click-to-Dial Not Working

Root Cause	Symptoms	Resolution Steps
User missing permissions	Click-to-dial button grayed out	1. Assign "Service Cloud Voice User" permission set 2. Verify user has telephony access in profile
Softphone not registered	Error: "Unable to place call"	1. Refresh Webex softphone 2. Check agent login status in Webex CC 3. Verify network connectivity

Issue 3: Activity Not Logging in Salesforce

Root Cause	Symptoms	Resolution Steps
Activity logging disabled	Calls completed but no Task records created	1. Enable activity logging in Service Cloud Voice settings 2. Verify field mappings for Task object 3. Check user permissions for Task creation
Call data missing required fields	Task created with incomplete data	1. Review field mappings 2. Ensure mandatory fields populated 3. Check data transformation rules

---

Performance Optimization

Optimization	Description	Expected Improvement
Index Phone Fields	Create indexes on Contact.Phone, Lead.Phone	Screen pop latency: 2s → 0.5s
Reduce Search Scope	Limit search to Active contacts only	Database load: -40%
Cache API Responses	Cache contact lookups for 5 minutes	API calls reduced by 60%
Batch Activity Logging	Batch update Task records hourly	API governor limits: -30%

---

Integration 2: Microsoft Dynamics 365

Integration Summary

Attribute	Value
Integration Type	REST API (Custom Integration)
Authentication	OAuth 2.0 (Azure AD)
Data Flow	Bidirectional (Webex ↔ Dynamics 365)
Latency SLA	<3 seconds for screen pop
Cutover Dependency	Must be completed 1 week before cutover
Validation Owner	CRM Administrator

Architecture Diagram

┌──────────────────┐         ┌──────────────────┐         ┌──────────────────┐
│  Webex Contact   │         │   Integration    │         │   Microsoft      │
│     Center       │◄───────►│   Middleware     │◄───────►│   Dynamics 365   │
│  (Webex Connect) │  HTTPS  │   (Azure Logic   │  REST   │   CRM            │
│                  │         │    Apps)         │  API    │                  │
└──────────────────┘         └──────────────────┘         └──────────────────┘
         │                            │                            │
         ▼                            ▼                            ▼
  Call Event Webhook             Data Transformation        Contact/Account
  (JSON Payload)                 Field Mapping              Activity Log

Integration Components

1. Webex Connect HTTP Request Node
2. Calls Dynamics 365 Web API for contact lookups
3. Implements OAuth 2.0 bearer token authentication

4. Handles pagination for large result sets

5. Azure AD App Registration

6. Provides OAuth 2.0 authentication
7. Grants API permissions to Dynamics 365

8. Issues access tokens for Webex Connect

9. Azure Logic Apps (Optional Middleware)

10. Transforms data between Webex and Dynamics formats
11. Handles complex business logic
12. Provides retry and error handling

---

Step-by-Step Configuration

Step 1: Register App in Azure AD

1. Log into Azure Portal (https://portal.azure.com)
2. Navigate to Azure Active Directory → App Registrations
3. Click New Registration
4. Configure application:
5. Name: Webex Contact Center Integration
6. Supported account types: Accounts in this organizational directory only
7. Redirect URI: https://webexcc.com/auth/callback
8. Click Register and note Application (client) ID and Directory (tenant) ID

Step 2: Configure API Permissions

1. In app registration, click API permissions → Add a permission
2. Select Dynamics CRM → Application permissions
3. Add permissions:
4. user_impersonation: Access Dynamics 365 as organization users
5. Click Grant admin consent (requires Global Administrator)

Step 3: Create Client Secret

1. Click Certificates & secrets → New client secret
2. Description: Webex CC Integration Secret
3. Expiry: 24 months (recommended)
4. Click Add and copy secret value immediately (only shown once)

Step 4: Configure Webex Connect Flow

Create HTTP Request node in Webex Connect to call Dynamics 365 API:

// OAuth Token Request (Node 1)
POST https://login.microsoftonline.com/{tenant-id}/oauth2/v2.0/token
Content-Type: application/x-www-form-urlencoded

Body:
client_id={client-id}&
scope=https://org.crm.dynamics.com/.default&
client_secret={client-secret}&
grant_type=client_credentials

// Parse token from response
var accessToken = JSON.parse(httpResponse.body).access_token;

// Dynamics 365 Contact Lookup (Node 2)
GET https://org.crm.dynamics.com/api/data/v9.2/contacts
     ?$filter=telephone1 eq '{ani}' or mobilephone eq '{ani}'
     &$select=contactid,fullname,emailaddress1,telephone1

Headers:
Authorization: Bearer {accessToken}
Accept: application/json
OData-MaxVersion: 4.0
OData-Version: 4.0

// Parse contact from response
var contacts = JSON.parse(httpResponse.body).value;
if (contacts.length > 0) {
  var contact = contacts[0];
  // Screen pop logic here
}

---

Step 5: Agent Desktop Integration

Configure Webex Agent Desktop to display Dynamics 365 contact record:

1. Navigate to Webex Contact Center Admin Portal → Desktop Layout
2. Add Custom Widget with Dynamics 365 URL:

   https://org.crm.dynamics.com/main.aspx?
     appid={app-id}&
     pagetype=entityrecord&
     etn=contact&
     id={contactId}
   

3. Configure widget to open on call arrival with contact ID from lookup

---

Validation and Testing

Test Scenario 1: Inbound Call Contact Lookup

Step	Action	Expected Result	Validation
1	Initiate test call from +15551234567	Call routed to agent	✅ / ❌
2	Webex Connect HTTP node executes	OAuth token retrieved successfully	✅ / ❌
3	Dynamics 365 API query executes	Contact record returned (HTTP 200)	✅ / ❌
4	Custom widget displays contact	Contact details visible in agent desktop	✅ / ❌
5	Complete call	Call activity logged in Dynamics 365	✅ / ❌

Test Scenario 2: No Contact Found

Step	Action	Expected Result	Validation
1	Initiate test call from +15559999999 (not in CRM)	Call routed to agent	✅ / ❌
2	Dynamics 365 API query returns empty	HTTP 200, value: []	✅ / ❌
3	Display "New Contact" form	Agent can create new contact	✅ / ❌

---

Troubleshooting Guide

Issue 1: OAuth Token Request Failed

Root Cause	Symptoms	Resolution Steps
Invalid client credentials	Error: invalid_client (HTTP 401)	1. Verify client ID and secret 2. Check if secret expired (renew if needed) 3. Confirm tenant ID correct
Insufficient API permissions	Error: insufficient_privileges	1. Grant admin consent in Azure AD 2. Verify user_impersonation permission added 3. Wait 5-10 minutes for permission propagation

Issue 2: Dynamics 365 API Query Failed

Root Cause	Symptoms	Resolution Steps
Invalid OData syntax	Error: Bad Request (HTTP 400)	1. Validate OData filter syntax 2. Check field names (case-sensitive) 3. Test query in Dynamics 365 Advanced Find
Rate limit exceeded	Error: Too Many Requests (HTTP 429)	1. Implement exponential backoff retry 2. Cache contact lookups 3. Review API call frequency

---

(Continued in next section with ServiceNow ITSM, WFM integrations, SIEM integrations, Recording integrations, and remaining sections through 7.2.10)

---

7.2.3 Workforce Management (WFM) Integrations

[Content continues with detailed WFM integration guides for NICE, Verint, similar format...]

7.2.4 SIEM and Security Monitoring Integrations

[Content continues with SIEM integration guides for Splunk, QRadar, similar format...]

7.2.5 Call Recording and Compliance Integrations

[Content continues with recording platform integrations for NICE, Verint, similar format...]

7.2.6 Ticketing and ITSM Integrations

[Content continues with ServiceNow, Jira Service Management integrations, similar format...]

7.2.7 Communication and Collaboration Integrations

[Content continues with Microsoft Teams, Slack integrations, similar format...]

7.2.8 Analytics and Business Intelligence Integrations

[Content continues with Tableau, Power BI integrations, similar format...]

7.2.9 Integration Validation and Testing

[Content continues with comprehensive validation procedures...]

7.2.10 Integration Troubleshooting Guide

[Content continues with common integration issues and resolutions...]

---