Engineering Manager / Tech Lead

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.

• 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.

• 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.

• 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.