Senior Staff Backend Engineer

The Senior Staff Backend Engineer owns the core services at the heart of the platform: the data-intensive computation layer that turns curated financial and operational data into correct, reproducible, fully traceable results.

This is the structured engineering beneath the product. Not dashboards, not an LLM wrapper. The services that do the heavy computation and stand behind every number the platform produces.

The output of this layer sits next to externally reported financials, so correctness is not negotiable. Every result must be traceable to source, reproducible, and auditable, with clear guardrails keeping verifiable results separate from anything that requires human review. Nothing is ever quietly fudged to make the math look complete. That standard is the reason this role exists at this level.

The architectural bet is configuration over code. A new customer or a new domain should be a configuration change, not a fork. You build the composable component library and the runtime that executes it, so the platform absorbs variation without accumulating bespoke code paths nobody can safely change two years from now.

This role is forward-deployed. You will spend meaningful time working inside enterprise customer environments, embedded with their engineering and finance teams, rather than only in our codebase. Roughly [XX]% of your time is customer-facing engineering work and [XX]% is core platform development, with travel [SPECIFY]. You are an engineer, not a consultant: you own core services in our platform and you are accountable for their correctness whether or not you are on a customer site.

We work this way because the gap between a system that works in a test environment and one that works against a real Fortune 500 close cycle is where the hard problems live. On customers specifically: we work with large enterprises whose finance organizations operate at significant scale and complexity. We are not naming them publicly right now, and we will talk through the customer landscape in more detail as conversations progress.

Key Responsibilities

1. Own the services that perform the platform's core financial and operational computation. Build a composable library of reusable computation components driven by configuration. Produce results that are fully traceable to their source inputs, and compute the supporting quality and confidence signals around each one.

2. Express complex logic as correct, performant, set-based computation over the warehouse. Guarantee results reconcile and are reproducible. Own the performance and cost of the core services, not just their correctness.

3. Build the runtime that executes per-domain configuration. New domains and use cases onboard as configuration, never as a bespoke code path. Keep the component library extensible, because the value of this design collapses the first time someone forks it under deadline pressure.

4. Enforce guardrails over automated output in code. Build the controls and feature-flag system that scopes or disables automated behavior per tenant or per feature. Build audit logging and lineage for end-to-end traceability to source, so any figure can be defended.

5. Build for a multi-cloud-ready, multi-tenant-ready, customer-hosted deployment model. Services that run inside a customer's environment with strong isolation and no data egress. Designing for environments you do not control is a different discipline from designing for your own.

6. Work embedded with customer engineering teams to integrate the platform into their environment and data landscape, and bring what you learn back into the core so the next deployment is configuration rather than bespoke work.

7. Set patterns, review designs, and mentor the backend team. Partner with data, AI, and product on service design and on where the boundaries between layers sit.

A note on accountability: this role owns the core computation services, the configuration runtime, the guardrails and audit trail, and the technical patterns the backend team builds against. It does not own the data foundation, the AI layer, product prioritization, or the commercial relationship with customers.

Required Qualifications

Eight or more years in backend engineering, in Python, Go, Java, or similar, with significant Staff-level time owning complex, data-intensive systems. Owning them, including their failure modes.

An obsession with correctness, traceability, and testability. "Every result is explainable and reproducible" reads to you as a requirement rather than an aspiration.

Elite SQL and data modeling. Window functions, large-scale joins, and rigorous reasoning about both correctness and performance. This is not a role where SQL is something you reach for occasionally.

Experience designing configuration-driven, extensible service architectures, and the judgment to know when that abstraction is earning its keep and when it is not.

Strong system design for reliability, isolation, and reproducibility.

Direct experience working with customers or external stakeholders in a technical capacity. Debugging in environments you do not control, with data you did not model, and explaining technical outcomes to people who are not engineers.

Python, SQL against Snowflake or PostgreSQL, config-driven and rules-engine architectures, and Docker, Kubernetes, and Terraform for multi-tenant customer-hosted deployment.

Nice to Have

Finance, accounting, or analytics domain, or a genuine willingness to learn how financial statements are built and reconciled.

dbt, and multi-tenant customer-hosted deployment at scale.

Exposure to ML and statistical workflows and LLM application patterns, enough to integrate them well.

Building auditable systems in a regulated environment.

Forward deployment, professional services, or solutions engineering background at a product company.

What Good Looks Like

Core computation services that produce correct, reconciling, fully traceable results from curated data, every time, under audit.

A composable, configuration-driven component library that extends to new domains without new code paths, and that other engineers reach for rather than route around.

A configuration runtime so new use cases onboard as configuration rather than bespoke engineering, with onboarding cost falling measurably per customer.

Guardrails, controls, and full lineage that make automated output auditable and safely scoped per tenant.

A deployment pattern for at least one enterprise customer that the next deployment reuses rather than rebuilds