Director – Developer Platform & Experience

About the role

Motive is moving to an AI-driven development lifecycle. Agents that plan, generate, test, review, and help operate our systems — with engineers directing the work rather than typing all of it — are where software engineering at Motive is going. That direction is set. What we need now is a leader to build it.

We are hiring a Director of Developer Platform & Experience to own that execution and the platform underneath it. This role owns Motive's internal developer ecosystem end to end: developer experience, developer infrastructure, build and CI/CD systems, and the testing frameworks that let hundreds of engineers move quickly without breaking things. It also owns AI-DLC in practice — the tooling, cloud agent infrastructure, evaluation practice, and governance that determine whether agentic development actually makes us faster or just makes us noisier.

Our engineering organization spans North America, Europe, and Asia, across a Rails monolith, Go services, mobile, and embedded systems. How fast and how confidently that organization ships is one of our most important business levers.

This is a builder's leadership role, not a strategy role. You will inherit real systems and real teams, and be measured on whether engineers at Motive ship faster, with higher confidence, and with less friction than they did the quarter before.

The mandates

1. AI-driven development — make agentic development a governed, measured, everyday part of how Motive builds software.
2. Cloud-based agentic development infrastructure — build the substrate that lets agents run in the cloud, in parallel, safely.
3. Developer experience — make the inner loop fast and the right path the easy path.
4. Developer infrastructure — make build, CI/CD, and release systems fast, reliable, and cost-aware at scale.

The defining challenge: agentic development in the cloud

Most AI coding adoption stops at the laptop — one engineer, one agent, one local checkout. That ceiling is low, and moving past it is the signature technical challenge of this role.

You will build the infrastructure that runs agentic development in the cloud: ephemeral, reproducible, isolated environments where many agents work concurrently on real Motive codebases, run real tests against real dependencies, and open real pull requests — without an engineer babysitting a terminal, and without compromising security or blowing up spend.

This is a hard distributed-systems and platform problem, not a tooling procurement exercise. Done right, engineers stop being throughput-bound by their own machines and start operating as reviewers and directors of parallel work. We want a leader who finds that problem exciting and has the platform depth to solve it.

What you'll own

AI-driven development lifecycle (AI-DLC)

• Translate Motive's AI-driven development direction into an executable multi-year plan — how agents plan, generate, test, review, and operate under human direction, what "human in the loop" means at each stage, and where engineers spend their time as a result.
• Evaluate, select, and roll out AI developer tools (coding agents, code review, test generation, incident investigation, documentation) and build the internal scaffolding — context, MCP servers, evals, guardrails — that makes them effective on Motive's actual codebases rather than on a demo repo.
• Stand up a rigorous LLM and agent evaluation practice: benchmarks, offline and online evals, quality and cost regression tracking, and a defensible model and vendor selection process that survives a fast-moving landscape.
• Own the governance layer with Security, Legal, and Platform: acceptable use, code provenance and licensing, secrets and data handling, and audit trails for AI-generated changes.
• Define and report the adoption and impact metrics that tell us whether this is actually working — not just seat counts and enthusiasm.
• Bring the organization along. Drive enablement, internal advocacy, and the cultural shift from "write code, then review" to continuous review of agent-generated work.

Cloud-based agentic development infrastructure

• Build and own the platform that runs agentic development in the cloud: on-demand, reproducible, isolated workspaces provisioned per task, with the right source, dependencies, secrets, and services already in place.
• Design for concurrency and safety — sandboxed execution, least-privilege credentials, network egress controls, and blast-radius limits so many agents can run against real codebases without becoming a security or reliability incident.
• Make agent runs fast and cheap: warm environment pools, caching and snapshotting, incremental builds, and test selection so a cloud agent loop is measured in minutes, not tens of minutes.
• Own the orchestration and control plane — queueing, scheduling, autoscaling on Kubernetes, session lifecycle, artifact and log retention, and observability into what agents did and why.
• Own unit economics. Instrument per-task and per-agent cost, set budgets and quotas, and keep the platform financially sustainable as usage scales across the org.
• Build the human interface layer: how engineers dispatch work to cloud agents, monitor fleets of concurrent runs, review and merge results, and intervene when a run goes sideways.
• Design for multi-region (US and EU) from the start, with configuration-driven rather than hardcoded regional behavior, and honor data residency and code-egress constraints.

Developer experience

• Own the inner loop end to end: local and cloud development environments, code search and navigation, IDE and agent tooling, dependency management, and onboarding time-to-first-PR.
• Treat developers as your customers. Run regular DevEx research — surveys, interviews, instrumented telemetry — and publish a prioritized backlog the whole engineering org can see.
• Define and drive the internal developer platform: golden paths, service scaffolding, and self-service capabilities that make the right way the easy way.

Developer infrastructure and engineering velocity

• Own build systems, CI/CD, artifact and release pipelines, and the platform's outer loop across a Rails monolith, Go services, mobile, and embedded/firmware codebases.
• Drive step-function improvements in DORA and velocity metrics: PR lead time, build and CI duration, CI reliability and flake rate, change failure rate, and time to restore.
• Make cost, scale, and reliability of the developer platform a first-class concern — including multi-region (US and EU) behavior and configuration flexibility rather than hardcoded assumptions.

Testing and quality engineering

• Own the testing strategy and frameworks: unit, integration, contract, end-to-end, hardware-in-the-loop, and performance. Drive test reliability, isolation, and speed so engineers trust the signal.
• Build the infrastructure that makes high-quality testing cheap: fixtures, factories, test data management, environment provisioning, parallelization, and flake detection and quarantine.
• Partner with quality and release engineering to shift quality left without slowing teams down.

Leadership

• Lead a multi-team organization as a manager of managers, hiring and developing engineering managers and senior/staff-plus ICs.
• Run an org distributed across North American and Asian time zones with genuine care for handoffs, overlap hours, on-call fairness, and inclusion — not just calendar math.
• Operate as a peer to product and infrastructure leaders, influence a large engineering org without direct authority, and communicate strategy and results credibly to executives.

What we're looking for

Required

• 12+ years in software engineering with 6+ years leading engineering teams, including 2+ years as a manager of managers (Director, Senior Manager of Managers, or equivalent scope).
• A real developer background — you have shipped and operated production systems, and engineers respect your technical judgment.
• Deep DevOps and infrastructure depth: CI/CD, build systems, containers and Kubernetes, infrastructure as code (Terraform), cloud platforms (AWS preferred), and observability.
• Demonstrated ownership of developer productivity, developer platform, or developer infrastructure at meaningful scale (hundreds of engineers or a large multi-language codebase), with measurable velocity outcomes you can describe.
• Hands-on experience with modern AI developer tooling and a clear, opinionated point of view on where agentic development genuinely helps and where it does not.
• Experience building or operating cloud-based development or execution environments — remote dev environments, ephemeral CI/build workers, container sandboxing, or multi-tenant compute platforms — including the security and cost controls that make them viable at scale.
• Practical understanding of LLM evaluation — how to benchmark models and agents for coding tasks, how to measure quality and cost, and how to avoid being sold a demo.
• Strong empathy for developers: you instrument the pain, listen to it, and prioritize accordingly rather than shipping platforms nobody adopts.
• Experience leading distributed teams across multiple time zones.

Preferred

• Experience with a large monolith undergoing modernization, and with polyglot environments (Ruby on Rails, Go, mobile, embedded).
• Background in test infrastructure at scale — flake reduction, test selection, parallelization, hermetic environments.
• Experience running platform work as a product: roadmaps, adoption funnels, internal customers, feature-flagged rollouts.
• Familiarity with multi-region deployment and data residency constraints (US/EU).
• Open source contribution, developer community involvement, or public writing on developer productivity or AI-assisted engineering.