What is Cobre, and what do we do?
Cobre is Latin America’s leading instant b2b payments platform. We solve the region’s most complex money movement challenges by building advanced financial infrastructure that enables companies to move money faster, safer, and more efficiently.
We enable instant business payments—local or international, direct or via API—all from a single platform.
Built for fintechs, PSPs, banks, and finance teams that demand speed, control, and efficiency. From real-time payments to automated treasury, we turn complex financial processes into simple experiences.
Cobre is the first platform in Colombia to enable companies to pay both banked and unbanked beneficiaries within the same payment cycle and through a single interface.
We are building the enterprise payments infrastructure of Latin America!
The team you'd lead:
Risk Products builds the systems that decide who Cobre can do business with and which money movements are allowed to happen: client onboarding and KYB, document collection and verification, sanctions and counterparty screening, real-time transaction decisioning, and the backoffice where compliance analysts do their work.
Two things make this team different from a typical backend team:
We run the Builder Model. Engineers here own product, design and code end-to-end. You will talk to compliance analysts, read the regulation, write the spec, decide what the screen looks like, build the service behind it, and own the metric that says whether it worked. There is no queue of tickets waiting for you to implement someone else's design.
We are AI-native in the product and in how we build it. LLMs do real work in production for us — extracting structured data from incorporation documents and IDs, pre-filling onboarding forms, summarizing evidence for analyst review. And we build with AI: a shared AI toolkit, company-wide MCP servers and custom agents and skills our engineers write for their own workflows.
What we are looking for:
An engineer who can take an AI-powered capability from "this might work" to "this runs in production, in a regulated flow, and we can prove it's correct."
What would you be doing:
- Own features end-to-end — from problem framing and product decisions through API design, implementation, rollout, and the metrics that prove the outcome.
- Start from the problem, not from the model — decide where AI genuinely belongs. A deterministic rule that is always right beats a model that is usually right, and in compliance flows that is often the correct trade. We expect you to argue for the boring solution when it is the better one, and to treat cost and latency per decision as product constraints rather than infrastructure footnotes.
- Design for the model being wrong — confidence thresholds, escalation paths, and human-in-the-loop workflows where the model proposes and an analyst disposes. What the product does with a bad output is a design decision, and it is yours to make.
- Define correctness before you ship — golden datasets and evaluation suites, a definition of a good result agreed field by field with the people who depend on it, precision and recall measured in production, and explicit thresholds separating full automation from human review. "It looked right when I tried it" is not a release criterion.
- Treat prompts, models and thresholds as engineering artifacts — versioned, reviewed, tested and observable, shipped through the same pipeline as code. Not config someone edits in production.
- Build the deterministic scaffolding around the nondeterministic part — event-driven pipelines, idempotency, retries and DLQs, typed domain models, and an audit trail that holds up to a regulator.
- Instrument before you build — decide the metric and the dashboard up front; correlation IDs that survive every async hop; alerts that mean something.
- Design for compliance constraints as first-class requirements — PII handling, data retention, traceability, fail-closed defaults.
- Work AI-natively, and own everything you merge — AI assistants, MCP servers and custom agents are part of the daily loop here, and the bar for code produced with them is exactly the bar for code you wrote by hand: understood, tested, and defensible in review. Then contribute the skills, guardrails and patterns that make everyone else faster.
- Mentor, and raise the bar around you — pair on the hard problems, review code with substance, help less experienced engineers grow into owning features end-to-end, and write down the decisions that will outlive the ticket. Mentoring is part of the role here, not something you do if there's time left over.
What do you need:
- 5+ years building and operating production backend services, with real ownership of what you shipped after it shipped.
- Depth in at least one back-end focused language, and the willingness to learn Go if you don't already know it. Our stack is Go-first, with some Node/TypeScript and Vue 3 in the mix.
- Production experience with LLM-backed features, not prototypes — structured output, tool use, retrieval, context engineering, evaluation, latency and cost management, and a clear-eyed view of failure modes and fallbacks.
- Distributed systems fundamentals — asynchronous and event-driven processing, at-least-once delivery, idempotency, eventual consistency, and what to do when a downstream provider is down.
- Cloud-native AWS development — Lambda, DynamoDB, S3, SQS/SNS — plus containers, IaC and CI/CD as normal parts of your work, not someone else's job.
- Architectural judgement — hexagonal architecture and DDD in practice: rich domain models, ports and adapters, and the discipline to keep third-party AI SDKs at the edge behind an anti-corruption layer so a model or vendor swap is a one-adapter change.
- Testing discipline — high coverage as a gate rather than an aspiration, table-driven and contract tests, and a real answer for how you test a component that isn't deterministic.
- Product instinct and directness — you can sit with a compliance analyst, understand why a control exists, and turn that into a spec and a shipped screen.
- A track record of mentoring — you have made other engineers measurably better through pairing, review and onboarding, and you treat that as part of the job.
- Professional fluency in Spanish — it is our working language, day to day and in design discussions. Working English for technical documentation and reading.
- Strong written and spoken communication, in both.
Nice to have:
- Payments, treasury, banking or fintech background — especially anything touching KYC/KYB, AML, sanctions screening or transaction monitoring.
- Experience with agentic systems: MCP, tool-calling agents, multi-step orchestration, and their evaluation.
- Comfort building the frontend for what you ship (we use Vue 3 and an internal design system).
- Kafka, schema registries and contract evolution in production.
Why this role is worth your time
You will own AI capabilities that are load-bearing for how fast Cobre can activate a client and how safely it can move money — in a company where engineers are trusted to decide what to build, not just how to build it.
If you're looking for an exciting next step, and this sounds like something that would both challenge and excite you, then this is for you!