Senior Software Engineer - GoLang (FinCore) at Bash

• The FinCore division owns the financial infrastructure and customer experiences behind payments, refunds, credit usage, tokenisation, stored value, reconciliation, and fraud. We're not a fintech incubator dabbling in ideas, and we're not a platform team quietly keeping the lights on. We own these capabilities end to end and are accountable for the systems that reliably scale across every Bash channel.

We're hiring Go Engineers

• FinCore has two teams. Both own customer-facing and backend services, but they solve different problems and suit different engineers.
• Payments: We own the systems that take money, reverse it, and prove afterwards that both happened correctly, across every Bash channel and every payment provider.
• Wallet: We own the systems that provide customers with stored value. A balance customers can hold and spend, with or without credit.

What you'd actually work on

• Real-time, distributed systems where being correct and being fast are both non-negotiable, regardless of the system load. 
• Instrumentation good enough to answer "what actually happened here, for this customer" without guessing. Every meaningful state change is its own event with its own timestamp, because the next decision reads through it.
• Payment flows where correctness is not negotiable. Authorisation, capture, refund and settlement across multiple providers, each with its own idea of what a timeout means. Retries, idempotency and partial failure are routine here, not edge cases.
• Reconciliation. Matching what we think happened against what the provider, the bank and the ledger think happened.
• Credit origination against external systems where a single call can take tens of seconds, a customer is waiting on the other end, and duplicate submissions carry regulatory consequences.
• The road to a spendable balance. Funding a balance, holding it, controlling where it can be spent, and the refund paths that have to exist alongside it. Some of this is unbuilt and some of the design questions are still open, you'll help form this.

The Stack

• Go for backend services. 
• Around it: AWS, CloudFlare, Kubernetes, Temporal, Redis, RDS, Prometheus, Sentry.
• Internal tools and admin surfaces are built in Retool, and we plan and track work in Linear.

You'll fit well if you have

• 4+ years building production backend systems, ideally in Go - or you're strong in another language (Java, C#, Python, Node, Rust, whatever) and keen to go deep on Go. 
• A real curiosity about distributed systems - consistency, failure modes, and what happens at 2am when one node disagrees with the rest. You don't need to have all the answers here yet. You do need to find the questions interesting.
• The ability to take a feature and drive it to completion. You can break it down, spot the ambiguity, ask the right person the right question, and ship. 
• A habit of writing code others can live with. Well-tested, readable, debuggable. You give useful code review feedback, not just an approve button. 
• A bias toward observability and monitoring - you'd rather know than guess. You care whether the thing you shipped actually worked, and you know how to check.
• Clear communication. You can explain a technical trade-off, flag a delay before it becomes a surprise, and write a runbook that saves the next person a day.
• An instinct to understand why before building the how - you'd rather help steer a solution than wait for one to arrive. 
• Comfort with agentic coding tools, but you still read and validate everything "you" commit.
• A BSc in Computer Science (or equivalent) is a nice-to-have, not a gate. Strong, demonstrable experience speaks louder.

How we work
We're a cross-functional, agile team, but we care less about ceremony and more about how engineers actually operate day to day:

• You run your own day. You manage your own work, unblock yourself where you can, and shout early and clearly when you can't. 
• You build to last. Resilient, maintainable, observable. You hold a high bar on testing and code review - and you'll be surrounded by people who hold it too, which is the fastest way to raise your own.
• You share the load. That includes pitching in on operational work and an on-call rotation for critical alerts - because the people who built the systems are the people best placed to keep them healthy. We take on-call seriously and it’s our job to not make it miserable.
• You get better, and you help others get better. We rotate on solution ownership,  we collaborate within and across teams, we take part in engineering Guild sessions, we write RFCs, we mentor where it’s welcomed. 
• You'll know what "next" looks like. We have a progression framework and growth is a conversation, not a guessing game.