New opportunity

AI / ML Engineer

Accenture · Hyderabad, India

About this role

Accenture’s AI / ML Engineer posting in Hyderabad describes a full-stack AI and agentic-systems role. The engineer designs, builds and ships production applications with LLM-powered and agentic features, working with architecture and AI leads to deliver secure, scalable enterprise products. The project role also covers production-ready AI applications using cloud AI services or on-premises pipelines, potentially including GenAI models, deep learning, chatbots and image processing.

Responsibilities

Build React/Next.js front ends and Python or Node.js back ends that expose AI features to users. Integrate agentic orchestration for validation, evaluation and workflow automation, and build RAG pipelines using embeddings, vector search and context construction.
Deliver RESTful and microservice APIs with authentication, role-based access control and API-gateway patterns for multi-tenant products. Implement asynchronous, queue-based processing and integrate real-time voice or avatar capabilities.
Design relational and NoSQL data layers, including schemas, indexes and optimized queries. Deploy containerized applications on cloud infrastructure; apply encryption, secrets management, single sign-on and audit logging. Build internal automation, use AI-assisted development tools and contribute reusable technical work.

Requirements

The posting lists a minimum of 5 years’ experience for the project role; its detailed full-stack description specifies 6–8 years, including 6+ years of professional software engineering. It requires production experience with an agentic AI framework such as CrewAI, tool or function calling, multi-step orchestration, prompt engineering and RAG patterns. Candidates should be able to integrate proprietary and open-source LLMs; build front ends using React, Next.js or Vite, HTML5/CSS3 and Tailwind CSS or an equivalent library; and develop APIs using Python frameworks and/or Node.js/Express. Docker, Kubernetes, Azure integration and compute services or equivalent AWS/GCP stacks, PostgreSQL plus MySQL, MongoDB or DynamoDB, and production authentication, RBAC and multi-tenant API experience are required. The posting specifies 15 years of full-time education and lists a bachelor’s degree in Engineering, Computer Science or a related field, or equivalent experience.

Preferred

Graph databases or knowledge-graph applications; multi-cloud production deployments; CI/CD; conversational voice or avatar integration; sensitive-data handling; low-code platforms; and Figma. MCA or M.Tech is a plus.

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

Skills for this role

Data ScienceGenerative AIAgentic AILarge Language ModelsCrewAIRetrieval-Augmented GenerationPrompt EngineeringEmbeddingsVector SearchTool CallingMulti-Agent OrchestrationReactNext.jsViteHTML5CSS3Tailwind CSSPythonFastAPIFlaskDjangoNode.jsExpressREST APIsMicroservicesRBACDockerKubernetesAzure Logic AppsAzure Function Apps Windows Azure AI Foundry

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

Ship full-stack AI applications
The role calls for production applications that expose LLM and agentic features through React/Next.js front ends and Python or Node.js back ends, working with architecture and AI leads.
Operationalize agents and retrieval
The posting emphasizes production agentic orchestration, tool or function calling, and RAG pipelines using embeddings, vector search, and context construction to ground features in enterprise data.
Build secure enterprise APIs
RESTful and microservice APIs must support authentication, RBAC, API-gateway patterns, and multi-tenant products. The role also calls for encryption, secrets management, SSO, and audit logging.
Own deployment, data, and throughput
Responsibilities include relational and NoSQL schema and query design, queue-based asynchronous processing for high concurrency, and deploying and operating containerized applications on cloud infrastructure.

Likely challenges to think through

Reliability versus agent flexibility
Preparation hypothesis: multi-step workflows may be harder to validate than fixed application logic. Prepare to explain how tool calls, automated evaluation, and RAG grounding can be tested and monitored without assuming the posting specifies a particular evaluation process.
Tenant isolation versus feature access
Preparation hypothesis: exposing AI features through shared APIs creates tension between convenient access and strict authorization. Prepare an architecture example showing where authentication, RBAC, tenant boundaries, and audit logging would be enforced.
Responsiveness versus workload cost
Preparation hypothesis: LLM calls, retrieval, and high-concurrency requests may compete with interactive responsiveness. Prepare to discuss when to use queues, how to design data access, and what operational signals would guide scaling; the posting does not specify performance targets.

Practice your answers

Technical practice

Suggested practice: How would you design a full-stack application that exposes an LLM-powered feature?

What to coverThe posting calls for React or Next.js front ends and Python or Node.js back ends in production applications. Explain the user-to-API flow, where model integration belongs, and how you would handle failures without exposing sensitive implementation details to the browser.

Suggested practice: How would you structure a multi-step agentic workflow with tool calling?

What to coverThe role includes production agentic orchestration for validation, evaluation and workflow automation. Discuss tool boundaries, state management, safeguards against invalid actions, and how you would assess whether orchestration improves on a simpler workflow.

Suggested practice: How would you build and evaluate a RAG pipeline over enterprise data?

What to coverThe posting specifies embedding generation, vector search and context construction. Walk through those stages, then explain how you would investigate irrelevant retrieval or answers that are not grounded in the retrieved context.

Suggested practice: How would you choose and integrate an LLM for a product feature?

What to coverThe role calls for working across proprietary and open-source providers and using prompt engineering. Compare candidate models against the feature’s quality, latency, cost and deployment constraints, and describe how you would test prompts before release.

Suggested practice: How would you design a multi-tenant REST API for AI features?

What to coverThe posting specifies microservice APIs, authentication, RBAC and API-gateway patterns. Explain how you would enforce tenant isolation and permissions at the API and data layers, including how you would test for cross-tenant access.

Suggested practice: When would you move an AI task to queue-based asynchronous processing?

What to coverThe responsibilities include asynchronous processing for high-concurrency workloads. Discuss request latency, retries, duplicate work, job status and failure handling, including the trade-off against a simpler synchronous endpoint.

Suggested practice: How would you design and troubleshoot the application data layer?

What to coverThe role covers relational and NoSQL stores, schema design, indexing and query optimization. Explain how access patterns would guide your store and schema choices, and how you would diagnose a slow production query.

Suggested practice: How would you deploy and operate a containerized AI application?

What to coverThe posting names Docker, Kubernetes and Azure integration or equivalent cloud stacks; CI/CD is preferred. Describe a deployment approach, health and scaling checks, and how you would detect and roll back a problematic release.

Suggested practice: How would you apply enterprise security controls to an LLM-backed application?

What to coverThe responsibilities name encryption, secrets management, SSO and audit logging. Explain where each control applies and how you would balance useful audit records with limiting exposure of sensitive inputs or outputs.

Suggested practice: What would you consider when adding real-time voice or avatar interaction?

What to coverReal-time voice and avatar integration appears in the responsibilities. As a preparation suggestion, discuss latency, interruptions, streaming failures and fallback behaviour, and how those concerns differ from a text-only interaction.

Behavioural practice

Suggested practice: Tell me about partnering with technical leads to deliver a complex feature.

What to coverThe role involves working with architecture and AI leads to ship enterprise-ready products. Use a real situation, your actions to resolve design or ownership questions, and the resulting delivery outcome.

Suggested practice: Describe a production problem you diagnosed across application layers.

What to coverThe posting spans front ends, APIs, AI features and cloud operations. Give a real example with the symptoms, how you narrowed down the cause, what you changed, and the result.

Suggested practice: Describe a time you balanced delivery speed with security or reliability.

What to coverSecure, scalable production delivery is central to the role. Explain a real trade-off, the risks you raised, the action you took with others, and the outcome rather than claiming a risk-free decision.

Suggested practice: Tell me about automation you built to remove manual effort.

What to coverBuilding internal automation tooling is a stated responsibility. Describe the original task, your implementation and its measured or observed result, including any maintenance trade-off.

Suggested practice: Describe a reusable technical contribution from product work.

What to coverThe posting asks for reusable IP and technical innovation. Use a real example to show the initial need, how you made the work reusable, and what changed for other users or teams.

Sharpen your knowledge

Topics to prepare

Agentic workflow design
Map a multi-step validation workflow, identifying tool calls, handoffs, failure points and evaluation checks. The posting requires production agentic orchestration for validation, evaluation and automation.
RAG and model selection
Explain how embeddings, vector search and context construction ground an answer, then compare when a proprietary or open-source LLM might suit the feature. These are stated requirements for LLM-backed applications.
Prompt engineering and AI evaluation
Draft a prompt for an enterprise-data question and define checks for groundedness and incorrect answers. The posting calls for prompt engineering and agentic evaluation.
Multi-tenant API security
Trace a request through authentication, RBAC and an API gateway, noting where tenant access must be enforced. The role ships secure, multi-tenant enterprise APIs.
Asynchronous and data-layer design
Sketch a queue-based request flow and explain schema, index and query choices for its relational and NoSQL data. Both high-concurrency processing and data-layer design appear in the responsibilities.
Production deployment and security
Diagram a containerized deployment with orchestration, cloud compute, secrets, encryption, SSO and audit logging. Docker, Kubernetes and Azure services or equivalent AWS/GCP stacks are listed requirements.

Skills to revise

Build a full-stack AI feature
As a revision exercise, connect a React or Next.js interface to a Python or Node.js API that returns an LLM-backed result. The role builds and ships these end-to-end applications.
Implement an agent workflow
Practice a small multi-step workflow using CrewAI or an equivalent framework, with a tool call and a validation step. Production framework integration and tool/function calling are required.
Construct a RAG pipeline
Practice generating embeddings, retrieving through vector search and assembling context for an LLM request; inspect what the retrieved context supports. These are the posting’s named RAG components.
Implement a protected asynchronous API
Practice a REST endpoint with authentication, RBAC and tenant-scoped access, plus a queue-based operation. This combines stated production API and high-concurrency responsibilities.
Tune a database access path
Practice designing a PostgreSQL schema and index for an API query, then explain a corresponding choice in MySQL, MongoDB or DynamoDB. The posting requires PostgreSQL plus one of those stores and calls out query optimization.
Package and deploy an application
Practice containerizing a small front-end and API with Docker, then outline its Kubernetes deployment and integration with Azure services or an equivalent AWS/GCP stack. These are specified cloud and DevOps requirements.

Your preparation checklist

Prepare a production project walkthrough
The posting emphasizes shipped full-stack AI applications. Prepare one real project walkthrough showing the React or Next.js interface, Python or Node.js APIs, your contributions, deployment, and operational results.
Explain an agentic workflow
The role calls for production agentic orchestration, tool or function calling, and multi-step workflows. Diagram a real implementation, including tool boundaries, validation, evaluation, and failure handling.
Map a RAG feature end to end
Prepare an example covering embedding generation, vector search, context construction, and how you assessed whether retrieved content grounded the LLM response.
Practice a multi-tenant system design
As a preparation exercise, sketch an AI application with REST APIs, authentication, RBAC, an API gateway, and queue-based processing. Explain tenant isolation, concurrency, and security trade-offs; this is a suggested exercise, not a stated interview task.
Gather deployment and data-layer evidence
Select concrete examples you can explain of Docker and Kubernetes, Azure services or equivalent AWS/GCP stacks, and PostgreSQL alongside another listed database. Be ready to discuss schema, indexing, encryption, secrets, SSO, and audit logging where you have direct experience.
Organize evidence against the stated qualifications
Make a brief evidence sheet for the posting’s full-stack, API, LLM-provider, and agentic-production requirements. Note that it lists a five-year minimum, a six-to-eight-year detailed role, 6+ years of software engineering, and education criteria; do not fill gaps with hypothetical experience.
Draft focused questions for Accenture
Ask which agentic and RAG features are in production, how architecture and AI leads divide responsibilities, which cloud and model stacks the team uses, and how the differing experience and education statements are applied to this role.

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…