Senior Software Engineer Dev Accelerator

About the team

The Dev Accelerator team builds and operates our internal developer platform: the tools libraries and infrastructure that let 100 engineers design build test and ship products quickly and safely.

We own:

• Developer CLI tooling a Prompt-to-Product style CLI that scaffolds services end-to-end environment/credentials tooling and a wide range of internal developer scripts.
• Monorepo build lint and CI infrastructure including our core backend CI workflow Bazel integration and a custom linting framework and rule set used across the codebase.
• Go ecosystem stewardship for a large suite of shared libraries and applications under our main Go module.
• Python shared libraries & frameworks for core business logic gRPC helpers utilities and standardized component libraries (datastores messaging web etc.).
• Engineering effectiveness & test infrastructure including automated canary analysis test data and coverage tooling bad test dashboards dependency analysis and broken main automation.

Our goal is to make the easy path the right path for product teams and AI agents building on the platform.

About the role

As a Senior Software Engineer Dev Accelerator you will:

• Design and evolve the internal developer platform that underpins virtually all backend development.
• Own high-leverage projects across CLI tooling CI/CD shared libraries and test infrastructure.
• Work across Python Go Bazel Kubernetes AWS and CI systems to make our Golden Path fast reliable and intuitive.
• Shape abstractions and workflows that are AI-native consumable by both humans and AI agents.

Youll operate as a senior IC leading multi-quarter initiatives and collaborating with product teams infrastructure SRE and Security.

What youll do

• Build and evolve developer CLI tooling
• Extend our primary developer CLI to scaffold new component types and services end-to-end (service manifests container/build configs deployment charts build files API definitions starter code alerts runbooks).
• Improve environment and credentials tooling to make local development setup fast and reliable.
• Own core CI/CD and linting infrastructure
• Design and maintain the backend CI workflow used by backend services.
• Evolve linting formatting and typing tools to enforce architectural and code-quality guardrails across the monorepo.
• Debug and fix CI issues that block engineers and proactively reduce flakiness and runtime.
• Steward shared Go and Python ecosystems
• Own key shared Go libraries (auth caching clients configuration cryptography logging metrics domain/realm server etc.) and their usage across many applications.
• Maintain and evolve Python shared libraries and frameworks in our core libraries gRPC helpers utilities and standardized components.
• Strengthen test and release safety
• Extend automated canary analysis with new metric types backtesting and safer defaults.
• Build and improve test automation tooling bad-test detection dashboards and dependency-analysis utilities to keep main green and tests reliable.
• Contribute to automation that classifies CI failures and summarizes them for engineers (including LLM-assisted workflows).
• Drive platform-level design and abstractions
• Design abstractions that balance simplicity for product engineers with enough power for advanced use cases.
• Collaborate with PM/TPM infrastructure and product teams to scope and deliver multi-team initiatives (e.g. prompt-to-product workflows typing and linting initiatives test automation).

Required technical skills

Languages & frameworks

• Strong experience with Python 3.x:
• CLI development (e.g. Click or similar).
• YAML/Jinja2-style templating.
• Modern type hints and typing discipline (e.g. typing dataclasses / attrs Pydantic-style patterns).
• Testing with pytest or similar.
• Solid experience with Go:
• Shared library and service development (gRPC/HTTP).
• CLI patterns (e.g. Cobra/Viper or equivalents).
• Testing with Go testing frameworks (e.g. Ginkgo/Gomega or the standard library).

Protocols & APIs

• Protobuf/gRPC:
• Schema design and evolution.
• Cross-language client/server generation and integration.

Build systems & infrastructure

• Bazel in a large monorepo:
• BUILD rules and dependency management.
• Working with code generation for APIs and clients.
• Containers & orchestration:
• Docker image builds.
• Kubernetes concepts (Helm-style values service deployments readiness/liveness/health checks).
• Cloud infrastructure (AWS preferred):
• Experience with a meaningful subset of: object storage relational databases (e.g. Postgres) keyvalue/document stores search streaming/ingest services Kafka Redis IAM.

CI/CD & DevOps

• Modern CI systems (e.g. Git-based CI/CD platforms):
• Authoring non-trivial pipelines (matrix builds reusable workflows secrets/permissions).
• Infrastructure-as-Code mindset:
• Comfortable working with service manifests (YAML) Terraform/Terragrunt-like patterns or internal equivalents.
• Linting & static analysis:
• Hands-on experience configuring and tuning linting and typing tools (e.g. pylint ruff mypy golangci-lint).
• Experience writing or extending custom lint rules is a strong plus.

Strongly preferred

• Monorepo experience
• Worked in a large shared codebase with complex dependency graphs and shared frameworks.
• Familiar with dependency graph analysis and strategies to keep builds/tests fast.
• Developer experience (DX) tooling
• Built or maintained CLI tools scaffolding systems or internal frameworks used by other engineers.
• Thoughtful about ergonomics documentation and guardrails.
• Testing & progressive delivery
• Exposure to canary analysis / progressive rollout systems (e.g. Prometheus/PromQL Grafana automated deployment checks).
• Experience with test data management integration/E2E test infrastructure or bad-test detection.
• Messaging & streaming
• Experience with Kafka (topic design producers/consumers observability error handling).
• LLM/AI integration
• Experience or strong interest in using LLMs to improve developer workflows (e.g. failure summarization smart code generation AI-native CLIs).

How you work

Were looking for someone who:

• Designs scalable developer abstractions
• Has built tools that many engineers depend on and can point to where those abstractions worked (or didnt) and why.
• Operates across the full platform stack
• Comfortable jumping between Python CLIs Go libraries Bazel rules YAML manifests CI workflows and Kubernetes deployments.
• Reduces complexity for others
• Measures success by how much simpler and safer life becomes for product engineers and AI agents using the platform.
• Thinks in terms of leverage
• Prefers building guardrails automation and self-service over manual ops work.
• Writes clear documentation
• Treats usage and developer documentation as part of the product surface not an afterthought.
• Collaborates across teams
• Communicates clearly with product teams infra SRE and security; comfortable gathering feedback via Slack ticketing systems and design docs and iterating quickly.

If youre excited about building the tools and infrastructure that hundreds of engineers (and AI agents) will use every day wed love to talk.

#LI-AJ1

Required Experience:

Senior IC