As Senior Manager, DevOps Engineer (Individual Contributor), you will be the build, release, and reliability backbone for our Python SDK—a pip-installable package that provides reusable, modular AI capabilities (RAG components, agent/tool cookiecutters, MCP adaptors, standardized interfaces). You will design automated pipelines that enforce code quality, security, reproducibility, benchmarking, and integration tests for the SDK and ensure compatibility and operability for platform services that consume it.

You’ll collaborate closely with:

• Embedded AI Architecture & Solution Design to prioritize capabilities and validate interfaces against real solution patterns.

• AI Engineering to align PI increments and integrate external technologies into the SDK.

• Digital Creation Centers & Forward Impact Teams (FITs) as consumers of the SDK in products/services, capturing feedback to refine release ergonomics.

• Evaluation & QA, Developer Experience, and LLMOps & AI Integration engineers to make quality and operability automatic.

Why this Role Matters

For a Python SDK to scale safely, we need rock‑solid packaging, dependency hygiene, and CI/CD: reproducible builds, secure artifacts, versioning discipline, and automated tests/benchmarks that guard against regressions. Your work turns modular capabilities into enterprise‑grade libraries that downstream services can rely on—ensuring consistent behavior, faster time‑to‑first‑success, and audit‑ready releases.

ROLE RESPONSIBILITIES

1) Python Packaging, Build & Distribution

• Own build and release for the SDK: wheel/sdist creation, and reproducible builds.

• Enforce semantic versioning, backward compatibility checks, and changelogs; design safe migration paths (deprecation policies, compatibility shims).

• Standardize artifact repositories: internal PyPI (Dev/Stage/Prod indices), package signing, and promotion workflows with automated quality gates.

2) CI/CD for Libraries & Supply Chain Security

• Design CI/CD pipelines (e.g., GitHub Actions/Azure DevOps/GitLab CI) to automate linting, type checking, unit/integration tests, coverage, and style enforcement (black/ruff/mypy/pytest).

• Integrate dependency auditing and vulnerability scanning, license compliance, and SBOM generation; implement artifact signing and provenance (SLSA‑like controls).

• Codify policy‑as‑code (e.g., OPA/Conftest) so releases only ship when tests, coverage, docs, and security gates pass.

3) Benchmarking, Performance & Integration Testing

• Collaborate with Evaluation & QA Engineers to build benchmark harnesses for RAG components, connectors, rankers, and agent/tool modules; track latency/cost envelopes and regressions over time.

• Orchestrate integration tests against common stacks (vector databases, storages, identity providers) to validate interface contracts used by platform services.

• Maintain regression baselines and performance dashboards; fail builds on significant regressions.

4) Operability for Consumers (SDK↔Service Parity)

• Embed observability hooks appropriate for libraries (structured logging, configurable metrics/traces) so services consuming the SDK can integrate telemetry consistently.

• Define interface contracts and runtime configuration patterns (config schema, secrets management integration points) that downstream services must honor.

• Partner with platform teams to publish service readiness guides built on SDK interfaces (env parity, retry/backoff, error models).

5) Environments, Reproducibility & Tooling

• Design isolated test environments and fixtures for data, vector stores, and external dependencies; leverage tox/pytest‑xdist for matrix runs.

• Own Infrastructure-as-Code limited to test/development environments and CI runners; ensure deterministic builds and environment parity.

• Optimize pipeline performance (caching wheels, parallelization) and track DORA‑style delivery metrics to continuously improve.

6) Developer Experience & Contribution Workflows

• Collaborate with Developer Experience Engineers to produce developer‑ready artifacts (quickstarts, sample apps, docs bundles generated during CI).

• Standardize contribution workflows: feature branches, PR checks, mandatory tests/benchmarks/docs acceptance criteria; enable community extensions safely.

• Provide CLI/tooling or cookiecutters that scaffold new SDK modules with tests, docs, and benchmark hooks prewired.

7) Collaboration & Continuous Improvement

• Align pipeline policies with AI Capability Architecture Lead and ensure SDK interface consistency for downstream service teams.

• Close feedback loops with Embedded Architecture, Solution Design, AI Engineering, Creation Centers, and FITs to prioritize pipeline and release ergonomics improvements.

• Lead post‑release retrospectives to reduce defects, MTTR, and onboarding friction for consuming teams.

QUALIFICATIONS

Basic Qualifications

• 7+ years in DevOps/SRE/Build & Release engineering, with significant experience in Python packaging and library delivery (wheels/sdists, internal PyPI).

• Expert in CI/CD for libraries (GitHub Actions/Azure DevOps/GitLab CI) and artifact management (PyPI/private indices, container registries as needed for test harnesses).

• Strong hands‑on with cloud‑native development and CI runners; proficiency with IaC for build/test environments.

• Proven track record implementing quality gates: automated tests, secrets management, test coverage, dependency/security scanning, SBOMs/signing, policy‑as‑code.

• Experience embedding observability hooks for libraries and defining interface contracts for service consumers.

Preferred Qualifications

• Familiarity with GenAI/LLM ecosystems (RAG pipelines, vector stores, agent/tool frameworks, MCP adaptors) and their benchmarking/testing needs.

• Background in performance engineering for Python (profiling, async/concurrency, I/O, data pipelines) and managing latency/cost regressions.

• Experience with open-source contribution workflows, multi‑language SDK delivery (Python primary; TypeScript/Java nice-to-have), and semantic versioning discipline.

• Exposure to regulated environments and audit‑ready release documentation.

• Comfortable partnering across architecture, QA, DX, LLMOps, platform, and product teams in a matrixed organization.