Kooltra

Location: Remote | Full-Time Department: Engineering

About Kooltra

Kooltra is a Canadian fintech company building FX infrastructure and cross-border payment technology for banks and financial institutions. With over a decade in market, we're accelerating our US expansion and shifting toward an AI-first development and delivery model.

AI has changed the economics of writing code. The bottleneck is no longer how fast we can build — it's how confidently we can ship. As AI accelerates the volume and velocity of change across our platform, the systems that verify correctness, catch regressions, and keep production observable become the highest-leverage engineering investment we can make. We're hiring an architect-level platform engineer to own that layer end to end.

The Role

You will design, build, and operate the quality gate system that lets Kooltra ship AI-accelerated code with confidence — in a domain where correctness is non-negotiable. Financial infrastructure doesn't get to "move fast and break things." Your job is to make moving fast and not breaking things a structural property of how we deliver software, rather than a matter of individual discipline.

This is a systems-building role, not a QA role. You won't be writing test cases for other people's features — you'll be architecting the automated, layered verification pipeline that every change flows through, from the first property test to production observability.

Key Responsibilities

• Architect a layered quality gate system spanning the full delivery lifecycle: property-based testing, unit and integration testing, contract testing, UI and end-to-end testing, CI/CD pipeline gates, and production observability
• Champion test-driven development as a design discipline across the engineering organization — and evolve what TDD means when AI agents are writing a growing share of the code
• Establish property-based testing as a first-class practice for our financial domain logic, where invariants (balances reconcile, events replay deterministically, money is never created or destroyed) matter more than example-based cases
• Design and own CI/CD pipelines that act as structured, automated gates — every merge and deploy earns its way to production through verification, not review-by-heroics
• Build the UI and end-to-end test infrastructure that keeps critical user journeys verified continuously, with the reliability and speed engineers actually trust
• Define the observability architecture — metrics, traces, structured logs, SLOs, and alerting — that closes the loop from "it passed the pipeline" to "it's behaving correctly in production"
• Make quality gates AI-native: verification systems that validate AI-generated code at the volume and velocity AI development produces, and that AI agents themselves can invoke, interpret, and respond to
• Set the standards, golden paths, and tooling that make the well-tested path the easiest path for every engineer and every AI agent on the platform
• Instrument and report on delivery health — escaped defects, flake rates, lead time, change failure rate, time to recovery — and drive them in the right direction
• Partner with platform, product, and compliance teams to ensure the verification layer supports auditability and our regulatory obligations

Required Qualifications

• Deep experience designing test architecture and delivery systems in enterprise or B2B SaaS environments — you've built quality systems, not just used them
• Hands-on expertise with property-based testing (e.g., jqwik, Kotest property testing, fast-check, Hypothesis) and a clear view of where it beats example-based testing
• A genuine test-driven development practice and the ability to teach, model, and scale it as a design discipline
• Proven experience building and operating UI / end-to-end test infrastructure (e.g., Playwright, Cypress) that stays fast and non-flaky at scale
• Strong CI/CD architecture experience — designing pipelines as products, with staged gates, ephemeral environments, and deployment strategies like canary or progressive rollout
• Production observability expertise: metrics, distributed tracing, structured logging, SLOs, and alerting (e.g., Prometheus, Grafana, OpenTelemetry, Datadog)
• Proficiency in Kotlin and TypeScript, or deep experience on the JVM with the ability to ramp quickly
• Experience with event-driven architectures (Kafka) and how to test them — contract testing, replay testing, verifying eventual consistency
• Hands-on Kubernetes (EKS) and AWS experience
• Genuine enthusiasm for AI-assisted development — and a clear-eyed view of why it makes rigorous automated verification more important, not less
• Excellent communication skills — this role changes how the whole engineering team works, and that requires influence, not just architecture

Nice-to-Have Qualifications

• Fintech, payments, FX, or treasury operations background — you understand why a rounding error is an incident
• Experience building verification systems for AI-generated code, or evaluation harnesses for LLM-based systems
• Mutation testing experience and opinions on measuring test suite effectiveness beyond coverage
• Formal methods exposure (TLA+, model checking) or design-by-contract experience
• SOC 2 or similar compliance framework familiarity — evidence automation, change management controls
• Track record building internal developer platforms, tooling, or golden paths
• Open-source contributions to testing, CI/CD, or observability tooling

Why This Role Matters

Every company adopting AI development is about to learn the same lesson: generation is cheap, verification is everything. The quality gate layer is what converts AI acceleration from risk into advantage — and at Kooltra, it protects systems that move real money for real financial institutions.

If you believe a great test suite is an act of empathy for every engineer who ships after you, that pipelines should be architected like products, and that AI-first delivery is only as strong as the gates it passes through — we'd love to talk.

Senior / Staff Level 

Location: Remote | Full-Time 

About Kooltra 

Kooltra is a Canadian fintech company building FX infrastructure and cross-border payment technology for banks and financial institutions. With over a decade in market and a growing footprint in North America, we are now accelerating our US expansion and undertaking a fundamental shift toward an AI-first development and delivery model. 

To fuel that shift, we need Platform Engineers to invest in our platform and transform how we implement customers. 

About the Role 

We’re looking for a Platform Engineer who lives and breathes clean architecture and believes that a well-designed domain model is the foundation of everything great in software. You’ll own and evolve our core platform layer—the expressive, domain-driven backbone that powers our suite of financial products and enables third-party applications, services, and UIs to build on top of it with confidence. 

This is a high-leverage role. The platform you shape will be the surface that internal teams, external integrators, and next-generation AI agents interact with. You’ll design APIs and event contracts that are intuitive enough for a developer to pick up in minutes and robust enough to handle complex financial workflows at scale. 

Developer experience is at the heart of this role. You believe that a platform is only as good as how it feels to build on, and you’re obsessed with making the developer journey—from onboarding to production—effortless and delightful. You’ll craft expressive APIs, self-documenting domain models, and tooling that lets internal teams and third-party developers move fast with confidence. 

You’re excited about AI—not as a buzzword, but as a force multiplier. You see the convergence of great developer experience and AI as the next frontier: a platform where AI agents can discover capabilities, reason about domain events, and execute complex financial workflows through the same intuitive surface that human developers use. You want to build an AI-first developer experience—one where the platform is as legible to an autonomous agent as it is to a senior engineer reading the docs for the first time. 

What You’ll Do 

• Iterate and extend an expressive, domain-driven platform layer that serves as the integration surface for internal products, third-party applications, and AI-powered services. 

• Own the end-to-end developer experience on the platform—from SDK design and API ergonomics to documentation, error messages, and onboarding flows—ensuring every touchpoint is intuitive and productive. 

• Pioneer an AI-first developer experience where platform capabilities are discoverable, composable, and structured for consumption by both human developers and AI agents. 

• Define and enforce clean bounded contexts, aggregates, and domain events that model complex financial operations with precision and clarity. 

• Architect event-driven systems using Kafka to enable loose coupling, auditability, and real-time reactivity across the platform. 

• Build and maintain microservices in Kotlin, ensuring each service has a clear domain responsibility and well-defined contracts. 

• Champion test-driven development as a design discipline—not just a quality gate—driving clean, modular, and refactorable code. 

• Design platform APIs, SDKs, and event schemas with a relentless focus on developer experience—self-describing, well-typed, and structured so that AI coding assistants and autonomous agents can reason about and invoke them naturally. 

• Build developer tooling, templates, and golden paths that reduce friction and accelerate time-to-first-integration for both human developers and AI-driven workflows. 

• Operate and optimize services on Kubernetes (EKS) and AWS, making pragmatic infrastructure decisions that balance developer experience with operational reliability. 

• Model and manage data in MongoDB with thoughtful schema design that aligns with domain boundaries and supports evolving query patterns. 

• Collaborate closely with product, compliance, and integration teams to translate complex financial and regulatory requirements into elegant platform abstractions. 

• Continuously evaluate and integrate AI-assisted development tools and patterns into the team’s workflows, raising the bar for what’s possible. 

What You Bring 

• Deep experience building platform layers or shared service foundations in an enterprise or B2B SaaS environment, with a track record of enabling third-party integrations and external developer experiences. 

• Strong command of Domain-Driven Design in practice—bounded contexts, aggregates, domain events, anti-corruption layers—not just theory. 

• Proven ability to design and operate event-driven architectures with Kafka, including schema evolution, exactly-once semantics, and event sourcing patterns. 

• Proficiency in Kotlin and TypeScript, with an emphasis on clean, well-tested, and maintainable code. 

• Hands-on experience with Kubernetes (preferably EKS), containerized microservices, and AWS cloud infrastructure. 

• Solid MongoDB experience including schema design, indexing strategies, and performance optimization aligned with domain models. 

• A test-driven development mindset where tests shape design, not just verify behavior. 

• Strong opinions on clean code and architecture, held loosely and communicated clearly—you make the codebase better every time you touch it. 

• A passion for developer experience as a discipline—you’ve designed APIs, SDKs, or platform tooling with the consumer’s experience as the primary design constraint, and you measure success by how quickly someone can go from zero to productive. 

• Genuine enthusiasm for AI and its potential to transform how platforms are built and consumed. You follow developments in AI agents, function calling, MCP, and autonomous systems and think about how platform design enables or constrains them. You’re energized by the idea of building a platform that AI can use as fluently as a human developer. 

• Excellent communication skills and the ability to articulate complex architectural decisions to both technical and non-technical stakeholders. 

Nice to Have 

• Background in fintech, payments, FX, treasury operations, or regulated financial services. 

• Experience designing APIs or event contracts consumed by AI agents or LLM-based systems, including function calling schemas, tool-use patterns, or MCP server implementations. 

• Track record of building internal developer platforms, developer portals, or self-service tooling that measurably improved developer velocity. 

• Familiarity with compliance frameworks (SOC 2) and how they influence platform design. 

• Contributions to open-source projects or developer tooling. 

• Experience building multi-tenant platforms that serve diverse institutional clients. 

Why This Role Matters 

The platform layer is the highest-leverage code in the company. It’s what makes every product team faster, every integration cleaner, and every AI capability possible. You won’t be building features in isolation—you’ll be shaping the foundation that everything else is built on, and defining what it feels like to build on that foundation. If you believe that great developer experience is an act of empathy, that the best platforms are the ones that disappear into simplicity, and that AI-first design is the future of how platforms are consumed—we’d love to talk.