Integration Architect - GoLang

Role Summary This role owns the integration architecture and interoperability layer across a distributed platform. You will lead the end-to-end data lifecycle by designing contract-first interfaces, standardizing event streaming and messaging patterns, and delivering reliable integrations with external partners and internal systems. You will design, build, and operate schemas, adapters, and event flows that securely connect products, data providers, and decision systems. This includes enforcing reliability, observability, security, and Agile delivery discipline across all integration boundaries, as well as wiring external events into a rules engine and routing decision outputs back to downstream consumers.

Key Responsibilities

Integration Architecture & Contract Governance

• Define and govern all internal and external interoperability contracts using GraphQL Schema Definition Language and Protocol Buffers.
• Enforce strict versioning, deprecation, and backward-compatibility guarantees across interfaces.
• Establish and maintain a shared schema repository with automated code generation for Golang services and frontend clients.
• Author canonical data models, mapping guides, and transformation logic with full data lineage.

Rules Engine Integration (Inputs & Outputs)

• Design normalized, versioned input schemas for rule evaluation.
• Implement enrichment, validation, and idempotent ingestion from internal systems and external partners.
• Build fan-in pipelines from streaming and queueing systems into the rules engine, including back-pressure handling, dead-letter queues, and replay support.
• Implement structured decision output channels to internal services and external partners, ensuring exactly-once-effective delivery where required.
• Provide simulation and sandbox capabilities, including record/replay harnesses, golden datasets, and impact analysis prior to promotion.
• Publish end-to-end audit trails and decision traces with correlation identifiers, privacy controls, and field-level redaction.
• Partner closely with backend teams to keep the rules engine isolated from network I/O and governed by strict input/output contracts.

Event Streaming & Asynchronous Messaging

• Standardize real-time ingestion and fan-out using streaming platforms, implementing durable consumers with checkpointing and partition strategies.
• Govern asynchronous workflows with queues, including retries, exponential backoff, idempotency keys, and poison-queue handling.
• Propagate trace context and correlation identifiers across all asynchronous boundaries to support full observability.

Service-to-Service & Client Interfaces

• Define and enforce gRPC standards, including deadlines, retries, and consistent error semantics.
• Curate and govern the GraphQL gateway, including queries, mutations, and subscriptions.
• Enforce schema linting, breaking-change detection, and living documentation.

External Partner Integrations

• Lead technical discovery, onboarding, and certification with third-party data providers.
• Establish partner sandboxes and automated contract tests.
• Implement and manage third-party APIs with strong controls around quota management, privacy, resiliency, and failover.
• Build adapter layers that abstract partner-specific behavior behind stable internal contracts.
• Publish operational runbooks and troubleshooting documentation.

Cloud-Native Delivery, Security & Observability

• Deliver services on Kubernetes using automated CI/CD pipelines.
• Design deployable units, environment promotion strategies, and safe rollback mechanisms.
• Instrument services end-to-end using distributed tracing and centralized logging and alerting.
• Enforce secret management, rotation, request signing, and least-privilege access.
• Own data durability, recovery, and replay strategies across relational, in-memory, search, NoSQL, and object storage systems.

Reliability, Quality & Operational Readiness

• Define non-functional requirements for latency, throughput, and durability.
• Translate requirements into service level objectives and error budgets.
• Build automated test suites across contract, integration, end-to-end, and performance layers.
• Partner with Quality Assurance to align coverage to risk and enforce release gates.
• Publish change logs, deprecation notices, and migration playbooks.
• Train support teams on incident categories, diagnostics, and root-cause tagging.

Agile Delivery & Collaboration

• Operate within Scrum or Kanban frameworks, including backlog grooming, estimation, sprint planning, reviews, and retrospectives.
• Decompose work into incremental, releasable deliverables across platform, backend, frontend, and QA teams.
• Maintain architectural decision records and drive alignment through design and architecture reviews.

Required Qualifications

• Bachelor’s degree in Computer Science or related field; Master’s degree preferred.
• 6+ years of experience as a senior backend developer focused on integrations.
• Strong experience with Golang, GraphQL, gRPC, and cloud-based streaming or queueing systems.
• Proven experience delivering contract-first APIs with robust schema design, versioning, and deprecation strategies.
• Hands-on experience integrating data across relational, in-memory, search, and NoSQL data stores.
• Extensive experience building and operating systems on Amazon Web Services.

Preferred Qualifications

• Experience integrating third-party location, mapping, or document-processing APIs.
• Familiarity with consumer-driven contract testing and asynchronous contract specifications.
• Experience creating reusable integration frameworks, standards, and governance models.

Location Flexible within the United States. US Citizenship required Apply tot his job Apply To this Job