New opportunity

AI / ML Engineer

Accenture · Hyderabad, India

About this role

Accenture seeks an AI / ML Engineer in Hyderabad to develop production-ready applications and systems using AI tools and cloud AI services. The role may apply generative AI models, deep learning, neural networks, chatbots and image processing. Machine learning is a required skill.

Responsibilities

Design and scale distributed systems that process long-running tasks across thousands of claims in parallel.
Build modular Python APIs and services that connect to external APIs, vector stores and LLM APIs. Develop event-driven microservices using AWS Lambda, S3, API Gateway and CloudWatch.
Implement robust error handling, retries and idempotent execution. Work with the orchestration lead and AI team on prompt execution, state management, memory, checkpointing and policy-driven routing.
Provide logging, tracing and metrics for observability in a serverless, cloud-native environment.

Requirements

At least 5 years of experience, including 5+ years of Python development in backend or systems engineering roles; 15 years of full-time education and a degree in Computer Science, Artificial Intelligence, Machine Learning or a related field.
Deep understanding of Python asyncio, async/await, event loops and cooperative multitasking; strong knowledge of object-oriented programming, design patterns and modular code.
Experience designing distributed systems, including task partitioning, stateful and stateless services, concurrency, parallelism and queue-based orchestration such as Amazon SQS or AWS Step Functions. Experience with REST APIs, JSON, fault-tolerant cloud services, AWS Lambda, API Gateway, S3 and IAM, plus CI/CD, production debugging and logging.
Strong communication skills and the ability to work independently and collaboratively. A Ph.D. is highly desirable.

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

Skills for this role

Machine LearningGenerative AILarge Language ModelsPythonasyncioObject-Oriented ProgrammingDesign PatternsDistributed SystemsREST APIsJSONAWS LambdaAmazon S3Amazon API GatewayAmazon CloudWatchAWS IAMAmazon SQSAWS Step FunctionsCI/CDMicroservicesVector StoresPrompt ExecutionObservabilityLoggingTracingError HandlingCommunication

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

Scale parallel claim processing
The role calls for distributed systems that handle long-running tasks across thousands of claims in parallel. Prepare to explain task partitioning, queue-based orchestration, and when to use stateful versus stateless services.
Build modular Python integrations
The job specifies Python APIs and services connecting to external APIs, vector stores, and LLM APIs, alongside strong asyncio and modular design skills. Prepare to discuss service boundaries, async execution, and maintainable interfaces.
Deliver reliable AWS microservices
The posting names event-driven services using Lambda, S3, API Gateway, and CloudWatch, with robust error handling, retries, and idempotency. Prepare a concrete design that shows how work recovers safely from failures.
Support AI orchestration
The engineer works with the orchestration lead and AI team on prompt execution, state management, memory, checkpointing, and policy-driven routing. Prepare to explain how these concerns fit into production services, without assuming ownership of the AI models.
Make production behavior visible
The role requires logging, tracing, metrics, CI/CD, and production debugging in a cloud-native setup. Prepare to show how these practices help diagnose failures across services and deployments.

Likely challenges to think through

Balancing throughput and execution control
Preparation hypothesis: processing thousands of long-running tasks may make it difficult to increase concurrency without overwhelming downstream services or losing track of work. Prepare to compare partitioning, queues, concurrency limits, and checkpointing, including what each costs in complexity.
Retrying without repeating effects
Preparation hypothesis: failures around external APIs and LLM calls may require retries while making duplicate execution unsafe. Prepare to describe idempotency keys, persisted state, and which operations can or cannot be retried automatically.
Tracing a task across service boundaries
Preparation hypothesis: an event-driven serverless workflow may be hard to debug when one claim passes through multiple services and AI orchestration steps. Prepare to explain correlation identifiers and useful logs, traces, and metrics, while accounting for their operational overhead.

Practice your answers

Technical practice

How would you partition long-running work across thousands of claims?

What to coverThe role calls for distributed systems that process long-running tasks across thousands of claims in parallel. Suggested preparation: explain partitioning, concurrency limits and how you would track progress without losing work.

When would you use asyncio in a Python service?

What to coverThe posting specifically names asyncio, event loops and cooperative multitasking. Suggested preparation: distinguish I/O-bound concurrency from CPU-bound parallelism, and explain how blocking calls can affect an event loop.

How would you choose between a queue and a workflow orchestrator for these tasks?

What to coverThe posting cites queue-based orchestration, including SQS and Step Functions. Suggested preparation: compare how each approach handles task sequencing, long-running work, state and failure recovery without assuming either is required for every task.

How would you make retries safe in a claim-processing service?

What to coverThe role explicitly calls for error handling, retries and idempotent execution. Suggested preparation: explain how you would identify duplicate work, handle partial failures and decide which errors merit a retry.

How would you structure modular Python services that integrate several external systems?

What to coverThe posting names modular APIs, object-oriented design, factories and dependency injection. Suggested preparation: describe service boundaries, replaceable integrations and how those choices support testing and maintenance.

How would you design an API integration involving an LLM API and a vector store?

What to coverThe role includes Python services that interface with external APIs, vector stores and LLM APIs. Suggested preparation: discuss REST and JSON contracts, timeouts, error handling and how you would verify responses before downstream use.

How would you build and release an event-driven service using the AWS services named in the posting?

What to coverThe posting names Lambda, S3, API Gateway, IAM and CI/CD. Suggested preparation: explain the role of each applicable service, permission boundaries and how you would validate and deploy a change safely.

How would you support prompt execution across a long-running workflow?

What to coverThe role involves collaborating on state management, memory, checkpointing and policy-driven routing. Suggested preparation: explain what state would need to persist, when to checkpoint and how routing decisions could be made inspectable and recoverable.

How would you diagnose failures in a serverless workflow?

What to coverThe posting calls for logging, tracing, metrics and production debugging, including CloudWatch. Suggested preparation: identify what you would measure and correlate across services to locate a failed or slow task while limiting noisy logs.

How would you evaluate whether an ML or GenAI component is production-ready?

What to coverMachine learning is the required skill, and the role describes production-ready applications that may use GenAI models. Suggested preparation: discuss evaluation against the application’s intended task, failure cases and the trade-off between model quality and operational reliability.

Behavioural practice

Tell me about a time you coordinated work across engineering and AI stakeholders.

What to coverThe role calls for collaboration with an orchestration lead and an AI team. Suggested preparation: use a real situation, your actions to resolve a dependency or disagreement, and the resulting outcome.

Describe a time you explained a complex technical decision to a diverse audience.

What to coverThe posting emphasizes conveying complex concepts to people with different backgrounds. Suggested preparation: give a real situation, how you adapted the explanation and what the audience was able to decide or do afterward.

Tell me about a time you took ownership of an ambiguous technical problem.

What to coverThe role calls for independent, proactive work in a dynamic environment. Suggested preparation: describe the situation, how you clarified priorities and acted, and the result rather than claiming a particular level of autonomy.

Describe a production-like debugging problem you worked through with others.

What to coverThe posting names production debugging and collaborative work. Suggested preparation: use a real situation to show how you gathered evidence, communicated during the investigation and assessed the result of your actions.

Sharpen your knowledge

Topics to prepare

Machine learning and GenAI in an application
Posting: Machine Learning is the must-have skill; the role may apply GenAI models. Suggested revision: sketch how an ML component and an LLM API could each contribute to claim processing, and explain how you would check their outputs. This prepares you to discuss the advertised AI/ML application work.
Python asynchronous execution
Posting: Deep understanding of asyncio, async/await, event loops and cooperative multitasking is required. Suggested revision: trace an event loop handling several slow API calls and explain when concurrency does—and does not—provide parallelism. This relates to long-running claim tasks.
Distributed task orchestration
Posting: The role involves partitioning thousands of claims and designing stateful and stateless services with queue-based orchestration. Suggested revision: diagram task partitioning and state ownership using SQS or Step Functions, then explain how work resumes after an interruption.
AWS service responsibilities
Posting: Lambda, S3, API Gateway, CloudWatch and IAM appear in the service requirements. Suggested revision: draw an event-driven request flow and identify each service’s role, access boundaries and failure points. This supports discussion of the specified cloud-native architecture.
LLM execution state
Posting: The engineer supports prompt execution, memory, checkpointing and policy-driven routing with the orchestration lead and AI team. Suggested revision: walk through a multi-step LLM API call, noting what state must be retained and where a checkpoint would help recovery.
Fault tolerance and observability
Posting: Retries, idempotency, logging, tracing and metrics are explicit responsibilities. Suggested revision: analyze a timed-out claim task that might have completed, and explain how to avoid duplicate effects and diagnose its outcome.

Skills to revise

Build a modular Python REST service
Posting: Modular Python APIs, REST, JSON, OOP, design patterns, factories and dependency injection are specified. Suggested exercise: write a small JSON endpoint with an interchangeable external-API client and test error responses.
Implement asynchronous API calls
Posting: Python asyncio and services connecting to external and LLM APIs are specified. Suggested exercise: write an async function that handles several independent calls, sets timeouts and records which calls failed.
Map an event-driven AWS workflow
Posting: Event-driven microservices use Lambda, S3 and API Gateway; SQS and Step Functions are orchestration examples. Suggested exercise: draft a request-to-task workflow with JSON payloads and note where IAM permissions are needed.
Code safe retries and idempotency
Posting: Robust error handling, retry logic and idempotent execution are responsibilities. Suggested exercise: implement a task handler that receives the same claim task twice, retries a transient API failure and avoids repeating a completed action.
Instrument and debug a service
Posting: CloudWatch, logging, tracing, metrics and production-like debugging are specified. Suggested exercise: add a claim-task identifier to structured logs, record task outcomes and trace a simulated failure across service calls.
Practice a CI/CD change
Posting: CI/CD pipeline skill is required. Suggested exercise: outline checks and deployment steps for a small Python API change, then explain how you would investigate a failure observed after deployment.

Your preparation checklist

Map evidence to the stated requirements
Prepare a one-page matrix with examples of machine learning, 5+ years of Python backend or systems development, distributed systems, AWS, and production debugging. Note the stated 15 years of full-time education and related-degree requirements; the posting calls a Ph.D. desirable, not required.
Prepare a production-system walkthrough
Choose a relevant project, if available, and outline the problem, your contributions, architecture, deployment, failure handling, and measured results. Clearly distinguish what you built from team work.
Practice a claims-processing design exercise
As an interview exercise, sketch how to partition long-running work across thousands of claims. Explain concurrency versus parallelism, stateful versus stateless components, queue-based orchestration, retries, idempotency, and recovery assumptions.
Review Python service design
Prepare a small code example or design sketch showing asyncio and async/await, modular REST and JSON interfaces, and an appropriate use of dependency injection or a factory. Be ready to explain event-loop behavior and testing choices.
Trace an event-driven AWS workflow
Draw a proposed flow using Lambda, API Gateway, S3, and, where useful, SQS or Step Functions. Annotate IAM boundaries, error paths, CI/CD checks, and how CloudWatch logs, traces, and metrics would support debugging.
Explain AI integration boundaries
Prepare a design sketch for connecting a Python service to an LLM API or vector store. Discuss how you would coordinate prompt execution, state, memory, checkpointing, and policy-driven routing with the orchestration lead and AI team; these are responsibilities in the posting, not a specified implementation.
Bring targeted questions
Ask which parts of claims orchestration this role owns, what production scale and reliability measures matter, how the AI and orchestration teams divide decisions, and which AWS components are already in use.

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…