Product Systems Engineer (AI-first, Systems-thinking, Serverless)

Superpositional builds a control plane for software engineering. As AI makes code cheap, the bottleneck becomes consequence: what breaks, what drifts, and what this change means for the whole system.

We’re building the system graph that lets agents act with constraints, not vibes.

You will operate end-to-end across the surface area of the product. You will bring product judgement to engineering decisions. Roadmap ownership sits with me for now, and we will delegate it over time as the system and the team mature.

What “product systems engineer” means here

• You are a product-minded generalist engineer first.
• You use AI tools as leverage, not as authority.
• You distrust AI outputs by default, then you verify with constraints, tests, types, and instrumentation.
• You sit outside the hype curve. You apply cool-headed pragmatism to build what works.
• You are comfortable on the bleeding edge when it buys speed or capability, and sceptical when it buys novelty only.
• You optimise systems to staggering efficiency, but only once the system demands it.
• You treat code as a liability. We still need it, so we own the least we can and distil the rest into high-value, well-factored pieces.

What you’ll do

• Build end‑to‑end product surfaces: UX → API → storage → infra → observability → rollout.
• Ship serverless systems on AWS (S3, Lambda, IAM, queues, eventing) with clear boundaries, failure modes, and cost behaviour.
• Use SST v4 to move fast without turning infra into a bespoke snowflake.
• Write real production code in TypeScript and Rust where it matters (performance, correctness, interfaces, operational control).
• Own the full feedback loop: instrument, measure, debug, and iterate until the system behaves.
• Treat AI agents as force multipliers: decompose work into tasks, define interfaces, validate outputs, and keep the system coherent.

What “AI‑first” means here

We don’t want “prompt engineers”. We want engineers who can:

• Specify work as constraints + interfaces + tests.
• Delegate to agents, then verify with instrumentation, types, and invariants.
• Keep a clean mental model of the system while shipping quickly.

Our stack (what you’ll touch)

• Frontend: React, Next.js
• Backend: TypeScript, Node, serverless patterns
• Infra: AWS + SST v4, event-driven systems
• Systems code: Rust (selectively, with intent)

What we’re looking for

• A whole‑shebang engineer. You don’t hand off “the hard part” to someone else.
• Systems thinking. You reason about behaviour under load, partial failure, retries, queue backpressure, idempotency, and cost.
• Strong product instincts. You can build something people use, not just something that compiles.
• Comfort operating in ambiguity. You turn fuzzy goals into concrete interfaces and shipped artefacts.
• High standards for correctness without ceremony.

Signals we like (examples, not requirements)

• You’ve shipped a serverless product end‑to‑end.
• You’ve built a React/Next UI that talks to real APIs with real error states.
• You’ve owned production incidents and can explain the root cause and the invariant that would have prevented it.
• You’ve used AI tools seriously, and you’ve learned where they fail.

Why this role exists

We’re early. The product and the system are still being shaped. Your work will define the initial architecture, the shipping cadence, and the standards for how we use agents in production engineering.