Software Engineer, Control Plane

Conduit

3d•Hybrid

About The Position

Conduit's Control Plane team owns the coordination layer of the Conduit Platform: the services that provision, update, and retire everything customers run on us — rollups, RPC nodes, indexing, and whatever comes next — meter what those products consume, and give both customers and our own team a trustworthy picture of what is actually running. The core of it is a control loop. We're building a lifecycle service that observes what's actually running and reconciles toward the desired state, rather than writing a status field and hoping it stays true. It treats each product as opaque: its shape and configuration come from schema read at runtime, so onboarding a new product type is a description, not a pull request. If you've worked on Kubernetes controllers, provisioning APIs, deployment systems, or any platform where the hard part is keeping many systems consistent with one another, this will feel familiar. It's a web2 stack in service of web3 technology — we don't require blockchain experience, and people on the team picked up the domain here. Three things worth knowing up front: A small, senior team with a large charter. Control Plane is small and entirely senior — this layer is critical enough that everyone on it operates independently. The surface area — lifecycle, usage reporting, the customer-facing API, internal tooling — is wider than the team can build at once, which is why we spent this year defining what it owns and what it doesn't. The upside is unusual influence: your design decisions become the architecture rather than one input among many. The mission is automation. Plenty of platform operations still have a human in the loop. Turning those into automated, self-serve paths is the work — and because the first users of what you build are inside the company, the feedback loop is measured in hours, not quarters. A lot of this work is decoupling before extending. These systems grew organically and carry real coupling. We'd rather pay that down than keep building on top of it. The team optimizes for correctness and reliability first. Performance matters, but this isn't a role about making one component marginally faster — it's about making sure a change in one system doesn't quietly break three others. Nearly everything here is an integration problem, so breadth of systems judgment counts for more than depth in any one specialty.

Requirements

5+ years building and operating production backend systems
Systems breadth: you reason across several interacting systems at once — how they fail, where the seams belong, how they stay consistent
Experience designing APIs and contracts that other teams depend on — versioning, backward compatibility, deprecation
Comfort with asynchronous and event-driven systems: idempotency, retries, partial failure, eventual consistency
Experience debugging complex issues across the stack — networking, performance, data integrity — and good instincts for where security boundaries belong
Self-directed: comfortable with ambiguity, able to take a loosely-defined problem and drive it to done
Able to become productive in an unfamiliar language quickly — our services are Go today

Nice To Haves

Production Go experience
Built reconciliation- or controller-pattern systems (Kubernetes operators, Terraform providers, provisioning or deployment control planes)
Worked with schema- or config-as-data systems (CUE, JSON Schema, protobuf) and the realities of schema evolution and migration
Metering, usage reporting, or other systems where correctness has financial consequences
Built internal tools for expert operators
Crypto / web3 background — genuinely not required

Responsibilities

Own the interfaces other teams build against — lifecycle operations, usage reporting, schema contracts — including how they version and migrate as they evolve
Integrate systems that don't fit together on their own, including third-party billing and partner integrations
Drive cross-functional coordination when the control plane is the shared point of integration
Improve the tooling and process that keep the platform maintainable and reliable
Participate in the team's oncall rotation, covering the control plane services you own rather than the customer data path