Product Manager, AI

What matters most

• Own the product lifecycle while building

  The role spans discovery, requirements, development, testing, deployment and iteration. LSEG explicitly values product ownership and engineering depth in equal measure.

• Build production-grade agentic workflows

  Design and refine LLM-powered workflows for complex, data-intensive use cases, including agent configuration, orchestration and tool use. The posting favors shipped products or features over academic work.

• Define and monitor AI output quality

  Set acceptance criteria, test edge cases and monitor production accuracy, latency, cost and auditability. Use performance data and user feedback to inform optimization and model or feature refreshes.

• Design for governance requirements

  Work with governance teams on internal quality, compliance and interoperability standards. The posting also calls for attention to data quality, model monitoring and bias in regulated environments.

• Translate across teams and audiences

  Turn business and user needs into actionable requirements, work across technical and commercial teams, and demonstrate capabilities internally and externally. Track relevant model, framework and protocol developments for product opportunities.

Likely challenges to think through

• Balancing output quality with operating limits

  Likely preparation challenge, not a confirmed LSEG problem: more elaborate agent workflows may improve some outputs while increasing latency and cost. Prepare a concrete example of how you would set acceptance thresholds, test failure modes and compare trade-offs using production metrics.

• Iterating without losing auditability

  Likely preparation challenge: model or feature refreshes may change variable outputs while quality and compliance expectations remain. Prepare to explain how you would evaluate changes against acceptance criteria, document decisions and involve governance partners.

• Combining hands-on delivery with product decisions

  Likely preparation challenge: the same role must define what to build, contribute technically and explain decisions to different audiences. Prepare an example that distinguishes the user need, the technical choices and how you communicated the resulting trade-offs.

Topics to prepare

• AI product lifecycle and ownership

  The posting spans discovery, requirements, development, deployment and post-launch iteration. Suggested revision exercise: map a hypothetical AI feature through those stages, identifying the decision and evidence needed at each handoff.

• Production agent behavior

  The role calls for knowledge of prompt design, tool use, orchestration, output variability and failure modes. Suggested revision exercise: diagram an LLM workflow and explain how it should behave when a tool fails or returns inconsistent data.

• AI output quality and acceptance criteria

  LSEG specifies accuracy, latency, cost and auditability as production measures. Suggested revision exercise: define a small set of acceptance criteria and explain how a failed criterion would affect a release decision.

• Near-real-time system trade-offs

  The posting requires sensitivity to latency, throughput and cost in real-time or near-real-time data systems. Suggested revision exercise: compare two hypothetical workflow designs and explain which constraints would drive your choice.

• Responsible AI and interoperability

  The role involves data quality, performance monitoring and bias considerations in regulated environments, alongside quality, compliance and interoperability standards. Suggested revision exercise: outline the product-design questions you would take to a governance review; the exercise is preparation, not a stated LSEG process.

Skills to revise

• Write requirements and challenge specifications

  The posting expects clear product requirements and independent review of technical specifications. Suggested exercise: turn a business need into an agent-workflow requirement, acceptance criteria and three questions about the proposed implementation.

• Prototype an LLM-powered workflow in Python

  Hands-on LLM or agentic-framework experience and solid Python skills are explicit. Suggested exercise: build a small Python workflow that uses a prompt and a tool call, then test its response to an unavailable tool. No particular framework is specified.

• Test outputs and integration edge cases

  The role includes evaluating AI outputs and resolving model or integration issues with engineering teams. Suggested exercise: create a compact test set with expected outcomes, ambiguous inputs and a failed integration response; record and categorize the results.

• Trace an API-to-output data flow

  The posting names familiarity with APIs, data pipelines and cloud infrastructure. Suggested exercise: sketch how incoming data reaches an agent and its output, then identify where data freshness, errors and operational cost should be checked. The sketch is a preparation suggestion, not a prescribed architecture.

• Present a prototype and its trade-offs

  LSEG calls for demos to internal and external audiences and clear communication with technical and commercial stakeholders. Suggested exercise: rehearse a brief prototype walkthrough that explains the user need, demonstrated capability, measured limitations and next iteration without overstating reliability.

• Choose a hands-on AI product case

  Prepare a walkthrough showing your product and engineering decisions from discovery through deployment and iteration. The posting prefers shipped LLM or agentic features; distinguish work that shipped from prototypes and state your own contribution.

• Draft a one-page product requirement

  As a practice exercise, turn a data-intensive user need into a problem statement, agent configuration, technical constraints and testable acceptance criteria. Be ready to explain how you would review an engineering specification.

• Sketch an agentic workflow

  Draw a proposed design covering model prompts, orchestration, tool use, Python components, APIs and data pipelines. Explain failure handling and the latency, throughput and cost trade-offs for near-real-time data.

• Build an AI evaluation plan

  Prepare sample test cases for output variability, edge cases and model or integration failures. Define how you would assess accuracy, latency, cost and auditability against acceptance criteria.

• Plan production iteration and governance

  Outline what you would monitor after launch, how user feedback would inform model or feature refreshes, and where data quality, bias, compliance and interoperability reviews would enter the process.

• Rehearse a prototype demonstration

  Prepare a short explanation of the workflow for both engineers and client-facing stakeholders, including what it does, its limitations and the product decisions behind it. The role includes demonstrations to internal and external audiences.

• Bring focused questions for LSEG

  Ask which data-intensive use cases are priorities, how teams measure production AI quality, how governance teams participate, and which emerging model, framework or protocol developments they are evaluating.