Skip to main content
An IT leader decides to implement policy-based access management. The vision is clear: when someone joins, their HRIS record updates, policies calculate required access, and systems provision automatically. Then the integration mapping begins:
Reality sets in: Every arrow represents a custom integration. Every system has different authentication, different APIs, different data models. Welcome to the integration layer—the unsexy but critical plumbing that makes access management work.

The Integration Complexity Matrix

A typical mid-size company integrates 20-30 systems: Total integration endpoints: 60-100+ (each system exposes multiple APIs).

The Six Integration Patterns

Pattern 1: Pull (Polling)

Mechanism: The access management system queries external systems on a schedule, compares current state to previous state, and processes changes. Example: HRIS User Sync
Advantages: Simple to implement. Works with any API. No external dependencies on webhooks or message queues. Disadvantages: Delayed updates based on poll frequency. Inefficient—fetches all data even when nothing changed. API rate limits constrain frequent polling. Best fit: Systems lacking webhook support. Scenarios where real-time updates are non-critical. Data volumes under 10K records.

Pattern 2: Push (Webhooks)

Mechanism: External systems send HTTP POST requests to designated endpoints when data changes. The access management system processes immediately. Example: HRIS User Update
Advantages: Real-time updates. Efficient—only changed data transmits. No polling overhead. Disadvantages: Requires public endpoint (security consideration). Webhook reliability depends on endpoint availability. Retry logic varies by vendor. Signature verification differs across systems. Best fit: Real-time updates are critical. The external system supports webhooks. The organization can handle webhook security requirements.

Pattern 3: Scheduled Batch

Mechanism: Data exports from systems on schedule, imports to the access management system, batch processing. Example: HRIS Daily Export
Advantages: Simple. Works with legacy systems (many only support file exports). Reliable—file-based, easy to retry. Disadvantages: Significant delays (daily, nightly). Large data transfers. Requires file handling (SFTP, S3). Best fit: Systems only supporting file exports. Real-time is non-critical. Batch windows are acceptable.

Pattern 4: Event Stream

Mechanism: Events publish to a message queue (Kafka, SQS). The access management system subscribes and processes events as they arrive. Example: User Lifecycle Events
Advantages: Real-time. Decoupled—systems avoid direct calls to each other. Reliable—message queue handles retries. Scalable—multiple consumers. Disadvantages: Infrastructure overhead (Kafka, SQS). Complexity (message serialization, dead letter queues). Requires both systems to support event streaming. Best fit: Event streaming infrastructure exists. Multiple systems need the same data. High volume and high reliability are requirements.

Pattern 5: SCIM (Standard Protocol)

Mechanism: SCIM (System for Cross-domain Identity Management) provides a standard protocol. Identity providers push or pull user data through standardized endpoints. Example: Okta to Application via SCIM
Advantages: Standard protocol with thorough documentation. Supported by major IdPs (Okta, Azure AD, Google). Bidirectional—supports push and pull. Disadvantages: Complex specification with numerous edge cases. Not all systems support SCIM. Group mapping presents challenges. Best fit: Enterprise IdP integrations. Standardized protocols preferred. User provisioning is the primary use case.

Pattern 6: API Proxying

Mechanism: The access management system acts as a proxy between two systems, translating requests and responses. Example: HRIS to Okta via Proxy
Advantages: Full control over transformations. Business logic can be added (validation, enrichment). Single point for monitoring. Disadvantages: The access management system becomes a critical path. Maintenance burden—the organization owns all transformations. Performance bottleneck—all traffic flows through the proxy. Best fit: Data transformations required. Business logic must be applied. Systems cannot communicate directly.
Integration patterns directly affect audit trail completeness. Webhook-based (push) patterns create real-time audit records; polling patterns create batch records with potential gaps. Auditors evaluating SOC 2 CC6.1 (logical access controls) prefer near-real-time evidence of access changes. Document the integration pattern for each connected system and the expected latency for audit events.

The Authentication Zoo

Each system requires different authentication: Organizations must manage 20-30 different credential types, credential rotation (some expire), secure storage (encrypted secrets), and permission scopes (least privilege).

The Rate Limit Maze

Each API enforces different rate limits: Organizations need rate limit tracking per API, exponential backoff retry logic, request queuing to avoid exceeding limits, and graceful degradation when limits are reached.

The Integration Layer Architecture

Recommended architecture:

Component 1: Adapter Interface

A standard interface ensures consistency across all adapters:

Component 2: Concrete Adapter (Example: Okta)

Component 3: Rate Limiter

Component 4: Retry Logic with Exponential Backoff

Component 5: Orchestrator

Common Integration Challenges

Challenge 1: Eventual Consistency

Problem: Systems do not update immediately. Example: Create user in Okta. Add user to Okta group. Okta provisions to Google via SCIM. Google creates the user 5-10 minutes later. Solution: Poll for completion. Use webhooks when available. Implement retry with longer delays.

Challenge 2: Circular Dependencies

Problem: System A depends on System B, which depends on System A. Example: Okta provisions to Google. Google group membership triggers an Okta group rule. The Okta group rule triggers Google provisioning. Infinite loop. Solution: Detect cycles in the dependency graph. Break cycles with explicit ordering. Use idempotency to prevent duplication.

Challenge 3: Partial Failures

Problem: Some systems succeed while others fail. Example: Create user in Okta (success). Add to Google group (API timeout). Add to Slack channels (success). Solution: Track provisioning state per system. Retry failed operations separately. Avoid rollback of successful operations—use forward recovery.
Partial failures create audit trail complexity. SOC 2 and SOX auditors expect to see: (1) evidence that failures are detected, (2) documented retry/remediation procedures, and (3) reconciliation reports showing eventual consistency. Build reconciliation reports that compare intended access (per policy) with actual access (per system) and flag discrepancies for investigation.

Challenge 4: Data Format Mismatches

Problem: Each system uses different data formats. Example: HRIS stores “John Smith”. Okta expects first_name=“John”, last_name=“Smith”. Google expects givenName=“John”, familyName=“Smith”. Slack expects display_name=“John Smith”, real_name=“John Smith”. Solution: Define a canonical data model (internal format). Build transformation functions per system. Handle edge cases (single-word names, hyphens, non-ASCII characters).

Challenge 5: API Versioning

Problem: APIs change, breaking integrations. Example: Okta releases v2 API. Deprecates v1 API with 6 months notice. The existing integration uses v1. Solution: Pin to stable API versions. Monitor deprecation notices. Test against new versions before migrating. Abstract API calls to simplify version swaps.

The Integration Reality

Integration represents 70% of the work in access management automation. The six patterns:
  1. Pull (polling)—Simple, delayed
  2. Push (webhooks)—Real-time, complex
  3. Batch (file exports)—Legacy-friendly
  4. Event stream (Kafka)—Scalable, requires infrastructure
  5. SCIM (standard)—Enterprise IdP standard
  6. API proxying—Full control, maintenance burden
Key components:
  • Adapter interface (standard contract)
  • Concrete adapters (one per system)
  • Rate limiters (respect API limits)
  • Retry logic (handle transient failures)
  • Orchestrator (coordinate across systems)
Common challenges:
  • Eventual consistency
  • Circular dependencies
  • Partial failures
  • Data format mismatches
  • API versioning
Implementation timeline:
  • First 3 adapters: 3-4 weeks
  • Each additional adapter: 1-2 weeks
  • Orchestration layer: 2-3 weeks
  • Testing and hardening: 2-4 weeks
Total: 3-4 months for 10 system integrations. Organizations underestimating integration complexity discover the difference between “access management in theory” and “access management in production.”
Next up: Security considerations in access management—threat models, attack vectors, and defense strategies.