Engineering Manager / Tech Lead - Ethena Pay

P2P; Lisboa; Presencial; EUR 90 000 - 130 000; Tempo integral

Resumo da oferta

Ethena is building a new engineering team for the Ethena Pay product, a neobanking experience on our stablecoin platform. You’ll lead technically and people‑wise, shaping architecture, setting engineering bar, hiring, and delivering the hardest parts yourself.

This hands‑on player‑coach role balances leadership with coding; as the team grows, leadership expands, but coding remains central to the role.

Qualificações

• Led engineering for a consumer money product with real financial stakes.
• Led a small team while shipping code yourself and previously contributed production code.
• Owned production operations including on-call and incident resolution.
• Oversaw integration with regulated financial rails and banks.
• Led disciplined, fast delivery in an agile setup with strong test practices.
• Used agentic development concepts to multiply engineering impact.

Responsabilidades

• Write production code as a top IC while guiding the team through critical work.
• Own the architecture across services, data model, and infrastructure at scale.
• Build and onboard engineers, raise the hiring bar, and grow a senior team.
• Set high engineering standards: CI, testing, and safe development practices.
• Drive delivery cadence with versioned releases and a healthy backlog.
• Establish reliable operations with runbooks and incident response.

Conhecimentos

Backend leadership

TypeScript/Node

Agile delivery

Incidents & on-call

Regulated rails integration

Hiring & team building

Coding as IC

Ferramentas

Postgres

Kubernetes

IaC

Observability

OAuth2/OIDC

Descrição da oferta de emprego

Role Overview

We're building a new engineering team at Ethena to own the Ethena Pay product. A neobanking experience app 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.