Backend Engineer (Data + APIs)

About the Role

We’re building measurement-driven systems where results are only trustworthy if the assumptions behind them are continuously checked. That means the backend can’t just store data—it has to keep the contracts alive at runtime: capture telemetry, record provenance, enforce validity gates, and make it easy to answer “what happened, when, and why did we trust it?”

This role owns the data plane and API surface that turns devices + algorithms into a dependable product: ingestion, storage, audit logs, contract evaluation, and customer-facing APIs.

What You’ll Do

• Data ingestion pipelines: design robust ingest paths for device streams (batch + streaming), handle backpressure, retries, dedupe, ordering, and schema evolution.
• Telemetry as a first-class product: model and store timebase health, sampling health, calibration state, and on-device diagnostics; make it queryable and alertable.
• Audit logs & provenance (“receipts”): ensure every result is reproducible: dataset hash, firmware version, calibration constants, config used, algorithm version, window validity scores, abstentions/failures.
• Contracts alive at runtime: implement evaluators/gates that record whether a window/run met required promises (coherence thresholds, drift bounds, saturation flags) and prevent “bad truth” from being presented as truth.
• APIs for product + partners: build stable APIs for device registration, data upload, run retrieval, diagnostics, reports, and integrations (BMS/ops tooling where relevant).
• Storage architecture: choose and implement storage for raw streams, derived artifacts (features, spectra, delay tracks), and reports; manage retention, indexing, and cost.
• Multi-tenant security: authN/authZ, tenant isolation, secrets management, rate limiting, secure auditability.
• Operational excellence: monitoring, tracing, SLOs, incident response playbooks, safe migrations.

Concrete Deliverables

• An ingest + storage service that reliably accepts device data and produces a canonical internal representation.
• A telemetry schema that supports deep debugging (clock drift, dropouts, calibration staleness, coherence collapse) without ad hoc logs.
• A run receipt / audit log system: immutable records tying every computed output to inputs + versions + validity gates.
• A contract evaluation service that emits: pass/borderline/fail with reasons and is surfaced in APIs/UI.
• Customer-facing APIs (and internal SDKs) that make integration straightforward and stable.

Required Qualifications

• Strong backend engineering experience building data-heavy services (ingestion, APIs, storage, reliability).
• Experience with event/telemetry systems: time-series data modeling, streaming or batch processing, schema/version management.
• Proficiency in one or more backend stacks (Go/Java/TypeScript/Python/etc.) and API design (REST/gRPC).
• Comfort with cloud infrastructure (deployments, monitoring, queues, object storage, databases).
• Security fundamentals: auth, tenant isolation, audit logs, least privilege.

Preferred Qualifications

• Experience with IoT/device fleets: provisioning, device identity, OTA metadata, unreliable networks.
• Familiarity with time-series databases and hybrid architectures (object store + metadata DB + feature store).
• Experience implementing reproducibility/provenance systems (lineage, manifests, immutable logs).
• DSP/measurement-adjacent intuition: you don’t need to design estimators, but you respect validity gating and traceability.

How You’ll Be Measured (First 60–90 Days)

• You ship a reliable ingestion path with clear schemas, strong observability, and safe evolution.
• You implement a receipt/audit log that lets the team reproduce a run and explain trust decisions quickly.
• You bring contracts alive at runtime by persisting validity scores and gating decisions as first-class data.
• You reduce time-to-debug by making telemetry queryable and correlated with outputs.

Working Style

• You build systems that answer uncomfortable questions quickly: what changed, what version ran, was the data valid?
• You favor explicit schemas and immutable receipts over “best effort” logging.
• You treat reliability and observability as product features, not afterthoughts.

Title & Level

Backend Engineer (Data + APIs) (mid-to-senior; can scale to Staff if owning the data platform architecture), partnering with embedded, systems, algorithms, and product/UI.