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:
You should apply if you:
Have several years of meaningful experience building distributed, service-oriented systems
Have strong experience with JavaScript/TypeScript and Python
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.
