Software Engineer (Functional Programming / Fintech)

The team

The Craft function has seven small, cross-functional engineering teams - each with engineers, an engineering manager, and a product manager, working closely with designers. You'll join one team that owns a product area end-to-end.

When we start work, we explore multiple solutions before picking one. You'll write RFCs, build proof-of-concepts, and run experiments to validate approaches. Once we commit to building something, we care about maintainability more than cleverness, observability more than hoping it works, and scalability more than premature optimisation. We ship quality code over hitting arbitrary deadlines. Once something goes live, we refactor the rough edges rather than polish what's already working.

The opportunity

Right now, we're building card issuing from scratch, going direct on Faster Payments, enabling cross-border payments, and building term deposit accounts. Day to day, this means: writing the reconciliation systems that process millions of FPS transactions, implementing double-entry accounting that tracks card spending and settlements, designing webhook infrastructure with message signing and replay protection, building API versioning that lets us evolve without breaking customers, or creating payment approval workflows that satisfy both user experience and compliance requirements.

What success looks like

Success here is about impact beyond your own code: improving how we work, making other engineers more productive, and building systems that our customers (other developers) actually want to use. This looks like:

• redesigning the transaction reconciliation service to handle 10x throughput before we hit FPS volume limits
• fixing the root cause of webhook delivery failures so we stop getting paged at 3am
• building a Bazel rule that cuts build times in half for the whole team
• writing an RFC that becomes the pattern we use for all event-driven services
• pairing with another engineer to help them reason through FoundationDB transaction semantics
• owning card issuing from initial RFC through to processing the first live transaction - making every architecture and implementation decision along the way.

What you'll own

• The technical decisions on your projects - you'll write the RFCs, choose the architecture, and decide when to extend existing systems versus rebuild them
• Delivery from customer problem to live feature - you'll work with PMs to shape what gets built, then own getting it into production
• Setting technical direction - your code reviews, implementation patterns, and architectural choices influence how the wider team builds software
• Production responsibility - the systems you build are yours to monitor, debug, and improve when issues arise

Your background

You'll fit well here if you come from one of these backgrounds:

• Functional programming - you've shipped production Clojure, Elixir, Erlang, Haskell, Scala, or Scheme in a professional setting, or you've built substantial personal projects that demonstrate deep functional programming experience
• Fintech domain expertise - you've worked in payments, accounts, ledgers, or compliance where you've dealt with money movement, reconciliation, and regulatory requirements

Beyond that, you'll need:

• Strong software fundamentals and distributed systems knowledge - you understand consistency models, idempotency, and the failure modes that actually matter in production
• Experience working in product-focused, collaborative teams - you've shaped what gets built alongside PMs and designers, not just implemented specs

Comfort with startup pace and ambiguity - priorities shift, requirements evolve, and you adapt without needing perfect clarity upfront