Full-time Description

JOB TITLE: Senior Software Engineer - Developer Tools & AI

JOB TYPE: Full-Time

JOB LOCATION: India, Chennai (Hybrid)

About CloudBees

CloudBees helps organizations build, run, and govern software factories, giving enterprises the confidence to ship software better, faster, and safer.

Writing code is no longer the bottleneck. Governing what reaches production and validating its impact is. As enterprises adopt agentic coding, software is created faster than most teams can review, secure, and validate. Without consistent governance, organizations risk shipping code they cannot explain, audit, or trust.

CloudBees addresses this challenge without asking teams to replace the tools they already use. Across every toolchain a customer runs, CloudBees makes each change, human or AI, visible, auditable, and accountable before it reaches production. CloudBees Unify is the product behind this: a governance layer, with context and control-plane capabilities, that enforces consistent policy and evidence across every tool, team, and workflow.

Founded in 2010, CloudBees is backed by Goldman Sachs, Morgan Stanley, Bridgepoint Capital, HSBC, Golub Capital, Delta-v Capital, Matrix Partners, and Lightspeed Venture Partners.

Visit us at www.cloudbees.com.

Requirements

About the Role

We build the software, tools and automation that CloudBees engineers use to develop and deliver software. This includes developer tooling, shared engineering services and our AI Software Factory: systems that automate and improve increasingly large parts of the software development lifecycle.

This is fundamentally a software engineering role. You will design and build production software, developer tools, APIs, integrations and automation. Infrastructure matters because our software has to run somewhere, but operating infrastructure is not the primary purpose of the role.

AI is also not an optional productivity add-on for this team. We expect senior engineers to have an established AI development practice that goes materially beyond prompt completion, code generation and small-scale edits. You should already be using AI to tackle higher-order engineering work: decomposing problems, planning changes, coordinating agents or automated workflows, validating outcomes, and improving the systems and constraints that make AI-generated work reliable.

You do not need a machine learning background. You do need demonstrated experience applying AI to substantial software engineering problems while retaining engineering ownership and judgement.

What You’ll Do

Build Developer Tools and Engineering Systems

- Design, build and operate production software that improves how engineers develop, test, integrate and deliver software.
- Build developer-facing tools, services, APIs, CLIs and integrations with a strong focus on usability, sensible defaults and useful feedback.
- Automate repetitive or error-prone engineering work by building maintainable systems rather than accumulating one-off scripts.
- Integrate with systems across the engineering lifecycle, including source control, CI/CD, identity, issue tracking, build systems, deployment systems and AI agents.
- Own the software you ship from design through production, including testing, security, observability, reliability and ongoing improvement.

Engineer in an AI-Native Environment

- Use modern AI coding agents as a normal part of professional software development, not simply as autocomplete or a source of isolated code snippets.
- Decompose substantial engineering work into problems that humans and AI agents can execute effectively, with clear context, constraints and validation.
- Use higher-order AI automation to accelerate engineering work,



including agentic workflows, repeatable development automation, structured planning and automated validation where appropriate.
- Review plans, designs and code produced by AI with the same engineering judgement applied to human contributions, including recognising plausible but incorrect implementations, missing edge cases and architectural drift.
- Improve the feedback loops, tools, context and guardrails that make AI-assisted development more reliable and scalable.
- Evaluate current models, tools and techniques based on demonstrated engineering outcomes rather than novelty.

Design Systems, Not Just Implementations

- Turn ambiguous engineering problems into coherent technical designs and executable increments.
- Reason about APIs, component boundaries, data models, state, concurrency, failure modes, security, performance and operational trade-offs.
- Design robust integrations between independently evolving systems, including authentication, versioning, failure handling and backwards compatibility.
- Participate in architecture reviews and make pragmatic build, buy and integrate decisions.

Raise the Engineering Bar

- Treat other engineers as users of the systems you build and actively improve their developer experience.
- Mentor other engineers and contribute to shared engineering patterns, practices and tooling.
- Identify unnecessary complexity and manual work in the software delivery lifecycle and remove it.
- Help evolve how CloudBees engineers work as AI agents become increasingly capable participants in software delivery.

What We’re Looking For

Required

- Senior software engineering capability. You have designed, built, shipped and maintained substantial production software and can independently own non-trivial engineering problems.
- Strong programming experience. You have professional software development experience in at least one modern structured programming language such as Go, Python or Java. Experience using Python primarily for scripting, glue code or infrastructure automation does not meet this requirement.
- Strong system design fundamentals. You can reason about architecture, APIs, state, data, concurrency, failure modes, security, performance and operational characteristics, and make appropriate trade-offs.
- Demonstrated higher-order AI development practice. You already use modern AI development tools for substantial engineering work beyond prompt completion and small-scale edits. You can demonstrate how you have used AI to decompose and execute complex work, coordinate or automate development workflows, validate results, and improve the reliability of AI-assisted engineering.
- Engineering judgement around AI. You understand that AI-generated output is not inherently correct. You can constrain work, review plans and implementations, detect drift and subtle errors, and remain accountable for the outcome.
- Developer-oriented product thinking. You care about APIs, CLIs, workflows, documentation, defaults, error messages and the overall experience of engineers using what you build.
- Automation mindset. You look for repetitive engineering work that should cease to exist and can replace it with maintainable software and automation.
- Production ownership. You build software that can be tested, secured, observed, diagnosed and operated,



and you take responsibility for what happens after it ships.

Preferred

- Experience building developer tools, internal developer platforms or shared engineering services.
- Experience building agentic systems, AI-powered developer tooling or automated software development workflows.
- Experience with CI/CD systems, source-control integrations, workflow engines or build tooling.
- Experience designing APIs and integrations across multiple independently evolving systems.
- Experience with cloud platforms, containers and Kubernetes sufficient to develop and operate your own software.
- Familiarity with modern AI application concepts such as tool use, context management, evaluation, structured outputs, permissions and agent orchestration.
- Experience with technologies such as MCP, Tekton, Jenkins, GitHub, GitLab, Argo, LangGraph or similar systems is useful, but no particular framework is required.

What We Don’t Require

- A machine learning or data science background. This role is about software engineering and AI-enabled software development, not training models.
- Deep DevOps or SRE specialisation. You need to be capable of operating the software you build, but infrastructure operations are not the primary job.
- Expertise in a specific AI framework. The underlying models, tools and frameworks will continue to change.
- A particular preferred programming language if you can demonstrate strong software engineering capability in an equivalent modern language.

What Success Looks Like

First 3 Months

- Shipping useful production software with minimal ramp-up.
- Demonstrating effective use of AI agents on substantial engineering work while maintaining clear ownership of design and quality.
- Understanding the existing developer workflow well enough to identify meaningful opportunities for automation or simplification.
- Owning a developer tool, service or integration end-to-end.

3-6 Months

- Delivering a materially improved developer or Software Factory capability that other engineers rely on.
- Automating a meaningful part of the software development lifecycle that previously required repeated human effort.
- Contributing reusable patterns, tooling or AI workflows that improve how the wider team develops software.
- Making sound system design decisions across multiple services or integrations.

6-12 Months

- Leading a significant Developer Tools or AI Software Factory initiative from problem definition through production adoption.
- Improving not only individual implementations but the engineering system that produces them: its automation, feedback loops, guardrails and developer experience.
- Raising the team's bar for effective AI-assisted engineering through demonstrated practices and reusable automation.
- Influencing architectural and build, buy and integrate decisions across the engineering system.

Why This Role

Software engineering is changing quickly. AI agents can now participate in planning, implementation, testing, review and operational workflows, but simply generating more code is not the objective. The harder problem is building an engineering system that can use those capabilities safely, repeatedly and at scale.

This team works on that problem directly. You will build the tools and automation used by engineers today while helping shape an AI Software Factory in which humans and agents collaborate across the software development lifecycle.

The opportunity is not to outsource engineering judgement to AI. It is to apply strong software engineering judgement at a higher level: designing the systems, constraints, feedback loops and automation that allow both humans and AI agents to produce better software.

📌 Senior Software Engineer - Developer Tools & AI (Chennai)
🏢 CloudBees
📍 Chennai