Integration Developer

Ryan Mahoney

Why this role is hard · Ryan Mahoney

Hiring an integration developer at this level is less about theory and more about seeing if they can handle real friction. You need someone who can take messy external data and force it into strict internal schemas without breaking the pipeline. Strong applicants explain why they picked a simple script over a standard connector, then show how they handle token expiry without calling for backup. Weak candidates just read from the manual and dodge questions about failed payloads. You are really checking for calm communication under pressure, immediate ownership of mistakes, and a clear sense of where their work stops.

Core Evaluation

Critical questions for this role

The competency and attitude questions below are where the hiring decision is made. They run in the live interview rounds and are calibrated to the level selected above.

20 Competency Questions

1 of 20

  1. Discipline

    Integration Architecture & Connectivity

  2. Job requirement

    API Design & Specification

    Implements standard API endpoints and documents basic request/response schemas following team guidelines.

  3. Expected at Junior

    Focus is on implementing within existing contracts rather than greenfield design; requires guidance for complex schema definitions and versioning.

Interview round: Hiring Manager Technical: Architecture & Core Competencies

Share an instance where you implemented a new REST endpoint or consumed one based on external documentation. How did you verify that the request and response formats matched the specification?

Positive indicators

  • Uses spec as single source of truth
  • Validates thoroughly against examples
  • Catches contract violations early

Negative indicators

  • Relies on assumptions rather than documentation
  • Skips validation of response structures
  • Discovers format issues during UAT

10 Attitude Questions

1 of 10

Accountability Mindset

The consistent internalization of personal and collective responsibility for integration outcomes, characterized by proactive ownership of errors, transparent communication of risks, and a commitment to resolving issues regardless of originating system boundaries. It manifests as a willingness to address systemic gaps, follow through on technical commitments, and prioritize sustainable, business-aligned solutions over short-term workarounds.

Interview round: Recruiter Screen: Role Fit & Baseline

How do you ensure consistent logging and error handling across multiple flows you are responsible for delivering?

Positive indicators

  • References standardized logging frameworks
  • Demonstrates consistent error handling implementation
  • Monitors and verifies logging effectiveness
  • Enforces standards through peer reviews

Negative indicators

  • Uses ad-hoc logging per workflow
  • Ignores error handling consistency
  • Fails to verify logging in production
  • Doesn't enforce standards during development

Stage 2 · Resume Screening

Read the resume against fixed criteria

Reviewers score every application that clears the door against the same criteria. Stronger reviews advance to live interviews; weaker ones are archived without further screening.

Resume Review Criteria

8 criteria
Evidence of configuring and deploying system-to-system connections using standard protocols, data mapping, and out-of-the-box connectors.
Evidence of designing automated recovery mechanisms, idempotent flows, and state tracking to ensure reliable data synchronization.
Evidence of applying secure authentication, credential rotation, and compliance-aware practices to integration endpoints.
Evidence of producing clear technical documentation, runbooks, and participating in structured peer review cycles.

Does the resume show relevant prior work experience?

Does the cover letter or personal statement convey clear relevance and familiarity with the job?

Is the resume complete, well-organized, and free from formatting, spelling, and grammar mistakes?

Does the resume indicate required academic credentials, relevant certifications, or necessary training?

Stage 3 · During Interviews

Where the hire is decided

Interview rounds use the competency and attitude questions outlined above, then add tests, work simulations, and presentations that reveal deeper evidence about how the candidate thinks and works.

Coding Test

Live Interview · Coding Test

Without AI

Implement the function using standard library features only. Focus on clear state management and predictable retry intervals.

Complete the executeWithRetry function to handle transient HTTP failures. Implement exponential backoff with jitter, respect a maximum attempt limit, and short-circuit if a circuit-breaker threshold is met. Return the successful response or throw a structured error.

With AI

You may use an AI coding assistant to generate boilerplate or suggest patterns, but you must critically review, adapt, and explain the final implementation. Document any AI-suggested logic you modified.

Complete the executeWithRetry function to handle transient HTTP failures. Implement exponential backoff with jitter, respect a maximum attempt limit, and short-circuit if a circuit-breaker threshold is met. Return the successful response or throw a structured error.

Response time

20 min

Positive indicators

  • Clear separation of retry logic from business logic
  • Correct implementation of exponential backoff with jitter
  • Graceful error wrapping and state tracking
  • Readability and testable boundaries
  • Critical evaluation of AI-generated backoff formulas
  • Explicit handling of AI-suggested edge cases (e.g., jitter bounds)
  • Clear documentation of AI usage and manual overrides
  • Refined error handling that matches production standards

Negative indicators

  • Infinite retry loops or missing base cases
  • Hardcoded delays without jitter
  • Swallowed errors without proper context
  • Tightly coupled implementation that is hard to test
  • Blindly pasting AI output without validation
  • Overcomplicated AI suggestions left unrefined
  • Missing jitter or incorrect delay calculations despite AI assistance
  • Lack of commentary on why certain AI patterns were rejected

Presentation Prompt

Walk us through your approach to designing idempotent REST spoke payloads for retry resilience when integrating with a flaky third-party API. Slides are optional; you may talk through your reasoning step-by-step. Discuss how you would identify likely failure modes, structure retry and backoff logic, and ensure data consistency without creating duplicate records.

Format

approach-walkthrough · 20 min · ~2 hr prep

Audience

Integration engineering team and technical hiring manager

What to prepare

  • A short verbal walkthrough or up to 3 optional slides outlining your failure mode analysis and retry strategy.

Deliverables

  • A structured verbal explanation of your technical approach, highlighting decision points and trade-offs.

Ground rules

  • Focus on your reasoning process rather than writing new code or producing deployment scripts.
  • You may reference anonymized past work or construct a hypothetical scenario.
  • Use only work you are permitted to share.

Scoring anchors

Exceeds
Proactively identifies edge cases, proposes a robust idempotency strategy with clear trade-offs, and adapts reasoning to audience questions with precision.
Meets
Provides a logical, structured approach to retry logic and idempotency, addresses key failure modes, and communicates trade-offs clearly.
Below
Struggles to frame the problem, overlooks core consistency risks, relies on vague assertions, or cannot justify design choices under questioning.

Response time

20 min

Positive indicators

  • Asks clarifying questions about API constraints and data volume before proposing a solution
  • Explicitly surfaces assumptions about network latency and third-party SLA limits
  • Articulates a clear strategy for idempotency keys and deduplication
  • Balances retry aggressiveness with downstream system protection

Negative indicators

  • Jumps directly to a specific tool or library without framing the problem space
  • Ignores data consistency or duplicate record risks in retry logic
  • Uses overly technical jargon without explaining impact on system stability
  • Fails to consider fallback mechanisms or circuit breakers

Work Simulation Scenario

Scenario. You are tasked with designing the error handling and retry logic for a new IntegrationHub spoke that syncs critical incident data from an external monitoring tool into ServiceNow. The external API is known to be intermittently unstable and occasionally returns partial payloads. You have a 30-minute discovery session with the integration lead to clarify requirements, constraints, and success criteria before drafting your implementation approach.

Problem to solve. Determine the optimal retry strategy, idempotency guarantees, and failure escalation paths for the integration while balancing platform resource limits and data integrity requirements.

Format

discovery-interview · 35 min · ~1 hr prep

Success criteria

  • Surface hidden constraints around rate limits and partial payload handling
  • Define clear idempotency keys and retry backoff parameters
  • Establish unambiguous escalation thresholds and alerting rules

What to review beforehand

  • ServiceNow IntegrationHub documentation on retry logic and error handling
  • Basic REST API idempotency principles
  • Platform throttling and governor limits

Ground rules

  • You are in a discovery interview. Ask clarifying questions to uncover constraints and requirements.
  • The interviewer will answer honestly but will not volunteer information unless asked.
  • Focus on your approach to framing tradeoffs, sequencing decisions, and identifying risks.

Roles in scenario

Integration Lead (informed_partner, played by hiring_manager)

Motivation. Wants a resilient, production-ready integration design that won't trigger platform governor limits or cause data duplication.

Constraints

  • External API has a strict 100 requests/minute rate limit
  • Partial payloads must be handled without corrupting downstream records
  • Platform has a 15-second script execution timeout for synchronous calls

Tensions to introduce

  • Push back if the candidate assumes synchronous processing without asking about timeout implications
  • Clarify that duplicate records are unacceptable, but eventual consistency is acceptable within a 5-minute window
  • If asked about alerting, specify that the SOC team is already overwhelmed and needs highly filtered alerts

In-character guidance

  • Answer questions directly and factually
  • Provide technical context only when explicitly asked
  • Acknowledge the candidate's assumptions and confirm or correct them

Do not

  • Do not volunteer rate limits or timeout constraints unless asked
  • Do not suggest specific retry algorithms or idempotency strategies
  • Do not coach the candidate on platform best practices

Scoring anchors

Exceeds
Systematically uncovers constraints through high-leverage questions, proposes a resilient async/retry architecture with explicit idempotency controls, and balances platform limits with business SLAs.
Meets
Asks most critical clarifying questions, proposes a standard retry and error-handling pattern that addresses idempotency, and identifies basic escalation paths.
Below
Assumes constraints without verification, suggests designs that violate platform timeouts or risk data duplication, and struggles to define actionable failure thresholds.

Response time

35 min

Positive indicators

  • Asks targeted questions about rate limits, payload structure, and timeout constraints before proposing a design
  • Explicitly surfaces assumptions about idempotency keys and data deduplication strategies
  • Proposes a structured retry/backoff approach that accounts for platform governor limits and downstream impact
  • Defines clear, actionable escalation thresholds that avoid alert fatigue

Negative indicators

  • Guesses implementation details without asking for API constraints or platform limits
  • Proposes synchronous retry loops that would violate script execution timeouts
  • Fails to address idempotency or data corruption risks from partial payloads
  • Freezes or defaults to generic answers when presented with conflicting requirements

Progression Framework

This table shows how competencies evolve across experience levels. Each cell shows competency at that level.

Integration Architecture & Connectivity

5 competencies

CompetencyJuniorMidSenior
API Design & Specification

Implements standard API endpoints and documents basic request/response schemas following team guidelines.

Designs versioned APIs, establishes contract standards, and resolves cross-system compatibility issues.

Defines enterprise-wide API governance frameworks, drives strategic interface evolution, and aligns contracts with business capabilities.

Data Mapping & Transformation

Executes straightforward field-to-field mappings and applies basic data type conversions.

Architects complex transformation logic, handles hierarchical data structures, and optimizes parsing routines.

Establishes canonical data models, governs transformation standards across portfolios, and mentors teams on data architecture patterns.

Error Handling & Resiliency

Implements basic try-catch blocks, logs failures, and configures simple retry policies.

Architects idempotent operations, implements circuit breakers, and designs fallback routing for degraded dependencies.

Defines enterprise resilience standards, oversees chaos testing strategies, and ensures SLA/SLO alignment across integration ecosystems.

Integration Pattern Implementation

Implements standard point-to-point and request-response integrations using platform-native tools.

Deploys publish-subscribe, message queue, and saga patterns to decouple systems and manage distributed state.

Evaluates and standardizes enterprise integration patterns, balancing trade-offs between real-time processing and batch workflows.

Integration Workflow Orchestration

Builds linear automation flows and configures basic conditional routing within the platform.

Orchestrates complex, multi-system workflows with dynamic state management and parallel execution paths.

Designs enterprise service orchestration layers, standardizes workflow governance, and optimizes cross-domain process automation.

Platform Operations & Advanced Development

5 competencies

CompetencyJuniorMidSenior
AI-Enhanced Integration Development

Utilizes AI-assisted code completion and documentation generation for routine integration scripts.

Applies AI-driven pattern recognition to suggest optimal routing, auto-generate test cases, and predict failure modes.

Integrates AI governance into development lifecycles, evaluates emerging AI integration capabilities, and drives strategic automation roadmaps.

Compliance & Audit Logging

Enables standard audit trails and captures required metadata for routine compliance checks.

Designs structured logging schemas, implements data masking for PII, and automates compliance reporting workflows.

Defines enterprise audit architectures, aligns logging practices with global regulatory frameworks, and leads audit readiness programs.

DevOps & CI/CD for Integrations

Executes manual deployments and follows established pipeline triggers for scope and update sets.

Configures CI/CD pipelines, implements automated environment provisioning, and manages artifact versioning.

Defines DevOps strategy for integrations, establishes deployment governance, and optimizes release velocity and safety.

Performance Monitoring & Tuning

Monitors basic execution logs and adjusts timeout thresholds for failing jobs.

Analyzes execution traces, optimizes query payloads, and tunes connection pooling for high-volume integrations.

Establishes enterprise observability standards, architects capacity planning models, and drives continuous performance optimization initiatives.

Security & Access Control

Configures standard OAuth tokens, API keys, and credential stores for outbound connections.

Implements mutual TLS, custom grant flows, and role-based access controls for sensitive data payloads.

Architects zero-trust integration security postures, defines cryptographic standards, and leads security compliance reviews.