Senior Platform Engineer

Ctrl; Toronto; On-site; CAD 120,000 - 180,000; Full time

Job summary

Ctrl is seeking a Platform Engineer to design, build, and operate the systems powering our products. This role sits at the crossroads of platform engineering, distributed systems, and product development, requiring the ability to build reliable cloud infrastructure and backend systems while moving up the stack when necessary.

You’ll work on systems coordinating asynchronous workloads, processing large datasets, and building the foundation for customer-facing applications, with a focus on

Qualifications

• Experience building distributed, service-oriented systems.
• Production experience with Kubernetes and containerized apps.
• Comfort with defining and managing cloud infrastructure with Terraform.
• Understanding of event-driven architectures and asynchronous processing.
• Think in terms of failure modes, retries, idempotency, and observability.
• Ability to design APIs and service boundaries.
• Ownership mindset from design to production operations.

Responsibilities

• Design, build, maintain, and operate the infrastructure and services behind Ctrl’s platform.
• Coordinate asynchronous and long-running workloads; build event-driven processing.
• Develop backend services and APIs with Python and TypeScript; use Terraform and Kubernetes.

Skills

Distributed systems

Kubernetes

Terraform

Python

TypeScript

Observability

API design

Tools

AWS

Temporal

PostgreSQL

Prometheus

Grafana

Job description

Your Role as a Platform Engineer at Ctrl

Ctrl is looking for a Platform Engineer to help design, build, and operate the systems that power our products.

This role sits at the intersection of platform engineering, distributed systems, and product development. We need someone who can build reliable cloud infrastructure and backend systems while remaining comfortable moving up the stack when the product requires it.

You’ll work on systems that coordinate asynchronous workloads, process large datasets, integrate with external services and hardware, and provide the foundation for customer-facing applications.

About Ctrl Engineering

Ctrl builds software that connects field operations, autonomous systems, data processing, and customer-facing applications.

Our platform has to coordinate work across devices, cloud infrastructure, distributed compute, and external services. Many of these processes are long-running, asynchronous, and failure-prone by nature. Building reliable systems around them requires thoughtful architecture, strong observability, and an understanding of how distributed systems behave outside the happy path.

We are a small engineering team, so we value engineers who can understand a problem end-to-end. You might spend one day designing an event-driven processing workflow, another improving our Kubernetes infrastructure, and another building an API or product feature that exposes those capabilities to customers.

What You’ll Be Working On

You’ll design, build, maintain, and operate the infrastructure and services behind Ctrl’s platform. This includes:

• Designing distributed systems that coordinate asynchronous and long-running workloads
• Building event-driven architectures for processing data and responding to changes across the platform
• Developing backend services and APIs using Python and TypeScript
• Building and maintaining cloud infrastructure using Terraform
• Operating containerized workloads on Kubernetes
• Improving the reliability, scalability, and observability of our production systems
• Designing resilient workflows with appropriate retries, idempotency, failure recovery, and state management
• Building integrations between cloud services, external systems, and product applications
• Developing tooling that makes it easier for engineers to deploy, operate, and debug their systems
• Contributing to customer-facing applications when product work crosses platform boundaries
• Helping establish engineering standards and technical direction as the platform evolves

What We’re Looking For:

• Have several years of meaningful experience building distributed, service-oriented systems
• Have production experience with Kubernetes and containerized applications
• Are comfortable defining and managing cloud infrastructure with Terraform
• Understand event-driven architectures, message queues, asynchronous processing, and distributed workflows
• Think carefully about failure modes, retries, idempotency, consistency, and observability
• Are comfortable designing APIs and service boundaries
• Can reason about architectural tradeoffs and communicate those decisions clearly
• Enjoy owning systems from initial design through deployment and production operations
• Are comfortable working across backend, infrastructure, and product-facing code
• Prefer solving underlying platform problems rather than repeatedly working around them
• Can operate effectively in a small team where engineers have significant ownership
• Experience with AWS, Temporal, PostgreSQL, Prometheus, Grafana, or similar technologies is valuable, but we care more about your ability to understand the underlying systems than experience with a particular vendor or framework.

What Engineering at Ctrl Looks Like

End-to-end ownership

Engineers own the systems they build. That means understanding the product problem, designing the architecture, implementing it, deploying it, and making sure it behaves correctly in production.

We want engineers to understand how their work fits into the broader system rather than treating infrastructure, backend services, and applications as isolated concerns.

Platform thinking

We invest in capabilities that make future development easier. When we encounter recurring operational or engineering problems, we look for opportunities to solve them at the platform level rather than adding another workaround.

The goal is to create reliable abstractions that allow the rest of the team to move faster without hiding how the underlying systems work.

Distributed systems in the real world

Many of our workflows cross process, service, infrastructure, and sometimes physical device boundaries. Networks fail. Processes restart. Messages arrive twice. External systems become unavailable. Workloads can take minutes or hours to complete.

We design around those realities rather than assuming the happy path.

Product-minded engineering

Platform engineering at Ctrl is not isolated infrastructure work. The systems we build ultimately exist to support products used by real people.

You should be comfortable following a capability from infrastructure through backend services and into the application. Sometimes the best way to solve a platform problem involves contributing directly to the product experience.

DevOps mindset

The engineers building our systems are also responsible for making them operable.

Infrastructure is defined as code, applications run in containers, and observability is treated as part of the system rather than something added after deployment. We continuously improve our deployment processes, monitoring, alerting, and developer tooling so that operating production systems become increasingly predictable.

Why This Role Matters

Ctrl’s platform is becoming increasingly distributed as we connect applications, cloud infrastructure, processing workloads, and autonomous systems.

The challenge is not simply getting these components to work individually. It is building a platform where they can reliably work together.

This role will have significant influence over that architecture. You’ll help establish the patterns and infrastructure that allow Ctrl to scale its products without scaling operational complexity at the same rate.

If you enjoy building reliable distributed systems, improving the foundations other engineers build upon, and occasionally jumping directly into the product to solve a problem end-to-end, we’d like to hear from you.