AI Platform Engineer

What matters most

• Enterprise retrieval and knowledge ingestion

  The posting calls for scalable data and knowledge ingestion, integration of enterprise repositories, embeddings, vector databases and knowledge graphs, and retrieval frameworks for semantic search and RAG.

• Model serving and secure agent execution

  Build and operate Amazon Bedrock services and real-time and batch inference; support agent architectures using AWS AgentCore or comparable platforms, with MCP-based tool orchestration and agent communication.

• Centralized AI access and governance

  Implement AI Gateway capabilities for authentication, routing, rate limits, policy enforcement and telemetry. The role also calls for controls over models, prompts, tools and enterprise knowledge sources.

• Evaluation, observability and recovery

  Monitor model and agent behavior, usage, token consumption, latency and reliability; support evaluation and Responsible AI guardrails, with logging, tracing, alerts, rollback and recovery.

• Operational standards and developer enablement

  Apply SRE, FinOps and Infrastructure as Code practices while producing APIs, SDKs, self-service tools, reference architectures and runbooks. The posting also calls for advising application teams and mentoring colleagues.

Likely challenges to think through

• Useful retrieval versus governed data access

  Preparation hypothesis: broader knowledge access could improve RAG answers while increasing privacy and authorization risks. Prepare to explain how ingestion permissions, retrieval evaluation and data-protection controls would work together.

• Agent flexibility versus controlled execution

  Preparation hypothesis: reusable MCP tools and multi-agent patterns could accelerate development but widen the impact of unsafe tool calls. Prepare an architecture discussion covering authorization, scoped tool access, auditability and recovery.

• Central standards versus team autonomy

  Preparation hypothesis: gateway policies and shared services must be consistent without making application integration cumbersome. Prepare to describe how self-service APIs, reference patterns and cross-team feedback can support both control and adoption.

• Inference quality versus latency and cost

  Preparation hypothesis: model routing, evaluation and guardrails may add latency or token expense even as they improve outcomes. Prepare to discuss measurable trade-offs using quality benchmarks, gateway telemetry, SLOs and FinOps metrics.

Topics to prepare

• Enterprise RAG architecture

  The posting requires RAG with embeddings, vector databases, and enterprise knowledge sources, and describes knowledge graphs and governed ingestion. Exercise: sketch an ingestion-to-answer architecture and explain how you would test retrieval quality and enforce access to source material.

• Bedrock inference and agent design

  Hands-on Amazon Bedrock and experience with AWS AgentCore or comparable agent frameworks are required. Exercise: compare real-time and batch inference designs, then explain when a single agent, tool-using agent, or multi-agent pattern is warranted.

• MCP and agent communication

  The role requires MCP-based solutions and familiarity with agent-to-agent patterns. Exercise: diagram a tool request from agent to execution, marking authorization, data boundaries, and failure handling.

• AI Gateway architecture

  AI Gateway implementation is required; Kong AI Gateway is an example, not the only acceptable solution. Exercise: design a model-access flow showing authentication, routing, rate limits, policy enforcement, and telemetry.

• Evaluation and Responsible AI

  The posting calls for model evaluation, guardrails, privacy, explainability, fairness, and governance. Exercise: outline evaluation cases for a RAG application, including unsupported answers, sensitive-data exposure, and guardrail failures.

• Platform reliability and cost

  SRE, FinOps, observability, token optimization, and operational support appear throughout the role. Exercise: choose service metrics for latency, reliability, throughput, and token consumption; explain alert, rollback, and cost-control decisions.

Skills to revise

• Build a governed retrieval prototype

  Suggested practice: use sample documents to implement ingestion, embeddings, vector retrieval, and cited answers; test stale content and document-access boundaries. This mirrors the posted RAG and knowledge-ingestion work.

• Implement a Bedrock-backed service

  Suggested practice: write a small Python API that invokes a Bedrock foundation model and handles request validation, errors, and usage measurement. Python proficiency and hands-on Bedrock experience are required.

• Secure an MCP tool interaction

  Suggested practice: implement a narrowly scoped MCP tool using sample data, with input validation, authorization checks, and audit records. MCP solutions are required; MCP servers and secure tool execution are preferred experience.

• Configure gateway controls

  Suggested practice: configure or prototype an AI Gateway route with authentication, model routing, rate limiting, policy checks, and request telemetry. These are explicit gateway responsibilities; Kong is one named example.

• Instrument and recover a workload

  Suggested practice: add logs and traces for a model-and-agent request, track latency and tokens, then write a short alert-and-rollback runbook. The posting explicitly covers observability, recovery, SLOs, and FinOps.

• Automate a platform deployment

  Suggested practice: define infrastructure as code for a containerized service, add CI/CD checks, and document Kubernetes deployment, secrets, and access controls. AWS, containers, Kubernetes, CI/CD, security, and IaC are stated requirements or responsibilities.

• Map your evidence to the requirements

  Prepare a one-page matrix of actual examples covering distributed or cloud-native platforms, AI/ML services, hands-on Bedrock, RAG, agents, MCP, gateways, AWS, Kubernetes, CI/CD, and security. Note gaps honestly; the posting specifies 7+ years in platform systems and 3+ years in AI/ML platforms.

• Rehearse a RAG project walkthrough

  If you have a relevant example, prepare a diagram and results showing ingestion, embeddings, vector retrieval, enterprise knowledge access, evaluation, and governance decisions. Otherwise, use a clearly labeled design example rather than implying deployed experience.

• Practice a Bedrock and agent design exercise

  Sketch how you would support real-time and batch inference, an agent platform such as AgentCore, and MCP-based tool access. Explain orchestration, agent-to-agent communication, failure handling, and the boundaries between platform and application teams.

• Diagram an AI Gateway control path

  Prepare a proposed request flow for authentication, authorization, model routing, rate limits, policy enforcement, and telemetry. Be ready to discuss Kong AI Gateway or an equivalent without claiming Capital Group uses a particular implementation.

• Prepare a security and governance review

  Use a proposed architecture to identify where IAM, encryption, secrets, audit logs, prompt protection, data privacy, and controls over models, tools, and knowledge sources belong. Include decisions to review with Security, Risk, Compliance, and Data Governance.

• Build an operations and evaluation brief

  Draft example SLOs, traces, alerts, rollback steps, and a short runbook for model or agent failures. Add an evaluation plan and metrics for quality, latency, token use, throughput, reliability, and cost; label targets as proposals, not company standards.

• Show how you enable engineering teams

  Prepare one example of an API, SDK, self-service workflow, or reference architecture you have built, if applicable. Explain its IaC, container or CI/CD approach, documentation, adoption, and any mentoring contribution.

• Write targeted questions for the employer

  Ask which platform capabilities are already live, how Bedrock, AgentCore, MCP, and gateway responsibilities are divided, what governance and evaluation standards exist, and which reliability, developer-experience, and FinOps outcomes matter most.