Senior Software Entwickler:in - Rust

At Retire Capital, we're building a digital retirement-withdrawal platform — a professional cockpit for sustainable asset decumulation.

We tackle a real gap in the German financial landscape: helping financially literate people (55+) draw down their portfolios confidently and sustainably, optimizing across withdrawal strategies, allocations, rebalancing, and historical market environments.

Our simulation engine evaluates hundreds of thousands of parameter combinations across decades of market data — annuity vs. constant-withdrawal rules, corridor-based smoothing, glide-path rebalancing — to surface the strategies that actually survive real-world conditions.

This is applied financial mathematics, not another robo-advisor.

The Role

You'll be our second technical hire, shaping both the product and the engineering culture from day one.

It's a senior, hands‑on role: you write code, ship features end‑to‑end, and help set the technical direction for a platform that operates under regulatory oversight and handles sensitive financial data.

You'll work closely with the founders in a deliberately small, high‑leverage team.

Our target is 3–5 engineers, we believe AI‑augmented, end‑to‑end engineers replace the need for large, specialized teams.

What You'll Do

• Ship end-to-end: Design, build, test, and deploy across the full stack — from domain modeling and financial algorithms through API design to interactive UI.

No handoffs, no silos.

• Own the architecture: Evolve it, enforce dependency rules, and make pragmatic calls.
• Advance the platform: Extend a Rust‑native fullstack system that compiles a single codebase to both a native server binary and a WASM client — with compile‑time guarantees enforcing the boundary between them.
• Build for correctness: Withdrawal math must be numerically stable, validation provable, and security primitives implemented without shortcuts.
• Scale the team: Establish practices that keep a small team fast.

What We're Looking For

• 7+ years of professional experience, with meaningful time in complex, statically typed systems.

We value depth over breadth — if you've spent years reasoning about ownership, lifetimes, type systems, or protocol correctness, let’s talk.

• A proven track record of delivering features end‑to‑end. You don't identify as "backend" or "frontend" — you're an engineer who ships.
• A strong architecture foundation: hexagonal/ports-and-adapters, dependency inversion, and knowing when to pragmatically break the rules.

You fight accidental complexity relentlessly.

• Production experience with regulated or security‑sensitive systems (fintech, healthcare, identity, or similar) where correctness isn't optional.
• Technical background

We especially value depth in technologies that reward sustained thinking — the kind you can't shortcut with a prompt. Pre‑AI experience in any of these is a strong signal:

• Rust (strongly preferred): ownership, trait‑based polymorphism, async runtimes, procedural macros, WASM targets. Our entire production stack is Rust.
• Systems programming: memory models, concurrency primitives, zero‑copy abstractions, performance‑critical numerical computation.
• Cryptography & security: authentication protocols, encryption, key management, secrets handling in production.
• Applied math / quant finance: annuity formulas, Monte Carlo simulation, portfolio theory, statistical modeling.
• Infrastructure as code: Terraform/Open Tofu on GCP (Cloud Run, Cloud SQL, VPC, IAP). You've operated what you've built.

We embrace AI to move faster and unlock new capabilities — and we mean it.

Claude Code is our daily co‑engineer, and we expect you to be fluent in AI‑assisted development: prompting, reviewing, iterating, and integrating AI‑generated code into production.

But we draw a hard line on accountability.

AI is a capability multiplier, not a responsibility diffuser.

When you merge code Claude helped write, your name is on it — you understand why it works, and you stand by it as correct.

In practice, that means knowing when AI output needs scrutiny and when it can be trusted, breaking complex tasks into AI‑friendly units with good context, and catching the subtle correctness issues that slip past a surface‑level review.

How We Hire

The age of AI changes how startup teams should be built

• End‑to‑end only: we hire engineers who deliver across the full stack — no pure‑frontend, backend, or infra roles.
• Small by design: more shipped by fewer people. Our ceiling is 3–5 engineers — enough to cover on‑call, vacations, and illness.
• Depth as signal: 3+ years of pre‑AI experience in a demanding stack (like Rust) shows a willingness to think deeply — something no credential or take‑home test can reliably prove today.
• References as primary qualifier: we'll ask to interview named references from your past roles.

When CVs and take‑homes can be AI‑generated, colleagues who worked beside you are the signal that still holds.

What We Offer

• The chance to shape a regulated fintech product — and its engineering culture — from the earliest stage.
• A Rust‑native, architecturally disciplined codebase. Not a legacy migration, not a throwaway prototype.
• A technical co‑founder who writes code, knows the architecture, and reviews your PRs with the same rigor you bring to his.
• A team that treats AI as a first‑class engineering tool — not a novelty, not a threat.

If building correct, elegant systems in Rust with a small team of people who care about their craft sounds like your kind of work, we'd love to hear from you.

#J-18808-Ljbffr