Integrations Engineer

Worky; Greater London; On-site; GBP 80,000 - 130,000; Full time

Benefits offered by this job

Equity

Competitive salary

Open-source contributions

Job summary

HASH is hiring an Integrations Engineer to design and implement connectors in TypeScript and Python, unifying data from a wide range of external systems into HASH’s knowledge graph. You’ll map source concepts into shared types, handle complex auth flows, and maintain robust, secure, and observable integrations.

You’ll collaborate with platform engineers and customers to learn unfamiliar services quickly, reverse-engineer undocumented surfaces, and ensure production-grade reliability and

Qualifications

• Proficient in TypeScript and Python for production-grade work.
• Experience building and maintaining multiple connectors to third‑party APIs or services.
• Solid understanding of HTTP/REST, GraphQL, and authentication patterns (OAuth 2.0).
• Ability to reverse-engineer poorly documented surfaces by inspecting client behavior and payloads.
• Experience handling pagination, rate limits, retries, deduplication, and eventual consistency.
• Strong semantic modeling skills to map real-world concepts into shared types.
• Experience building asynchronous/event-driven services (queues, workers, backfills).
• Strong testing instincts: unit, integration, contract, and E2E where appropriate.
• Ability to diagnose failures across multiple systems using logs, metrics, and traces.
• Good security judgment around credentials, secrets, permissions, and tenant isolation.
• High ownership to deliver integration from incomplete docs to production-ready
• Clear written and spoken communication, including customer interaction.

Responsibilities

• Build new connectors between HASH and SaaS apps, services, and customer APIs.
• Maintain existing connectors as upstream APIs and auth flows evolve.
• Work with excellent public API docs when available.
• Reverse-engineer undocumented surfaces with authorized approaches.
• Design reliable full and incremental synchronization with pagination and recovery.
• Implement OAuth, API keys and service-account authentication safely.
• Consume webhooks and events, reconcile with polling or scheduled sync.
• Build safe two-way synchronization respecting source permissions and avoiding writes loops.
• Determine actual meaning of external fields and map to common HASH types.
• Map heterogeneous source schemas into HASH entity types while preserving provenance.
• Reconcile multiple services' representations of same concepts and improve schemas.
• Handle schema/API evolution without data loss or corruption.
• Create mocks and contract tests for difficult-to-reproduce systems.
• Write user and engineer-facing documentation for integrations.
• Collaborate with AI Success Engineers and customers to understand constraints.
• Provide feedback to infrastructure teams and contribute improvements to HASH open-source codebases.
• Use AI-assisted development thoughtfully to accelerate connector work while ensuring correctness.

Skills

TypeScript

Python

Connector Dev

REST/GraphQL

OAuth 2.0

Security

Testing

Documentation

Reverse engineering

SaaS integrations

Tools

REST APIs

GraphQL

OAuth 2.0

OpenAPI

Webhooks

Job description

About HASH

At HASH, we're building infrastructure to solve information failure and help everybody make the right decisions. Our open-source platform helps organizations turn fragmented information into typed, temporal knowledge and process graphs that support analysis, simulation, optimization and automation.

We're building towards world models from a different starting point from most AI labs: explicit representations of real systems, the entities within them and the processes through which they change. Our founders include Joel Spolsky, who founded Stack Overflow and Trello; Jude Allred, formerly CTO of Glitch; and Dei Vilkinsons, formerly CEO of Soho Strategy.

About the role

A large part of HASH's utility is its ability to integrate structured data from a wide-range of external applications into a single, unified knowledge and process graph. Each SaaS applications, communication tools, internal service or specialized enterprise system has its own authentication model, API conventions, rate limits, schemas, failure modes and ideas about time. HASH needs to connect to these systems reliably, preserve where information came from and keep its model synchronized as the source changes. We're hiring an Integrations Engineer to work on these problems.

You will design and implement connectors in TypeScript and Python, making both widely used services and customer-specific systems straightforward to connect to HASH. This includes understanding each source in detail, retrieving and synchronizing its data reliably, and mapping its native concepts into common semantic schemas that remain useful beyond a single integration. While some services provide excellent public APIs, complete schemas and thoughtful documentation... others provide only incomplete documentation, inconsistent endpoints or no public documentation for the behavior we are authorized to integrate with. You should enjoy both situations. You may find yourself studying an SDK, inspecting browser network traffic, comparing payloads, testing undocumented behavior and working out how an application really functions—then turning that understanding into a connector that is robust, respectful of permissions and maintainable as the service changes.

Different systems use different names, structures and assumptions for the same real-world concepts, while superficially similar fields may mean different things. You should find the idea of how a Salesforce account, an SAP business partner, a row in a customer database and an organization found on the web can map into shared types without erasing their provenance or source-specific meaning.

This is not a role for writing disposable scripts, and you will be supported in the role by a team working on the surrounding integration infrastructure. Your main output will be excellent connectors: new ones developed quickly and carefully, and existing ones kept working as upstream services and HASH evolve.

You will work closely with core platform engineers, AI Success Engineers and customer-facing colleagues. Sometimes you will be adding support for a widely used SaaS product. Sometimes you will need to understand a customer's unusual internal API or data model. In both cases, your responsibility is to produce something accurate, maintainable, secure and observable enough to remain dependable after the initial implementation. You will also be expected to leverage AI effectively in this role.

Requirements

• Strong production experience with both TypeScript and Python
• Experience personally building and maintaining multiple connectors to third-party APIs, SDKs, databases or services
• A solid understanding of HTTP, REST, GraphQL, webhooks, OAuth 2.0 and common authentication patterns
• A genuine appetite for reverse-engineering poorly documented integration surfaces by reading client code, inspecting network behavior, testing hypotheses and comparing real payloads
• Experience handling the realities of external systems: pagination, rate limits, partial failure, retries, deduplication, idempotency, eventual consistency and breaking API changes
• An obsession with semantic modeling: the ability to identify the real-world concepts behind unfamiliar data and map them into common types without discarding source-specific meaning
• Experience building asynchronous or event-driven services, including queues, workers, scheduling and backfills
• Strong testing instincts, including unit, integration, contract and end-to-end testing where appropriate
• The ability to diagnose failures across several systems using logs, metrics, traces and careful reproduction
• Good security judgment around credentials, secrets, permissions, tenant isolation and sensitive customer data
• High agency and the ability to take an integration from incomplete documentation and a real customer need to a dependable production implementation
• Clear written and spoken communication, including the ability to work directly with customers and external technical teams when necessary

You do not need experience with every system HASH may connect to. You do need to learn unfamiliar services quickly, notice the edge cases that documentation omits and enjoy the investigative work required to discover how a system actually behaves.

Experience with ERP or supply-chain systems, Salesforce, Microsoft 365, Google Workspace, Slack, data warehouses, object stores, message brokers, Airbyte, Meltano, Singer, OpenAPI, MCP or similar integration ecosystems is useful. So is experience with schema registries, change-data capture, data lineage, temporal data, knowledge graphs or two-way synchronization.

What you'll do

• Build new connectors between HASH and SaaS applications, communications tools, enterprise services and customer APIs
• Maintain existing connectors as upstream APIs, authentication flows, payloads and product behavior change
• Work comfortably from excellent public API documentation when it exists
• Reverse-engineer poorly documented or unofficial integration surfaces where authorized and appropriate, using network inspection, client behavior, SDKs, experiments and careful validation
• Design reliable full and incremental synchronization, including pagination, checkpoints, backfills and recovery after partial failure
• Implement OAuth, API-key and service-account authentication flows and manage credentials securely
• Consume webhooks and event streams, and reconcile them with polling or scheduled sync where necessary
• Build safe two-way synchronization that respects source-system permissions and avoids loops, duplication or unintended writes
• Determine what external fields and objects actually mean, rather than mechanically reproducing their source shape
• Map heterogeneous source schemas into common HASH entity, relationship and property types while preserving source identity, provenance, time and important source-specific distinctions
• Reconcile several services' representations of the same real-world concepts and improve shared semantic schemas as new evidence appears
• Handle schema and API evolution without silently corrupting or dropping customer data
• Create realistic fixtures, mocks and contract tests for third-party systems that are difficult to reproduce locally
• Write clear documentation for users and engineers creating or operating integrations
• Work with AI Success Engineers and customers to understand source systems, data semantics and deployment constraints
• Feed repeated connector requirements back to the engineers who own HASH's surrounding integration infrastructure
• Contribute improvements back to HASH's open-source codebases
• Use AI-assisted development thoughtfully to accelerate connector implementation and schema mapping while retaining responsibility for correctness and maintainability

Why HASH

• Build the integration layer for an open-source platform spanning knowledge graphs, process models, simulations and AI
• Work on synchronization where provenance, history and semantic meaning matter—not merely moving rows from one place to another
• Become expert in a wide variety of public, private, polished and eccentric services
• Combine API reverse-engineering with unusually deep semantic data-modeling work
• Build connectors whose value comes not only from moving data, but from making different systems intelligible together
• Work directly with the engineers building HASH's graph, query, product and deployment infrastructure
• See your work become immediately useful in customer deployments and reusable across the platform
• Join at a moment of rapid growth, with unusual ownership and influence over what HASH becomes
• Be part of a high-agency team that cares about output, ownership and quality

Benefits

This role pays £80,000-£130,000 base + meaningful equity.