Senior/Staff Software Engineer - Ethena Pay

We're building a new engineering team at Ethena to own Ethena Pay neobanking style app built on top of our stablecoin

infrastructure. As the Staff/Senior Engineer, you own the correctness and evolution of the money-paths at the core of the product

— payments, payouts, deposits, transfers, and reconciliation — and the app-facing APIs and authentication backend the native

mobile app depends on.

Your north star: money always moves correctly, exactly once, and observably; and every request the Ethena Pay app makes is fast,

well-versioned, and secure. This is a senior IC role with real design authority over the backend — you set the standard for how

these services are built, not just execute tickets.

• Own the app-facing API contract as a product: versioned, backward-compatible endpoints with client idempotency keys, a

consistent error model, and clean pagination, built in partnership with the iOS team.

• Own the authentication and authorization backend, including the passkey/WebAuthn relying party, session/token lifecycle, and

authorization enforcement at every API boundary.

• Set patterns, tests, and documentation so the backend can be safely extended by any engineer, raising the correctness, testing,

and security bar by example and in review.

• Trace and document money-paths end-to-end, from API through wallet/executor/submitter/indexer, event streams, and on-chain

settlement, closing real correctness and reliability gaps as you go.

• Ship fast, test-first. Deliver on a tight cadence with test-driven and behaviour-driven development — you can prove the

correctness of a payout path, not just its happy path.

• Proven experience building and operating backend systems that move real money in production — payments, exchange/settlement,

lending, banking, or crypto — with a track record of preventing (or fixing) idempotency, rounding, or reconciliation bugs.

• Experience designing and owning client-facing APIs consumed by a mobile app at scale: contracts, versioning and backward

compatibility, idempotency keys, error models, pagination, and rate limiting.

• Experience building or operating an authentication/authorization backend — OAuth2/OIDC, JWT session/token lifecycle, RBAC/ABAC

scopes, MFA/step-up — ideally including a WebAuthn/passkey relying party.

• Hands-on integration with real financial third parties end-to-end (card issuing, KYC/fiat ramp partners, or payments/settlement

providers), including their webhooks, failure modes, and reconciliation.

• On-chain settlement literacy from the backend — nonces, gas, reorgs, RPC failure, confirmation depth — treating chain data as

untrusted input.

• Strong TypeScript (or a fast, credible path from Go/Kotlin/Rust/Java), with Postgres, an event/queue system

(NATS/Kafka/SQS-class), and gRPC-based service-to-service communication at production scale.

• A test-first culture matching ours — BDD/integration testing with real dependencies (Testcontainers-style) — and fluency with

agentic development workflows (Claude Code, MCP, skills) as a core part of how you engineer.