Senior Software Engineer

FinTech Collective, LLC; Barcelona; Presencial; EUR 110.000 - 170.000; Jornada completa

Descripción de la vacante

FinTech Collective, LLC is seeking a Senior Software Engineer for the Core Platform team that runs a real-time payment ledger. You will work on how transfers are accepted, recorded and confirmed, with strong emphasis on correctness under high concurrency.

You’ll own design, write tests, review code, profile performance, and lead cross-team initiatives such as partitioning and capacity planning. The stack is TypeScript/Node.js, PostgreSQL, Kafka, on Kubernetes, and success is measured by

Formación

• Seven+ years building backend services in production.
• Strong TypeScript and Node.js, or a strong backend language with quick TS ramp-up.
• Writes tests as part of the work, including load tests.
• Has supported their own services in production and led incident investigations.
• Explains and defends a design clearly, in writing and in review.

Responsabilidades

• Ship features from team backlog to production with tests and reviews.
• Profile hot paths and optimize performance for scaling.
• Design schemas, indexes and queries to maintain throughput during growth.
• Lead cross-team design work (partitioning, capacity planning) and mentor others.

Conocimientos

Backend experience

TypeScript

Node.js

Testing (load tests)

Incident investigation

Design articulation

Herramientas

PostgreSQL

Kafka

Kubernetes

Docker

Descripción del empleo

Minka builds real-time payment infrastructure. At the centre is a cloud-hosted ledger that banks, wallets and payment schemes settle through. The Core Platform team builds and runs that ledger. As a Senior Software Engineer on this team you work on the parts of the system that every payment passes through: how a transfer is accepted, validated, recorded and confirmed, how balances stay correct when many transfers touch the same account at once, and how the whole system holds up as volume grows. The work is in TypeScript on Node.js, with PostgreSQL and Kafka, running on Kubernetes.

The first job is to ship. You take work from the team backlog, design it with the team, build it with tests, get it reviewed and into production, and look after it once it is live. When something breaks, you find the cause, fix it and write down what happened.

After that comes performance and scale. You profile the hot paths and remove what slows them down. You design schemas, indexes and queries so that throughput grows with hardware and does not stall on locks or long transactions. You decide what is cached, where, and how it is invalidated, so that a cache never shows a balance that is out of date. You design the event flows between services so that every message is processed exactly once and the system recovers on its own after a broker or a consumer fails.

Later you lead design work that reaches across teams: partitioning strategy, capacity planning, how the ledger behaves during a failover, and what the platform guarantees to the integrations built on top of it. You help other engineers grow through review and pairing.

Success is measured by four numbers:

• sustained transactions per second the ledger handles in load tests, which should rise with each release
• latency at the 99th percentile for a transfer under load, which should fall and stay within the agreed limit
• production incidents caused by your own changes, which should stay at zero
• time to recover after a database or broker failure in a test environment, which should come down to minutes with no manual steps

Requirements

Must have:

• Seven or more years building backend services in production
• Strong TypeScript and Node.js, or a strong backend language and the ability to become productive in TypeScript quickly
• Has built systems where doing something twice by mistake is a serious bug
• Writes tests as part of the work, including load tests
• Has supported their own services in production and led the investigation after an incident
• Explains and defends a design clearly, in writing and in review

Deep experience in at least two of these areas:

• High throughput distributed applications: services that process thousands of requests per second across many instances, with the consistency, ordering and failure handling that comes with it
• Advanced PostgreSQL: query planning, indexing, locking and transaction isolation, partitioning, replication and tuning under heavy write load
• Advanced Kafka: topic and partition design, consumer groups, delivery guarantees, replays, dead letter handling, and running clusters under load
• Caching in distributed applications: choosing what to cache, keeping caches consistent with the source, invalidation, and what happens when a cache is cold or stale

Nice to have:

• Payments, banking or accounting background
• Kubernetes and Docker
• Monitoring, tracing and profiling tools
• Performance engineering as a named part of a previous role
• Spanish