New opportunity

AI Engineering Lead

Flutter Entertainment · Hyderabad, India

About this role

Flutter Entertainment’s AI & Automation team seeks an AI Engineering Lead to build and lead a pod of 2–3 AI developers. The role owns the technical direction and delivery of enterprise AI assistant and agent platforms that use internal data to improve productivity and decision-making across sports betting and gaming operations. The position is based in Hyderabad on a hybrid schedule of two office days per week.

Responsibilities

Set architecture and engineering standards for LLM inference, agent frameworks, context pipelines, prompt design, evaluations and guardrails. Select and optimize inference systems, including LiteLLM and AWS Bedrock, with attention to model routing, token costs, latency and context-window trade-offs.
Guide multi-agent orchestration, scalable APIs and integrations using services such as AWS Lambda and API Gateway and standards such as Model Context Protocol. Own solutions across LLM integration, backend services and user-facing interfaces.
Design safe, auditable systems aligned with Flutter’s Responsible AI Policy and obligations across 20+ regulated markets. Address prompt injection, data leakage, authentication, access control and sensitive-data handling.
Hire, mentor and develop the pod; conduct code reviews, establish technical practices and lead incident response and post-mortems. Partner with product, data science, platform engineering and business stakeholders to deliver production systems and communicate architectural decisions.

Required qualifications

Bachelor’s degree in Computer Science, AI or a related STEM field; 5–8 years of software development experience, including 2–3+ years focused on AI/ML or agentic systems. Experience leading or mentoring technical teams.
Advanced Python and production backend experience with FastAPI or Flask and asynchronous patterns. Hands-on experience with AWS Bedrock, LiteLLM or similar inference platforms; context engineering, RAG and prompt architecture; and deep experience with at least 2–3 agent frameworks such as LangChain, LangGraph, Strands, ADK or CrewAI.
Production experience with guardrails, content filtering and responsible AI; AI security fundamentals; proficiency with AI coding tools such as Claude Code, GitHub Copilot or OpenCode; and strong software engineering, API design and communication skills.

Highly desirable: Full-stack experience with React and TypeScript; production vector databases such as Pinecone, pgvector, OpenSearch or Weaviate; MCP implementation; open-source AI contributions; experience in regulated industries; and a record of developing engineers or leading impactful technical initiatives.

Benefits include learning and development support, internal mobility, health and insurance coverage, wellness support, flexible leave, meals, cab and home-office allowances, retirement-related benefits and a discounted-share purchase plan.

For full details about this role, click “Apply on company site” to view the employer’s original posting.

Skills for this role

PythonFastAPIFlaskAWS BedrockLiteLLMAWS LambdaAmazon API GatewayLangChainLangGraphStrandsADKCrewAIRetrieval-Augmented GenerationContext EngineeringPrompt EngineeringLLM InferenceModel RoutingMulti-Agent OrchestrationAI GuardrailsResponsible AIPrompt Injection PreventionOAuthJWTModel Context ProtocolClaude CodeGitHub CopilotOpenCodeGitAPI DesignReact & TypeScript

Checking your profile…

Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.

Understand the role

What matters most

Own the enterprise AI platform architecture
Set technical direction for AI assistants and agents that use internal data. Own solutions from LLM integration through Python backend services, scalable APIs and user-facing interfaces, with maintainable AWS integration patterns.
Make disciplined inference decisions
Select and optimize systems such as LiteLLM and AWS Bedrock. Establish model-routing patterns and architectural reviews that account for token cost, latency, context limits and capability.
Standardize context and agent design
Define production practices for context pipelines, RAG, prompts, evaluations and multi-agent orchestration. Guide framework choices based on the problem rather than adopting one pattern everywhere.
Build safety and auditability into delivery
Architect guardrails aligned with Flutter's Responsible AI Policy and obligations across 20+ regulated markets. Address prompt injection, data leakage, authentication, access control and sensitive-data handling in design and testing.
Grow the pod while delivering with partners
Hire and mentor 2–3 AI developers, use code reviews to establish standards, and lead incidents and post-mortems. Work with product, business, data science and platform engineering partners to turn requirements into production systems.

Likely challenges to think through

Balancing answer quality against operating cost
A preparation hypothesis: richer context and more capable models may improve results while increasing tokens and latency. Prepare a decision framework for model routing and context limits, with evaluations and cost and latency measures to support trade-offs.
Using internal data without widening exposure
A preparation hypothesis: useful assistants need relevant internal context, but retrieval and agent tool use can create leakage or prompt-injection paths. Prepare to explain how access controls, least privilege, guardrails, testing and auditability would shape the design.
Leading hands-on architecture without bottlenecking a small pod
A preparation hypothesis: the lead must make technical decisions and support delivery while developing 2–3 engineers. Prepare an approach to delegating ownership, using reviews as teaching moments, and handling incidents without concentrating every decision in the lead.

Practice your answers

Technical practice

How would you set the architecture for an enterprise AI assistant and agent platform using internal data?

What to coverThe role owns technical direction from LLM integration through backend services to user-facing interfaces. Suggested preparation: explain component boundaries, access to internal data, and how you would balance platform consistency with the needs of different use cases.

How would you choose and route models through LiteLLM, AWS Bedrock, or an alternative?

What to coverThe posting calls out model routing, token costs, latency budgets, context limits, and capability-to-cost trade-offs. Suggested preparation: describe the evidence you would collect and how those trade-offs would become team-wide architectural guidance.

How would you design a production RAG context pipeline over internal data?

What to coverContext engineering and RAG are core requirements; production vector databases are listed as desirable. Suggested preparation: cover retrieval quality, relevance, access controls, and how you would evaluate whether retrieved context improves answers.

How would you establish prompt patterns and evaluation standards across a platform?

What to coverThe role sets prompt architecture, code patterns, and evaluation frameworks for consistent quality. Suggested preparation: distinguish testing a prompt change from testing retrieval or model changes, and explain how results would inform a release decision.

When would you use multi-agent orchestration rather than a simpler agent pattern?

What to coverThe posting seeks experience across multiple agent frameworks and judgment about orchestration and tool-use patterns. Suggested preparation: compare coordination, complexity, failure handling, and maintainability, using frameworks named in the posting only where they clarify the choice.

How would you defend an internal-data assistant against prompt injection and data leakage?

What to coverThe role explicitly addresses prompt injection, exfiltration, authentication, access control, and sensitive-data handling. Suggested preparation: trace trust boundaries from user request through retrieval and tool use, then explain least-privilege controls and security testing.

How would you design guardrails and auditability for AI outputs across regulated markets?

What to coverThe posting requires alignment with Flutter's Responsible AI Policy and obligations across 20+ regulated markets, but does not specify individual rules. Suggested preparation: discuss content filtering, design reviews, testing, and auditable decisions without assuming a particular market's requirements.

How would you build scalable Python APIs for an AI assistant?

What to coverAdvanced Python, FastAPI or Flask, asynchronous patterns, and integrations using services such as AWS Lambda and API Gateway are stated. Suggested preparation: explain API boundaries and when async execution helps, including how you would handle slow or failed inference calls.

Where could Model Context Protocol fit into agent tool integration?

What to coverThe posting names MCP for predictable integrations and lists implementation experience as desirable. Suggested preparation: explain when a standard tool-and-context interface would help, and what access-control and maintainability questions you would review before adopting it.

How would you validate AI-generated code before it enters a production AI platform?

What to coverProficiency with AI coding tools and the ability to validate their output are core requirements. Suggested preparation: describe review and testing practices for correctness, security, and maintainability, including how you would teach developers to apply them.

Behavioural practice

Tell me about a time you helped an engineer grow through mentoring.

What to coverThe role involves developing a pod of 2–3 AI developers and supporting individual growth. Suggested preparation: use a real situation, your specific coaching actions, and an observable result; distinguish your contribution from the engineer's work.

Describe a code review in which you caught an architectural issue without turning review into gatekeeping.

What to coverThe posting asks the lead to set technical standards and use reviews as teaching moments. Suggested preparation: give the situation, how you explained and resolved the concern, and the resulting change to the code or team practice.

Tell me about a production incident you led through resolution and follow-up.

What to coverIncident leadership, blameless post-mortems, and systemic improvement are stated responsibilities. Suggested preparation: explain the situation, your actions during diagnosis and coordination, and what changed afterward, without claiming the incident was risk-free.

Describe a time you aligned stakeholders on a difficult technical trade-off.

What to coverThe role partners with product, data science, platform engineering, and business stakeholders while communicating architectural decisions. Suggested preparation: use a real situation to show how you made competing priorities understandable, what you did to reach a decision, and the result.

Tell me about a time you made it safer for a team to challenge an assumption or propose a different approach.

What to coverThe posting explicitly calls for psychological safety, curiosity, and calculated technical risks. Suggested preparation: describe the initial situation, the actions you took to invite and evaluate disagreement, and what happened as a result.

Sharpen your knowledge

Topics to prepare

Inference architecture and token economics
The role calls for model routing and decisions about token cost, latency, context limits and capability. Revision exercise: compare two hypothetical routing designs against a stated latency budget and explain the trade-offs you would bring to an architecture review.
Context engineering, RAG and evaluation
The posting requires context pipelines, RAG, prompt architecture and evaluation frameworks. Revision exercise: sketch how an assistant would retrieve permitted internal information, assemble context and measure answer quality; identify where irrelevant or stale context could cause failure.
Agent orchestration choices
The role requires deep experience with at least 2–3 agent frameworks and judgment about tool use and multi-agent coordination. Revision exercise: compare two listed frameworks for a bounded assistant workflow, explaining when a simpler workflow would be preferable.
AI security and responsible governance
The posting emphasizes prompt injection, data exfiltration, OAuth or JWT, least privilege, guardrails and auditability across regulated markets. Revision exercise: threat-model an assistant that accesses sensitive internal data and identify controls, tests and audit evidence. Do not assume a particular regulatory rule or undisclosed policy detail.
Technical and people leadership
The lead will set standards, mentor 2–3 developers, review code, lead incidents and explain decisions to stakeholders. Revision exercise: outline how you would resolve an architecture disagreement, coach the team through the decision and run a blameless post-mortem after a production failure.

Skills to revise

Build an asynchronous Python API
The posting requires advanced Python, FastAPI or Flask, async patterns and scalable API design. Suggested exercise: implement a small assistant endpoint with input validation, timeout handling and a mocked inference call; explain how it could integrate with the listed AWS Lambda and API Gateway services.
Implement and measure inference routing
Hands-on inference-platform expertise, including AWS Bedrock and LiteLLM, is a core requirement. Suggested exercise: prototype or pseudocode a routing layer, then record token usage, response time and fallback behavior for contrasting requests.
Test a retrieval and prompt pipeline
Production context engineering and RAG are required. Suggested exercise: use a small set of synthetic internal documents to build a retrieval-and-prompt flow, then create test questions that expose missing evidence, irrelevant retrieval and unsupported answers.
Prototype bounded agent tool use
The role involves agent frameworks, tool-use design and multi-agent orchestration. Suggested exercise: model the same bounded workflow in two frameworks named in the posting, documenting tool permissions, hand-offs, failure handling and the reason for your choice.
Exercise guardrails and access controls
The posting requires production guardrails, content filtering and AI-specific security. Suggested exercise: write tests for prompt-injection attempts, unauthorized retrieval and sensitive-data leakage; show where authentication, least-privilege checks, filtering and audit records belong.
Review and teach production engineering practices
The lead conducts code reviews, establishes standards and validates AI-generated code; proficiency with Claude Code, GitHub Copilot or OpenCode is required. Suggested exercise: review a sample AI-assisted Python change for correctness, security and maintainability, then draft constructive feedback and an incident follow-up action.

Your preparation checklist

Map evidence to the core requirements
Prepare a one-page index of real examples covering Python backend development, AI/ML or agentic work, inference platforms, RAG, guardrails, team leadership and AI coding tools. Note what you personally did and what can be demonstrated; keep desirable skills separate.
Rehearse a production AI project walkthrough
Prepare one real project from requirements through deployment: architecture, your decisions, FastAPI or Flask and async patterns if applicable, API design, evaluation, operational results and lessons learned. Clearly distinguish your work from the team’s.
Sketch an enterprise assistant architecture
As interview practice, draw a hypothetical assistant using internal data, with context retrieval, backend APIs, inference and a user interface. Explain routing between models or platforms such as Bedrock and LiteLLM, including token cost, latency and context-window trade-offs; do not present the sketch as Flutter’s existing design.
Compare agent approaches and evaluation methods
Prepare a short decision table for 2–3 frameworks you know well, covering tool use, orchestration and when a simpler pattern is preferable. Add a proposed test set for retrieval quality, prompt behavior and agent failures as a preparation exercise.
Build a safety and auditability review
For the hypothetical design, list prompt-injection and data-leakage threats, authentication and least-privilege controls, sensitive-data handling, content filtering, audit records and tests. Frame policy details and market-specific obligations as questions rather than assumed facts.
Prepare pod-leadership examples
Select real examples of mentoring, code review, technical standards, cross-functional decisions and incident follow-up. For each, be ready to explain the situation, your actions, how others contributed and the outcome; include a blameless post-mortem example if available.
Practice explaining one trade-off to two audiences
Give a brief technical architecture explanation, then a plain-language version for a product or business stakeholder. Include how you would validate AI-generated code before accepting it, reflecting the role’s communication and AI-tool requirements.
Write focused questions for Flutter
Bring questions about the pod’s initial priorities, existing assistant and agent architecture, access to internal data, evaluation and incident practices, how Responsible AI reviews operate, and which decisions this lead will own.

Availability last checked: 5 Nov 2026. Status can change after a check; confirm on the employer’s website. Report an issue · Our checking policy

KEEP EXPLORING

Similar AI jobs

Related skills and specializations in India. Matched to this role, not your profile.

Explore more jobs

Finding similar opportunities…