About Bitdeer:

Bitdeer is a world-leading technology company for Bitcoin mining and AI cloud.

Bitdeer is committed to providing comprehensive Bitcoin mining solutions for its customers. Apart from designing industry-leading ASIC chips and manufacturing mining rigs, the Group handles complex processes involved in computing across the value chain. This includes equipment procurement, transport logistics, datacenter design and construction, equipment management, and network and facility operations. Bitdeer also offers advanced cloud capabilities to customers with a high demand for artificial intelligence.

Headquartered in Singapore, Bitdeer operates globally with a diversified 3 GW energy portfolio, and deploys Bitcoin mining and HPC datacenters in the United States, Bhutan, Norway, Canada, Malaysia, and Ethiopia.

About the role

We are seeking a Developer Experience Engineer to build and own the Terraform provider, CLI, and SDKs that let customers provision and manage GPU clusters and Kubernetes workloads as code on our platform. Today, infrastructure-as-code support for the AI Cloud Kubernetes platform is carried informally by the control-plane team as a byproduct of shipping the core provisioning API; this role exists to turn that byproduct into a first-class, versioned product surface with its own release cadence, compatibility guarantees, and quality bar. The control-plane API is still evolving — resource shapes, async operation semantics, and error contracts are not yet frozen — so the immediate mandate is to build against a moving target: track schema changes, absorb breaking changes into provider and SDK versioning rather than passing them to customers, and push back on the control-plane team when a proposed API shape would make the provider or CLI hard to model correctly. Once the API is stable enough to freeze, this role takes full, permanent ownership of the Terraform provider, CLI, and SDK lines — acceptance tests, state and drift handling, generated and hand-written client layers, docs-as-code, and the registry release pipeline — and becomes the team's authority on what infrastructure as code means for a multi-tenant GPU cloud.

What you will be responsible for:

• Terraform Provider Architecture and Lifecycle: Design and implement the Terraform provider covering GPU cluster, node pool, network, and storage resources on top of the control-plane API, modeling create/read/update/delete and long-running async operations correctly under the Terraform plugin framework. Own state schema evolution, drift detection, and safe resource import so customer state files never desync from actual infrastructure. Build and maintain the acceptance test suite that runs against a live control-plane environment on every provider change.
• CLI Design and Workflows: Build the command-line tool customers use to authenticate, provision clusters, and script day-to-day operations, treating command ergonomics, output formats, and error messages as product surface rather than afterthought. Design credential and session handling that works across interactive and CI/automation use cases without weakening tenant isolation. Keep the CLI's resource model and the Terraform provider's resource model consistent so customers can move between the two without surprises.
• SDK Generation and Client Libraries: Stand up the SDK layer — generated clients off the control-plane's API definitions plus a hand-written idiomatic layer on top — for the languages customers actually build automation in. Own the generation pipeline so new API fields and endpoints reach SDKs automatically, and reserve hand-written code for pagination, retries, auth, and error typing that generation can't express well. Version and changelog each SDK release against the same compatibility contract as the provider and CLI.
• API Contract Partnership Through Freeze: Work directly with the control-plane team while the provisioning API is still unstable, reviewing proposed resource shapes, field semantics, and error contracts for how well they map onto Terraform's plan/apply model and SDK ergonomics before they ship. Flag API designs that would force leaky abstractions or unrepresentable states in the provider, and negotiate changes while the cost of changing is still low. Define the criteria and process for declaring the API frozen enough to hand full IaC ownership to this role.
• Versioning, Compatibility, and Release Engineering: Run semantic versioning and deprecation policy for the provider, CLI, and SDKs as a published contract, so a control-plane API change never silently breaks a customer's existing Terraform state or automation scripts. Own the release pipeline into the Terraform Registry (or private equivalent) and language package registries, including compatibility matrices against supported control-plane API versions. Treat any customer-visible breaking change without a migration path as a release blocker.
• Documentation as Code and Adoption: Build documentation, examples, and quickstarts as code — generated from provider schema and SDK definitions where possible — so docs cannot silently drift from behavior. Maintain a reference set of Terraform modules and CLI/SDK examples for common GPU cluster patterns that double as smoke tests. Gather adoption and failure telemetry from CLI and SDK usage to prioritize which resources and workflows need attention next.

How you will stand out:

• Bring 5+ years of backend or platform engineering experience, including hands-on work building or maintaining a Terraform provider (or comparable IaC plugin, e.g., Pulumi or Crossplane) against a real cloud or Kubernetes control plane. You should be comfortable owning a developer-facing surface end to end, from design through release and support.
• Demonstrate solid Go proficiency and direct experience with the Terraform Plugin Framework/SDK, including resource schema design, state management, drift detection, and acceptance testing patterns. Experience generating or hand-maintaining client SDKs from OpenAPI, protobuf, or similar API definitions is expected.
• Show a track record of building CLIs or SDKs as products — designing for scripting and automation use cases, handling auth and credentials safely, and managing versioning and deprecation without breaking existing customer integrations. Experience negotiating API contracts with an upstream backend team, rather than just consuming a finished API, is a strong plus.
• Have working knowledge of Kubernetes and cloud infrastructure primitives — clusters, node pools, networking, storage — well enough to model them correctly as declarative resources. Familiarity with GPU cloud or ML infrastructure concepts is a plus, not a requirement.
• Be comfortable operating against an unstable, evolving upstream API — absorbing schema churn into versioned releases rather than exposing it to customers — and communicating clearly with a platform team about which API changes are costly downstream.

What you will experience working with us:

• A culture that values authenticity and diversity of thoughts and backgrounds;
• An inclusive and respectable environment with open workspaces and exciting start-up spirit;
• Fast-growing company with the chance to network with industrial pioneers and enthusiasts;
• Ability to contribute directly and make an impact on the future of the digital asset industry;
• Involvement in new projects, developing processes/systems;
• Personal accountability, autonomy, fast growth, and learning opportunities;
• Attractive welfare benefits and developmental opportunities such as training and mentoring.

--------------------------------------------------------------------

Bitdeer is committed to providing equal employment opportunities in accordance with country, state, and local laws. Bitdeer does not discriminate against employees or applicants based on conditions such as race, colour, gender identity and/or expression, sexual orientation, marital and/or parental status, religion, political opinion, nationality, ethnic background or social origin, social status, disability, age, indigenous status, and union.

#LI-ST1