Backend Data Platform Engineer

Salary: $80,000 – $120,000 per year + Super

ABOUT THE WORK

Aston Dynamics builds brake-by-wire systems for trailers and autonomous vehicles.

Our electric-over-hydraulic (EoH) platform replaces conventional mechanical override and electric-drum trailer braking with electronically controlled hydraulic actuation, giving faster, more precise, independently controllable braking.

The data you'll handle comes off real machines. An actuator streams what it did over Bluetooth to a user's phone, and that data is how we learn what our hardware does in the field - and eventually how our customers understand their own fleets. You would own the entire server side of that story: a Rust telemetry pipeline that ingests, parses and stores high-rate sensor data, and a set of Python services handling device provisioning, device claiming, error-log ingest and OTA firmware distribution.

Some of what's described below exists and needs hardening; some of it doesn't exist yet and is yours to design. This is an early-stage platform, and whoever takes this role will make architectural decisions that at a larger company would have been made for them.

RESPONSIBILITIES

• Build on the architecture for receiving telemetry from units in the field, and decide how our existing ingest path evolves to get there.

• Own our device services: provisioning, claiming, firmware distribution, and the relational database behind them.

• Build the upload path from the mobile app to our database: batched writes, idempotent submission, and correct handling of the same unit being relayed by more than one phone. You'd design this jointly with the mobile engineer we're hiring alongside you.

• Design how device time reconciles with upload time. Actuators are read opportunistically, so data may arrive hours or weeks after it was recorded, out of order, and with unreliable device clocks.

• Own the on-wire payload format shared with our device software, and version it so that older firmware already in the field keeps working.

• Own a queryable time-series data model: indexing, aggregation, retention and schema migration.

• Expose that data through versioned APIs for the companion app, for internal engineering analysis, and for customer-facing reporting. You'd be setting that convention rather than inheriting one.

• Design device identity, authentication and per-customer access scoping across multiple brands - including verifying which units a given phone is entitled to report on. A technician's phone may be near units belonging to three different customers, so the app's claim about where data came from cannot be trusted on its own.

• Own deployment, monitoring and alerting, including detecting when incoming data is wrong rather than merely absent.

REQUIREMENTS

• Production Rust; our ingest hot path is async Rust.

• Python, for our device services and scheduled tasks. By volume this is the largest body of backend code we have, and most weeks will include it.

• Strong hand-written SQL and relational data modelling, ideally with time-series or high-write workloads. There is no ORM in the telemetry path.

• Experience running a service in production on AWS - Lambda, API Gateway, ECS, RDS, S3. Note that our estate is currently operated with very little infrastructure-as-code, so the relevant skill is both operating it as it stands and bringing it under control over time.

• Experience designing APIs consumed by mobile clients.

• Multi-tenant access control and data isolation, on a safety-relevant product.

NICE TO HAVE

• TimescaleDB, or comparable time-series extensions and storage engines.

• Redis Streams, or other durable queue and consumer-group systems.

• Binary or compact wire formats: custom framing, Protobuf, CBOR or similar.

• Parquet, Arrow and columnar storage economics.

• Data originating from embedded devices or gateways rather than from browsers.

• Node and Prisma at "read it and make small changes" depth

• Rust on the device side, or willingness to read it - our BLE library and firmware are both Rust