Senior Entity Graph Engineer

Firmable is the market-leading B2B sales intelligence platform in Asia Pacific, backed by leading investors, growing 2,000+ customers strong and growing in the US. We build one of the richest datasets about businesses anywhere: who they are, who works there, and what is changing. Millions of companies, hundreds of sources, resolved into a single record and served to humans and AI agents alike. This role owns the graph systems underneath everything Firmable knows about a business. Hybrid by design, mixing graph, warehouse and search rather than pretending one store does it all. Extending itself as new data and new relationship types arrive, instead of waiting for a migration. Built so AI agents can traverse it at low cost and high confidence across 15M companies and 130M people. Traditional graph RAG does not survive contact with a graph this size or this connected, and working out what replaces it is the job. The Role As Senior Engineer, Entity Graphs, you design the graph systems that hold Firmable's view of every business, and the retrieval that makes them useful to AI agents. The centre of the job is architecture: a hybrid store spanning graph, warehouse and search, with a schema that keeps extending as new entity types and relationships arrive, at a scale where the standard answers stop working. On top of that sits agentic retrieval, which at this size means an agent planning a traversal and assembling context on demand rather than embedding a subgraph and hoping similarity search finds it. Entity resolution is the other significant part. Deciding when two records refer to the same real business, across many sources that each key and spell things their own way, is what makes the graph worth traversing at all. Get it wrong and the system produces confident, specific false statements about real businesses at a rate of millions, so you will be the person who can state precision and recall per source and defend the numbers. Expect to invent. Both halves have a deep literature and both run out well before our volume. You will find where the standard techniques break, design something that does not, and prove it with evidence rather than argument. Some of that is refinement. Some of it is closer to a fundamental breakthrough. What You'll Own Hybrid graph architecture at global scale Design the store as a hybrid rather than a single database. Property graph for relationships, warehouse for scale and aggregation, search for candidate retrieval and fuzzy access. Decide what lives where and why, and own the consistency problem that createsBuild a schema that keeps extending. New entity types and new relationship types arrive continuously, and the design has to absorb them without a migration and without corrupting what is already thereHandle the structural problems that only appear at this size. Supernodes, traversal blowup, hot partitions, and queries whose cost is unpredictable until they runFeed graph structure back into the data itself: PageRank, community detection and link prediction as inputs to corroboration and confidence, not as decorations Entity resolution Generate candidates efficiently using sorted neighbourhood, canopy clustering, LSH and MinHash, or phonetic and n-gram keys, and measure what each blocking choice costs you in recallScore similarity with Jaro-Winkler, Levenshtein, token set ratios, TF-IDF or embeddings, inside a Fellegi-Sunter or equivalent probabilistic frameworkCluster the results using connected components, correlation clustering or hierarchical agglomeration, and handle the transitivity failures where A matches B and B matches C but A and C are different companiesCalibrate thresholds so precision and recall can be stated per source and per match type, with a labelled set behind the numbersHandle deterministic keys across ABN, ACN, LEI, NZBN, DUNS, domains and FQDNs, knowing which are stable, which get reused, and which lieDesign new linkage methods where the standard ones break at our scale, and produce the evidence that the new one holds Agentic retrieval beyond graph RAG Build the retrieval surface agents call, with parameterised traversals, subgraph projections sized to a context window, and an interface that returns a slice rather than the storeWork out what replaces conventional graph RAG at this scale. Embedding a graph this connected and hoping similarity search finds the right neighbourhood does not hold up, and the alternative is yours to designAssemble the right subgraph per query, expand hops based on what returns, compress without losing provenance, and stop when marginal context stops paying for itselfSupport text-to-Cypher or text-to-query safely, capping cost and traversal depth, allowing only permitted patterns, and validating before anything executesOwn how new data gets into the graph. Every change is validated, scored for confidence and traced back to its source before it is accepted, and anything wrong can be reviewed and rolled back Correctness over time Entities merge, split, rename, deregister and get acquired. Bitemporal modelling, slowly changing dimensions, and the ability to answer what was true on a given dateBuild the measurement that catches a 1% error rate before a customer does What We're Looking For Must Haves 6+ years building production data or graph systems, including at least one you designed and then operated at scaleA fully AI-native development workflow: agentic coding, AI-driven test generation and automated review pipelines as your default, not your experiment. In 2026, this is table stakes at FirmableProperty graph databases in production: Neo4j, Memgraph or similar, with Cypher, index and constraint design, traversal cost and supernode mitigationSchema extension without rebuilds: you have added node types, edge types and properties to a live graph repeatedly, and kept what was already in it correctGraph algorithms in production: PageRank, community detection, link prediction, shortest path and centrality, plus what each costs at billion-edge scale and when to precompute rather than run on demandHybrid store design: graph, warehouse and search each holding part of the picture, with a defensible view of what belongs where and how you kept them consistentRetrieval for machine consumers: graph RAG, agentic retrieval or equivalent, with a clear account of where it underperformed and what you did about itRetrieval optimisation: query planning and rewriting, index and projection design, materialised views and caching. You can take a traversal from seconds to milliseconds and explain what you changedSearch-side candidate retrieval: OpenSearch or Elasticsearch, with analysers, fuzzy and phonetic matching, and kNN over embeddingsCost and latency per query as a first-class metric: budgeted and measured, not discovered after a customer complainsRecord linkage on sources with no shared key: identity resolution or master data management, at a scale where the standard techniques stop workingBlocking, scoring, clustering and calibration: Splink, Zingg, Dedupe or a hand-built equivalentVery large scale, not negotiable: graph or linkage systems over billions of records, and a clear account of what actually broke. Traversal blowup, hot partitions, memory ceilings, skew, backfills, and what a full reprocess costs in both hours and dollarsReprocess economics: recalibrating a threshold means rerunning the matcher over the whole corpus, so you have views on incremental resolution and how to avoid a full pass every time something changesTemporal correctness: bitemporal or slowly changing dimension modelling, and the ability to answer what was true on a given dateEvaluation before implementation: you build the labelled set before the matcher, and you accept being measurably wrong rather than defending a number. A 1% error rate here is millions of specific false statements about real businessesInvention, not just application: a method you designed because the published approaches did not hold, with the evaluation that showed yours didPython, SQL, Cypher to production standard Highly Valued Snowflake at scale: window functions, clustering keys, incremental merge patterns, cost control on large joinsDistributed processing: Spark or Snowpark, with partitioning, skew handling and incremental processing chosen deliberately rather than by default. You know why a job that runs in an hour on a sample takes three days at full volumePipeline orchestration: dbt, Airflow or Dagster for scheduling, dependencies and lineageRegistry data in production: ASIC, ABR, NZBN, Companies House or SEC EDGARCorporate hierarchy resolution: parents, subsidiaries, brand families, trading namesInferred ownership attribution: shared IP addresses, multi-tenant infrastructure, and other cases where ownership is implied rather than statedVector search or learning to rank: alongside the linkage work rather than instead of itStartup or high-growth scaleup: shipped fast, owned outcomes end to end How We Build AI-Native, Not AI-Assisted Firmable is built on an AI-native engineering philosophy, and we mean that literally. We don't use AI as a productivity tool bolted onto traditional workflows. AI is the workflow. Every engineer at Firmable is expected to operate with fully agentic development, testing, and review pipelines as their default mode of working. This Means Agentic development: features are designed, scaffolded, and iterated with AI agents doing the heavy lifting — you direct, review, and elevateAI-powered test generation: test coverage is driven by AI agents that understand context, not manual test-writing as an afterthoughtAutomated code review: AI-assisted review pipelines flag issues, suggest improvements, and maintain standards before humans ever look at a PRContinuous AI feedback loops: traces, evals, and observability are built in from day one — not retrofitted later If you're not already working this way, this role will require a rapid and genuine mindset shift. We're not looking for people who are open to AI-native development, we're looking for people who already live it. The Operating Environment Firmable runs lean and ships fast, intentionally small teams, no layers, minimal process, and a weekly release cadence moving toward daily. Teams own their stack end to end: you design it, you build it, you ship it, you run it. This is a startup-to-scaleup environment and it comes with real expectations. There are no fixed hours. The pace is high, the team is always building, and when something matters it gets done. In return, you get genuine ownership, a seat at the table on every major architecture decision, and the opportunity to build something that doesn't exist anywhere else in the market. Why This Role Graph systems that have to keep growing. New entity types, new relationships and new sources arrive constantly, and the design has to absorb them rather than be rebuilt around themRetrieval beyond graph RAG. Making a graph this size and this connected cheap and reliable for AI agents to traverse is an open problem with no vendor answer, and the alternative is yours to designGlobal scale. 15M companies and 130M people, growing. Techniques that hold at a million records break here, and finding out where is the workLinkage that has to be right. Many sources, each keyed its own way, resolved into one canonical view of every businessResearch-grade problems, production constraints. The literature on both graph retrieval and record linkage runs out before our scale does. New methodology is expected, occasionally something closer to a fundamental breakthroughYour work is the foundation. Every product, signal and answer Firmable ships runs through this graphSmall senior team, no layers, real ownership Firmable is an equal opportunity employer. We believe diverse teams build better products.