Software Automation Engineer

Role purpose

Create and maintain dependable automated checks that protect X3 customer behaviour and give X3 squads fast feedback on every change, release and migration asset.

X3 context

Sage X3 is the SaaS-readiness programme for X3: a progressive transformation from tightly coupled legacy runtime patterns towards portable, cloud-operable and upgradeable capabilities. The programme protects customer behaviour, partner IP and rollback while it modernises journeys, APIs, components, data paths, business logic, delivery automation and migration economics.

The role contributes to outcome-owned squads. India is a scalable engineering and product delivery centre, connected to Europe and North America through deliberate overlap, shared standards, recorded decisions and continuous support of production outcomes.

Required technical and domain skills

• Professional experience in software testing or automation and a willingness to write production-quality code.

• Working knowledge of one automation language and tools for API, UI or service testing.

• Foundational understanding of enterprise business workflows (ERP or similar), Agile delivery, CI/CD and source control.

• Basic SQL/data validation and REST/SOAP integration testing, with interest in batch and migration workflows.

• Interest in GraphQL, PostgreSQL/data paths, Web/Syracuse, observability and cloud operations.

• Hands-on experience with containerisation and Kubernetes.

• Good English communication, attention to detail and a habit of recording evidence.

Modern platform skills for this role

• Build automated API, event, integration and regression checks into CI/CD; validate compatibility and migration reconciliation, keep failures diagnosable, and learn the team’s secure artifact, telemetry and rollback practices.

Preferred skills

• TypeScript/JavaScript, Playwright/Cypress, API contract testing or SQL Server/Oracle.

• Sage X3, ERP, manufacturing, distribution or finance testing experience, including L4G/4GL or Crystal Reports.

• Performance, accessibility, security or migration testing exposure.

Experience and qualifications

Typically 2+ years in software testing, quality engineering or development, with practical automation experience. Degree, diploma or equivalent experience in computing or engineering is desirable.

Professional English is required for global collaboration. Equivalent practical experience is valued alongside formal qualifications.

Expected outcomes / success measures

• Stories have relevant automated checks and clear, reproducible evidence.

• Regression suites remain reliable and useful as components, APIs and customisations change.

• Defects are found earlier, described precisely and linked to customer impact.

• The engineer steadily expands domain knowledge and contributes to safer release and migration practice.

Measures should be agreed with the squad and reviewed through the X3 monthly scorecard and quarterly evidence gates. For this role’s owned scope, show how customer behaviour and partner investment are preserved, capabilities become portable, secure, cloud-operable and upgradeable, and quality, reliability, supportability and rollback are proven. Include safe migration and improved cost or delivery economics where relevant.

Key stakeholders and collaboration model

Works with Software Engineers, Senior Automation Engineers, Product, Cloud Support/L3, Security and Customer Services in a distributed squad, with India-based execution connected to Europe/North America overlap.

Sage behaviours / leadership expectations

Customer Focus, Action Orientation, Trust, Innovation and Collaboration. Is curious, precise, open to feedback and willing to learn the domain behind the test.

Every colleague is expected to protect customer continuity, partner investment, security and the integrity of evidence. Leaders additionally create clarity, develop talent and make accountable decisions visible.

AI Infrastructure Engineer (Mid / Senior)

Location: Bengaluru (Hybrid – 3 days a week in office)

About Us

Sage is a global leader in accounting and business management software, trusted by millions of businesses worldwide. Together with our Bengaluru engineering team, we are building a finance, accounting, payroll and expense management** solution****s** that simplifies how businesses track and reconcile spending.

Thousands of finance teams globally use our product to streamline expense management, integrate seamlessly with leading accounting platforms, and are recognized for its clean design, usability, and speed.

We’re investing heavily in AI — building the platform that lets AI agents and assistants do real engineering work, reliably and at scale. This team designs and runs the infrastructure behind our coding agents, review agents, and internal AI assistants: the orchestration, context and memory systems, evaluation frameworks, and feedback loops that make them better over time.

The Impact You’ll Make

• Build and operate agent platforms: orchestration, tool and skill registries, plugin frameworks, and sandboxed execution.

• Develop coding agents and review agents that work well on real, large codebases, and integrate them into the existing SDLC (IDE, CI/CD, code review, issue tracking).

• Design context and memory management: retrieval (RAG), summarization and compression, session state, long-term memory, and repository-aware context.

• Build evaluation frameworks — both offline (benchmarks, regression suites) and online (production quality signals) — so we can measure whether agents are improving.

• Create feedback loops: capture and mine traces, find failure patterns, and turn them into better prompts, tools, skills, and evals.

• Build developer tooling and internal SDKs that make it easy for other teams to build on and adopt the platform.

• Own observability for agent systems: tracing, cost and latency tracking, and quality monitoring.

• Work with engineers and stakeholders to identify high-value workflows, ship quickly, and iterate on real usage data.

What We’re Looking For

We’re looking for someone with 3+ years of software engineering experience (mid-level) or 6+ years (senior), with hands-on experience building LLM-powered or agent-based systems in production.

Technical Skills

• Solid software engineering fundamentals: system design, API design, data modelling, and clean, maintainable code.

• Experience building and running production systems in the cloud (AWS, GCP, or Azure), including containers, Kubernetes or similar, and infrastructure as code.

• Hands-on experience with distributed systems: queues, async workflows, concurrency, reliability, and failure handling.

• Practical experience building with LLMs: tool use, agents, prompt and context engineering, RAG, and evaluation.

• Familiarity with agent protocols and ecosystems (e.g., MCP) and with using AI coding tools day to day.

Leadership & Ownership

• Comfort working independently and handling ambiguity: you can take a loosely defined problem, scope it, and drive it to production.

• Clear written and verbal communication, including explaining trade-offs to both technical and non-technical audiences.

• At the senior level, we also expect you to lead projects and set technical direction, mentor other engineers, define evaluation and quality standards, and influence architecture across teams.

Mindset & Collaboration

• Growth mindset — curious, always learning, and open to feedback.

• Works closely with the engineers who use these tools every day; you help the whole organization build software better and faster.

Nice to Have

• Experience with trace analysis or log mining to find and fix agent failure modes.

• Experience building internal platforms or SDKs that other teams adopted.

• Background in observability, CI/CD, or developer productivity tooling.

• Experience with model routing, cost optimization, or prompt caching.

• Open-source or public contributions in agent tooling or LLM infrastructure.

What to Expect

• We value humility and collaboration — we’re looking for people who can work as part of a team, not in silos.

• We expect engineers to take ownership beyond just writing code — including tests, documentation, and long-term system quality.

Core accountabilities and decision ownership

• Develop automated UI, API, GraphQL, integration and regression tests from clear risks and acceptance criteria.

• Maintain test data, environments, diagnostics and documentation so failures can be reproduced and fixed efficiently.

• Contribute tests to CI/CD quality gates and help identify flaky, missing or redundant coverage.

• Learn X3 processes, metadata and customisation patterns so automation reflects real customer outcomes.

• Participate in defect analysis, release verification, upgrade checks and rollback rehearsals.

Decision ownership:

Test implementation for assigned stories, defect evidence, coverage recommendations and escalation of quality or environment risks.

Common capability baseline

All X3 roles are expected to build capability in the following areas. Depth and decision scope increase with level:

• Understand X3 customer workflows, metadata, customisation and architecture well enough to protect supported behaviour, partner investment and SaaS readiness in the decisions owned by the role.

• Treat the internal platform as a product: use developer and operator research, feedback and adoption evidence to reduce cognitive load; provide self-service APIs and golden paths where they solve a demonstrated need.

• Use cloud-native service boundaries, versioned API contracts and event integration where appropriate, preserving compatibility and clear ownership across X3 capabilities.

• Apply CI/CD and secure software-supply-chain controls, with identity, secrets and policy enforcement built into relevant delivery and runtime paths.

• Make services diagnosable with OpenTelemetry-compatible logs, metrics and traces; define role-appropriate SLOs, reliability and resilience evidence.

• Manage performance and cost deliberately, and engineer lifecycle, upgrade, deprecation and rollback paths as part of supported capability ownership.

• Use migration, reconciliation and compatibility evidence to preserve customer data and behaviour while moving towards portable, secure, cloud-operable and upgradeable capabilities.

• Use AI-assisted engineering securely, with human review, privacy and IP protection, regression evidence and a recovery path; use deterministic methods when they are more appropriate.

• Depth follows role scope: engineers demonstrate hands-on lifecycle capability in their discipline; managers, product and programme leaders, and architects need decision-relevant fluency, not universal coding or every tool. Containerisation and Kubernetes are required for all engineering roles. Infrastructure as code, GitOps and a custom internal developer platform apply where the role owns those paths.