Senior Platform Engineer

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 re