New opportunity

AI Developer

Flutter Entertainment · Hyderabad, India

About this role

Flutter Entertainment’s AI & Automation team is hiring an AI Developer to build enterprise AI assistants and agent platforms that use internal data to improve productivity and decision-making across its sports betting and gaming operations. The role is based in Hyderabad on a hybrid schedule of two office days per week.

Responsibilities

Design and evolve AI assistants and multi-agent systems integrated with internal applications, data sources and workflows. Build tool-using agents, multi-step reasoning systems and orchestration layers.
Integrate LLM inference through LiteLLM and AWS Bedrock. Design retrieval, memory and context pipelines, balancing model capability, context length, latency and token cost.
Deliver end-to-end applications, from model integration and backend services to user interfaces. Build integrations using AWS Bedrock, Lambda, API Gateway, REST and streaming APIs, and Model Context Protocol (MCP).
Implement guardrails and model constraints aligned with the company’s Responsible AI Policy and obligations across 20+ regulated markets. Address prompt injection, data leakage, authentication, access control and sensitive-data handling.
Use AI coding assistants, validate generated code, and collaborate with product managers, data scientists and engineers.

Required qualifications

Bachelor’s degree in Computer Science, AI or a related STEM field and 3–4 years of hands-on AI/ML or software development experience.
Python proficiency, including FastAPI or Flask, asynchronous programming and maintainable coding practices. Practical experience with AWS Bedrock and/or LiteLLM, model routing and API integration.
Understanding of RAG, prompt structuring, context windows, inference trade-offs and at least one agent framework such as LangChain, LangGraph, Strands or Google ADK. Familiarity with production guardrails, responsible AI, AI security risks, OAuth, JWT, Git, the software development lifecycle and cross-functional communication.

Highly desirable: Full-stack experience with React and TypeScript; broader experience with agent frameworks including CrewAI; production RAG using Pinecone, pgvector or OpenSearch; MCP knowledge; and experience in gaming, sports betting, financial services or other regulated environments.

The posting describes the position as permanent. Benefits include learning resources and a development fund, internal mobility, health and life insurance, wellness support, flexible leave, meals, cab and home-office allowances, retirement-related contributions, a discounted-share plan and volunteering leave.

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

Skills for this role

PythonFastAPIFlaskAsynchronous programmingLarge language modelsLiteLLMAWS BedrockModel routingContext engineeringPrompt engineeringRetrieval-augmented generationAgent orchestrationMulti-agent systemsLangChainLangGraphStrandsGoogle ADKGuardrailsResponsible AIPrompt injection preventionOAuthJWTGitAPI designREST APIsStreaming APIsAWS LambdaAmazon API GatewayModel Context ProtocolClaude Code: important? skills literal

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

Build enterprise assistants and agents
Posting: Design and evolve assistant and multi-agent platforms that connect internal applications, data sources and workflows. Prepare to explain how you would structure tool use, multi-step reasoning and orchestration for an enterprise task.
Make informed inference and context decisions
Posting: Use LiteLLM and AWS Bedrock, model routing, retrieval, memory and context pipelines while balancing capability, latency, context length and token cost. Prepare to justify those trade-offs in a concrete design.
Design for safety and data security
Posting: Implement guardrails aligned with Flutter’s Responsible AI Policy and obligations across 20+ regulated markets; address prompt injection, data leakage, authentication and access control. Prepare to distinguish model-level constraints from application-level protections.
Deliver integrated, end-to-end applications
Posting: Own work from model integration through backend services to user interfaces, with Python, APIs and AWS integrations central to the role. Prepare to describe how components connect; React and TypeScript experience is highly desirable, not listed as required.
Own engineering quality across teams
Posting: Collaborate with product managers, data scientists and engineers, and validate code produced with AI coding assistants. Prepare to explain how you communicate design decisions and take responsibility for maintainable, reviewed code.

Likely challenges to think through

Useful access without excessive exposure
Preparation hypothesis, not a confirmed problem: An assistant using internal data and tools may need broad enough context to help users while preventing unauthorized retrieval or leakage. Prepare a design rationale covering least-privilege access, sensitive-data handling and prompt-injection risks.
Capability versus response time and cost
Preparation hypothesis, not a confirmed problem: Longer context, richer retrieval and more capable models may improve answers while increasing latency and token spend. Prepare to compare routing and context choices against those competing constraints.
Agent flexibility versus dependable execution
Preparation hypothesis, not a confirmed problem: Multi-step, tool-using agents can handle complex workflows but add orchestration and failure points. Prepare to explain when a simpler flow would suffice and how you would check tool outputs and handle failures.

Practice your answers

Technical practice

How would you design an enterprise AI assistant that uses internal applications and data sources?

What to coverSuggested preparation: Describe the boundaries between the interface, backend, model integration, retrieval and internal workflows. Explain how you would control access to data and measure whether the assistant improves productivity or decision-making.

How would you select and route models using AWS Bedrock or LiteLLM?

What to coverSuggested preparation: Compare model capability, latency, reliability and cost for different requests, then explain a routing approach and its fallback behavior. Address how you would evaluate routing decisions rather than assuming one model fits every task.

How would you build and troubleshoot a RAG context pipeline for internal data?

What to coverSuggested preparation: Cover retrieval, prompt structure, context-window limits and when conversational memory is useful. Explain how you would investigate irrelevant retrieval or unsupported answers; vector stores such as pgvector, Pinecone and OpenSearch are desirable examples in the posting, not mandatory choices.

How would you reduce token cost and latency without losing answer quality?

What to coverSuggested preparation: Discuss context selection, model choice and response length as trade-offs, including cases where a larger context is justified. Describe what you would measure to compare cost, latency and answer quality.

When would you use a tool-using agent or multi-agent orchestration?

What to coverSuggested preparation: Walk through how an agent would choose tools, pass results between steps and stop or recover when a step fails. Use a framework you know, such as LangGraph or LangChain, and explain why a simpler workflow might be preferable.

How would you implement and test guardrails for an enterprise AI assistant?

What to coverSuggested preparation: Address model constraints, content filtering and handling of unsafe or unreliable outputs in a regulated setting. Explain how you would test both blocked and permitted cases while aligning decisions with the Responsible AI Policy mentioned in the posting.

How would you defend an agent connected to internal tools against prompt injection and data leakage?

What to coverSuggested preparation: Distinguish untrusted retrieved content from authorized instructions, and discuss tool permissions, least-privilege access and sensitive-data handling. Include where OAuth or JWT authentication fits and how you would test attempted exfiltration.

How would you build a maintainable Python API for an AI application with concurrent requests?

What to coverSuggested preparation: Explain an async approach in FastAPI or Flask, including timeouts, error handling and calls to model or data services. Describe code organization and tests that would make the service maintainable.

How would you integrate a model-backed service with AWS and other application interfaces?

What to coverSuggested preparation: Describe how Bedrock, Lambda and API Gateway could connect to REST or streaming APIs, including failure handling. Explain where MCP could standardize agent tool or context integration without treating it as a requirement for every integration.

How would you validate AI-generated code in an end-to-end AI application?

What to coverSuggested preparation: Discuss reviewing generated code, testing behavior and security, and retaining ownership of changes through Git and the development lifecycle. Include how you would check that backend behavior and a user-facing interface work together; React and TypeScript are listed as desirable, not required.

Behavioural practice

Tell me about a time you aligned product, data science and engineering stakeholders on a technical solution.

What to coverSuggested preparation: Use situation, action and result to show how you clarified different needs and communicated a technical trade-off. Explain the outcome using evidence you actually have, rather than assuming a business impact.

Describe a time you owned an application problem from design through delivery.

What to coverSuggested preparation: Set out the situation, your actions across the relevant components, and the result. Distinguish your contribution from the team's and explain how you handled a delivery obstacle.

Tell me about a time you raised a security, safety or data-handling concern during development.

What to coverSuggested preparation: Describe the situation, what risk you identified, the action you took with others and the result. Focus on your reasoning and communication; experience in Flutter's specific regulated markets is not assumed.

Describe a time you evaluated an emerging AI tool or changed your engineering approach.

What to coverSuggested preparation: Use situation, action and result to explain what prompted the evaluation and how you tested the tool's usefulness or limitations. If your example involves an AI coding assistant, address how you validated its output.

Sharpen your knowledge

Topics to prepare

Context engineering and RAG
The posting requires understanding of retrieval, prompt structure, memory and context-window management. Revision exercise: sketch a context pipeline for an internal-data question, then explain what you would retrieve, retain from earlier turns and omit when the context window is tight.
Model routing and token economics
The role calls for decisions across model capability, latency, token cost and context limits. Revision exercise: compare two hypothetical inference routes for a short query and a long-document query; explain your routing choice and what you would measure.
Agent orchestration patterns
The posting specifies tool-using, multi-step and multi-agent systems, with knowledge of at least one named agent framework. Revision exercise: diagram an assistant that calls an internal tool, identifying where state is held, when another agent would help and how a failed tool call is handled.
Responsible AI and security boundaries
Guardrails, prompt injection, data leakage, OAuth, JWT and least-privilege access are stated needs for work across regulated markets. Revision exercise: trace an untrusted retrieved document through an assistant and identify authorization checks, output constraints and points where sensitive data could escape.
Enterprise integration choices
The role includes internal application integrations, REST and streaming APIs, AWS services and MCP. Revision exercise: draw a request flow from a user interface through an API to an authorized internal data source; explain when streaming or MCP would be useful rather than assuming either is required for every integration.

Skills to revise

Build a maintainable asynchronous Python endpoint
The posting asks for Python, FastAPI or Flask, async patterns and API design. Practice implementing an endpoint that calls an inference API, handles timeout and error responses, and separates request handling from integration code.
Integrate and route LLM calls
Practical AWS Bedrock and/or LiteLLM experience, model routing and API integration are explicit requirements. Practice configuring a call through one of those platforms, recording latency and token usage, and explaining a fallback or routing decision. Lambda and API Gateway are also named integration services.
Implement a tool-using agent
The posting requires working knowledge of at least one of LangChain, LangGraph, Strands or Google ADK. With one framework, practice an agent that selects a permitted tool, passes structured inputs and handles a tool failure; this mirrors the advertised orchestration work.
Assemble and inspect a retrieval pipeline
Context pipelines and RAG are explicit; Pinecone, pgvector and OpenSearch experience is highly desirable, not required. Practice retrieving from a small, non-sensitive document set, inspecting irrelevant results and revising what enters the prompt.
Test access controls and guardrails
The posting calls for safe handling of enterprise data, authentication and production guardrails. Practice tests in which a user lacks access to a retrieved item and an item contains an instruction to reveal data; check that the assistant neither uses unauthorized content nor follows that instruction.
Validate AI-assisted code with Git
The role explicitly mentions AI coding assistants, ownership of generated code, Git and collaborative engineering. Practice using one named assistant, such as GitHub Copilot, to draft a small API change; review the diff, test the error paths and commit only the code you have verified.

Your preparation checklist

Map your evidence to the role
Create a one-page list of actual examples covering the posting’s Python, FastAPI or Flask, async programming, LLM inference, RAG and agent-framework requirements. Mark React, TypeScript, vector databases and MCP as desirable rather than required.
Rehearse an agent project walkthrough
Prepare a diagram and short explanation of a project you actually worked on, if available: the problem, tool use, orchestration, internal-data integration, your contribution and measured results. Do not imply it was a Flutter project.
Practice a context-pipeline design
Sketch a hypothetical enterprise assistant using retrieval, prompt structure and memory. Explain how you would manage context limits and evaluate answer quality; label the design as a preparation exercise.
Compare inference and integration choices
Prepare a decision table for model capability, routing, token cost and latency using AWS Bedrock and/or LiteLLM. Add a simple API sketch showing where Python services, REST or streaming APIs, and relevant AWS components would fit.
Threat-model the assistant
Write a brief risk-and-control table for prompt injection, data leakage, sensitive data, OAuth or JWT authentication, least-privilege access and output guardrails. Tie the discussion to the posting’s Responsible AI and regulated-market responsibilities without assuming its internal policy details.
Show how you validate delivered code
Select a real example that demonstrates maintainable Python, tests, Git-based collaboration and ownership of any AI-generated code. Be ready to explain what you checked and changed, not just which coding assistant you used.
Prepare a cross-functional account
Outline a real discussion with product, data science or engineering stakeholders: the decision, how you explained technical trade-offs to different audiences and the outcome. Use only results you can substantiate.
Draft questions for the team
Bring questions about the assistant platform’s current integration challenges, how the team evaluates quality against latency and cost, and how it applies guardrails across regulated markets. These are questions to ask, not assumptions about Flutter’s processes.

Availability last checked: 4 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…