Role Overview

We're building a new engineering team at Ethena to own a money-movement product built on top of our stablecoin infrastructure. You'll take the technical and people leadership of that team, shaping the architecture, setting the engineering bar, hiring the people around you, and shipping the hardest parts yourself.

This is a hands-on player-coach role, not a hands-off manager seat. While the team is small, you'll spend most of your week writing and shipping production code — you'll be one of the strongest individual contributors on the team, take the most critical work yourself, and review everyone else's. Leadership, architecture, and hiring sit on top of that, not in place of it. As the team grows the balance shifts toward leadership, but coding stays a standing part of the job.

It's a rare combination: the scope and autonomy of an early-stage build — you own the architecture, shape the team, and decide how it works — with the backing, treasury, and distribution of one of the largest companies in stablecoins behind you.

Role Responsibilities

• Write and ship production code most days as one of the team’s top ICs, taking on the hardest and most critical-path work and unblocking the team members you’re responsible for.

• Own the architecture. Hold the whole system in your head — services, money-paths, data model, infrastructure, on-chain settlement — and make the design calls that keep it correct, legible, and extensible as it scales.

• Build the team. Run a rigorous, humane hiring loop; raise the bar; onboard new engineers with real plans; grow a small senior team that works in the open.

• Set and hold a high engineering bar. Non-author review on money paths, CI required to merge, small PRs, disciplined testing (TDD / BDD as the default, not an afterthought), always-on automated review, idempotency and correctness treated as non-negotiable. Establish safe, effective agentic-development practices as the team's default.

• Own the delivery cadence. Run a tight, high-velocity delivery process — sprints or kanban, whatever fits the team — with predictable, versioned releases, a healthy backlog, and short lead time from idea to production. Ship fast without lowering the bar.

• Make it reliable. Drive real production alerting, an on-call rotation that pages a human, tested runbooks, and incident response — so the team can build, ship, and run the product with confidence.

Required Skills and Experience

• You've led engineering for a consumer money product — a neobank, payments, or crypto money app - where a bug moves or loses real customer money. You owned an engineering function where correctness had genuine financial stakes.

• You've led a small team (~3–8) while still shipping code yourself — tech lead, staff, or hands-on engineering manager. You've shipped production code within the last year; this is not a management-ladder-only background.

• You've owned production operations for a money system — on-call, real incidents, observability, secret and key hygiene — not just delegated it. You can name incidents you personally drove to resolution.

• You've owned, or overseen the integration of, regulated third-party financial rails — at least two of: card issuing / BIN-sponsor programs (Marqeta, Lithic, Kulipa, Stripe Issuing), identity / KYC / onboarding (SumSub, Persona, Onfido), banking or fiat on-/off-ramp partners (a BaaS or ramp partner), and key custody / signing (cloud KMS, HSM, MPC, or multisig).

• You run a high-velocity, disciplined delivery process. You've led a team that ships fast and predictably in an agile setup — sprints or kanban, versioned releases, short lead time to production — without trading away quality. Test-driven and behaviour-driven development are how you build, not box-ticking.

• You're agent-native. You wield agentic development — coding agents (e.g. Claude Code), MCP servers, reusable skills — as a core multiplier, with a real point of view on adopting it safely on a money product. Fluent, not a dabbler; you know the failure modes and verify output.

Technical breadth to lead this team

• You'll lead engineers across backend, platform, and mobile, and set the standard each is built to. You must be deep in backend / distributed systems and genuinely literate across the rest — enough to review the work and make the architecture call in each:

• Backend & payments correctness (your core). Strong TypeScript / Node (or a credible senior path from Go / Kotlin / Java); you think natively in idempotency, reconciliation, retries, and consistency under partial failure, across event-driven services and Postgres.

• Client-facing APIs & auth. The app-facing API as a product — versioning, idempotency keys, a clean error model — plus the auth backend behind it (OAuth2 / OIDC, session lifecycle, WebAuthn / passkeys).

• Platform & reliability. Enough Kubernetes, IaC, and observability (OTel / Grafana-class) to own the deploy/rollback story and hold the reliability bar — you know the difference between a dashboard that exists and an alert that pages.

• Native mobile. Enough to review a native iOS app (Swift / SwiftUI) and reason about mobile ↔ backend contracts, failure states, and on-device auth.