Innteroperability Developer

Interoperability Developer

Role summary

Integration Architecture and Interoperability Layer Ownership for SkyHop Connect. Leads the End-to-End Data Lifecycle by architecting contract-first interfaces, codifying streaming and messaging patterns, and landing integrations with third-party data aggregators. You will design, build, and operate contracts, adapters, and event flows that securely and reliably connect SkyHop products to partners and data providers.

This includes enforcing reliability, observability, security, and Agile delivery discipline across all integration boundaries. You also own the end-to-end wiring of external events and partner data into the rules engine, and the routing of decision outputs back to internal and external systems.

Responsibilities

Cross-System Contract Governance

• Define and govern all external and internal interoperability contracts in GraphQL Schema Definition Language and Protocol Buffers.

• Ensure rigorous versioning, deprecation, and compatibility guarantees across all interfaces.

• Establish a shared schema store with automated code generation for Golang microservices and React clients.

• Author canonical data models and mapping guides; maintain transformation logic and lineage.

Rules engine integration (inputs and outputs)

• Design normalized, versioned input schemas for rule evaluation; implement enrichment, validation, and idempotent ingestion from external partners and internal sources.

• Build fan-in pipelines from Amazon Kinesis and Amazon Simple Queue Service into the rules engine with back-pressure handling, dead-letter queues, and replay.

• Implement decision output channels that emit structured outcomes to internal services and external partners; ensure exactly-once-effective delivery where required.

• Provide simulation and sandbox paths for rules: record/replay harnesses, golden fixtures, and impact analysis before promotion.

• Publish audit trails and decision traces with correlation identifiers end-to-end; ensure privacy controls and field-level redaction where needed.

• Partner with Backend to keep the engine pure (no network I/O in the engine) and to maintain strict contracts on inputs and outputs.

Event streaming and asynchronous messaging

• Standardize real-time ingestion and fan-out with Amazon Kinesis; implement durable consumers with checkpointing and partition strategy.

• Govern asynchronous workflows on Amazon Simple Queue Service with retry, backoff, idempotency keys, and poison-queue handling.

• Propagate trace context and correlation identifiers across hops for full-fidelity observability.

Service-to-service and client interfaces

• Set patterns for gRPC (deadlines, retries, error semantics) and enforce client/server compatibility.

• Curate the GraphQL gateway contract (queries, mutations, subscriptions) with schema linting, breaking-change checks, and living documentation.

External partner integrations

• Lead discovery and certification with third party data aggregators; stand up sandboxes and contract tests.

• Implement Google services (Google Maps API, Google Location Services, Google Optical Character Recognition) with quota, privacy, and failover policies.

• Build adapters that encapsulate partner quirks behind stable internal contracts; publish runbooks and troubleshooting guides.

Cloud-native delivery and security

• Ship on Amazon Web Services Elastic Kubernetes Service with GitHub Actions; design deployable units, environment promotion, and safe rollback.

• Instrument end-to-end with OpenTelemetry Collector and Jaeger; centralize logs and alerts in Amazon CloudWatch.

• Enforce secret hygiene and rotation via AWS Secrets Manager; implement least-privilege access and request signing.

• Own data durability and recovery across MySQL, Redis, Elasticsearch, Amazon DynamoDB, and Amazon Simple Storage Service.

Reliability, quality, and support readiness

• Define non-functional requirements (latency, throughput, durability) and translate into service level objectives and error budgets.

• Build automated tests across layers: contract, consumer-driven, integration, end-to-end, performance; include rule I/O fixtures and replay tests.

• Partner with Quality Assurance on coverage targets by risk and operationalize exit gates.

• Publish change logs, deprecation notices, and migration playbooks; train support on incident categories and root-cause tags.

Agile delivery and collaboration

• Operate in Scrum or Kanban cadences: backlog curation, estimation, sprint planning, reviews, and retrospectives.

• Decompose work into incremental, releasable slices with Platform, Backend, Frontend, and Quality Assurance teams.

• Maintain decision records with clear trade-offs; drive cross-team alignment via architecture reviews.

Required qualifications

• Bachelor's degree in computer science; Master's degree preferred.

• 6+ years as a Senior Backend Developer specializing in building integrations with Golang, GraphQL, gRPC, and at least one of Amazon Kinesis or Amazon Simple Queue Service.

• Amazon Web Services experience.

• Proven delivery of contract-first interfaces with strong schema design, versioning, and deprecation management.

• Data integration experience with MySQL, Redis, Elasticsearch, and DynamoDB, including migration and replay strategies.

Preferred qualifications

• Experience with Google Maps API, Google Location Services, and Google Optical Character Recognition.

• Familiarity with consumer-driven contract testing and asynchronous contract specifications.

• Experience codifying integration guidelines and reusable adapter frameworks.

Location

Flexible within the United States.

Job Type: Full-time

Pay: $108, $130,268.42 per year

Benefits:

• Dental insurance
• Employee assistance program
• Health insurance
• Paid time off
• Retirement plan
• Vision insurance

Work Location: Hybrid remote in Fort Lauderdale, FL 33315