Senior Software Engineer, Infrastructure and Blockchain

Senior Software Engineer, Infrastructure and

Blockchain

Starfield Fabric and NativX

Level Senior (staff track)

Reports to CTO

Location Remote; preferred Ukraine, Poland, or Hungary

Type Full time

About us

Starfield builds Fabric, one control plane that runs AI inference across a distributed fleet of GPU and

accelerator nodes. Fabric keeps each tenant's content inside the jurisdictions its policy allows, and lets

anyone check where a request ran without trusting our database. Every request is committed to Starfield

Chain, our OP Stack rollup, before it is placed. Batches are anchored to Arc, and energy is metered per

request.

NativX, our sister company, runs an exchange for compute capacity. Providers issue tokens backed by

compute they have proven they delivered, priced against COIL, NativX's compute index. Holders redeem

those tokens for real GPU time. Fabric is one of the systems that proves the delivery.

Both are early. Our first region is coming up on GPU servers we operate, and much of the system is specified

and being built now. You would join while the one-way doors in the architecture are still being decided, and

you would decide some of them.

The role

You own the parts of Fabric where infrastructure meets cryptography and chains, and you maintain and

extend the NativX provider stack. This is a hands-on role with broad scope: Go and Solidity most days, Rust

and Kubernetes on many, and bare-metal Linux when a node misbehaves.

You take over areas the CTO holds today and become their owner. That means you write or approve their

specs, review every change to them, decide their trade-offs, and answer for them in production.

What you will do

Custody and chains (Fabric)

Own the custody log end to end: the regional ledger and sequencer, signed batches posted to data

availability and the L2, the indexer that rebuilds job state from the chain, and per-region anchoring to Arc.

Maintain and extend the Solidity contracts: the workload ledger, node registry, residency policy, the Arc

anchor, and tenant escrow. Write their fuzz and invariant tests in Foundry.

Own how contracts are deployed and governed: deploy scripts, key ceremonies, multisig ownership, HSM-

held keys, upgrade policy, and rotation drills.

Take the chain path from testnet to mainnet, with a sequencer acknowledgment that never holds up

inference past its budget, batch posting that survives chain outages, and proofs a tenant can verify on their

own machine.

Infrastructure (Fabric)

Run each region's platform as code: Terraform on GCP, GKE, Cloud SQL, Cloud KMS and HSM keys, a

private CA, Binary Authorization, and Argo CD with Argo Rollouts for canaried deploys. Bring up new

regions from the same module.

Own the node side together with our inference engineer: the Go node agent on operator hardware, node

keys held in the TPM, signed releases, silicon adapters isolated in their own processes and cgroups, node

pairing, and the evidence that attestation scores.

Keep the system correct under failure. Changes reach one cell or one region first and roll back on their own.

Regions keep serving when the global tier is gone. Retries have budgets. Proof lag raises an alert.

Carry production: on-call for the regions and our GPU rack, incident reviews, and the runbooks that come

out of them.

NativX

Maintain and extend nxcc , the sealed Rust client a provider runs in its data center. It dual-signs delivery

reports with Ed25519 keys, keeps a forward-only hash-chained log, and talks only to pinned hosts.

Maintain and extend the Kubernetes fulfilment controller, which turns an on-chain redemption into a

metered GPU namespace and an attestation that settles the claim.

Work on the on-chain side with the NativX team: token registration, a mint authority bound to verified

delivery, and redemption and settlement on Arc.

Connect the two systems: export Fabric's metered delivery into NativX's index and redemption flow, and

help move proof of delivery from a signed software agent toward records signed by the hardware itself.

How we work

Specs first. Every slice of work has a spec with numbered requirements, a plan, and tests named for the

requirements they prove.

One-way doors get a decision record before code. Anything hashed, signed, or written to a chain, ID

formats, public APIs, and deployed contract addresses all count.

Concurrent protocols are modelled before they are built. Our sequencer, reconciler, lease, and

placement protocols have TLA+ models.

AI coding agents write much of the code from those specs. Engineers design, specify, review, and

decide. You review agent-written code as hard as a colleague's, and you know when to write it yourself.

No claim without evidence. If the console, the CLI, or a deck states something, a test or a measurement

backs it.

Nothing reaches a second failure domain before it has run cleanly in one. CI runs race, integration, and

mutation tiers, and every deploy has a canary stage.

What you bring

8+ years building and running production backend or infrastructure systems, several of them as the owner

of systems other teams or customers depended on.

Strong Go in production: concurrency, profiling, and careful error paths.

Working proficiency in Rust. NativX's client is Rust and you will maintain it.

Blockchain engineering shipped to mainnet:

Solidity with Foundry or similar; EVM internals, storage layout, gas, and the risks of each upgrade

pattern.

Signature schemes and proofs: secp256k1, EIP-191 and EIP-712, Ed25519, Merkle proofs.

How contract keys are held, rotated, and recovered: multisigs, HSMs, and key ceremonies.

Off-chain systems around contracts: you have run or built nodes, sequencers, batchers, or indexers, not

only written contracts.

Infrastructure at depth: Kubernetes in production, Terraform, a major cloud (GCP preferred), GitOps, PKI

and certificate management, workload identity, and secrets in KMS or HSMs.

Linux below the container: systemd, cgroups, networking and firewalls, drivers, and bare-metal servers you

have debugged over a console.

Distributed systems in practice: idempotency, ordering, append-only logs, at-least-once delivery,

backpressure, Postgres under load, and a message bus (we use NATS).

A security engineer's habits: threat models in which operators are untrusted, signed artifacts and supply-

chain verification (cosign or Sigstore), least privilege, and audit trails that hold up.

Clear writing. Design docs, decision records, and reviews are a large part of the job.

Nice to have

OP Stack internals: op-node, op-batcher, data availability layers, fault proofs, or running a rollup.

Remote attestation: TPM 2.0, measured boot, NVIDIA confidential computing, SPDM, or Caliptra.

GPU fleet operations: NVML, DCGM, vLLM, InfiniBand, BMC and Redfish.

Writing Kubernetes controllers and operators; Helm.

Exchanges, settlement, tokenized real-world assets, or energy metering.

Formal methods (TLA+) or deterministic simulation testing.

Stablecoin-native chains, Arc included.

Your first three months

Ship a slice of the custody log through spec, review, and merge in your first weeks.

Take ownership of the chain path and lead its move from testnet toward mainnet: contracts, keys, deploy

runbooks, and a rotation drill.

Put a NativX release into service on our rack, client and fulfilment controller, signature-verified, through a full

redemption.

Join the on-call rotation for the first region.