New opportunity

Python GenAI

INFOSYS LIMITED · BANGALORE, India

About this role

Infosys Limited seeks a Python GenAI professional in Bangalore for its Engineering Services service line. The posting specifies 3–5 years of work experience.

Responsibilities

  • Develop, test and maintain Python applications and scripts. Support AI/ML model development, training, testing and deployment.
  • Prepare data for AI use cases through preprocessing, cleaning, validation and transformation. Help integrate machine learning models with web applications or backend services.
  • Debug and improve application performance; write clean, reusable code; document technical solutions and workflows. Contribute to proofs of concept, internal tools and innovation initiatives, while keeping current with AI, generative AI, Python frameworks and automation.

Requirements

  • Good Python programming knowledge, including object-oriented programming, data structures and algorithms; basic understanding of machine learning and AI.
  • Working knowledge of agentic AI and use of LangChain, LangGraph and MCP. Familiarity with NumPy, Pandas, Matplotlib or Seaborn, and Scikit-learn; basic SQL and database knowledge; understanding of REST APIs and JSON; exposure to Git or GitHub and knowledge of VS Code or PyCharm.
  • An eligible degree is Bachelor of Engineering, Bachelor of Technology, Bachelor of Computer Applications, Master of Technology or Master of Engineering.

Additional areas identified in the posting include deep learning basics, TensorFlow or PyTorch, LLMs, generative AI, prompt engineering, Flask or FastAPI, and model deployment concepts. Python is also listed under preferred skills.

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

Skills for this role

PythonGenerative AIMachine LearningDeep LearningLLMsPrompt EngineeringAgentic AILangChainLangGraphMCPTensorFlowPyTorchNumPyPandasMatplotlibSeabornScikit-learnSQLREST APIsJSONGitGitHubFlaskFastAPIVS CodePyCharmData preprocessingModel deploymentObject-oriented programmingData structures and algorithms

Your skill match

Checking your profile…

YOUR NEXT STEP

Get interview-ready for this role

A focused preparation guide, built around this job’s responsibilities and requirements.

✦ AI-generated guide
Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.
01

Understand the role

What matters most

  • Deliver maintainable Python applications

    The posting calls for developing, testing and maintaining Python applications and scripts, with clean, reusable code. Prepare to explain implementation choices, tests and coding standards in work appropriate to a 3–5-year role.

  • Support AI/ML development and deployment

    The role supports model development, training, testing and deployment. It also specifies working knowledge of agentic AI and use of LangChain, LangGraph and MCP. Prepare a clear account of how these components fit into an AI workflow, distinguishing hands-on work from conceptual knowledge.

  • Make data usable for AI

    Preprocessing, cleaning, validation and transformation are explicit duties. Prepare to describe how data checks and transformations affect what a model can reliably consume.

  • Connect models to applications

    The posting asks for assistance integrating ML models with web applications or backend services and requires understanding of REST APIs and JSON. Prepare to explain an integration path, including input and output handling.

  • Improve and communicate technical work

    Debugging, troubleshooting, performance improvement and documentation are stated responsibilities; POCs and internal tools are also in scope. Prepare examples that separate the problem, the change made and how its effect was checked.

Likely challenges to think through

  • Balancing POC speed with maintainability

    A likely trade-off, not a stated employer problem: POCs can favor quick experimentation, while the role also requires tested, reusable Python code. Prepare to explain what you would validate early and what you would refactor or document before continued use.

  • Tracing failures across data, model and service boundaries

    Because the duties span data preparation, model testing and application integration, a poor result could have several causes. As preparation, outline how you would isolate an input-data issue from model behavior or an API integration fault rather than assuming one source.

  • Choosing depth across a broad AI toolset

    The posting combines core Python and basic ML with working knowledge of agentic AI; deep learning frameworks and web frameworks are listed as additional areas. A likely preparation challenge is discussing that breadth without overstating expertise. Prioritize concrete explanations of the stated working-knowledge areas, then label other exposure accurately.

03

Practice your answers

Technical practice

How would you structure a maintainable Python application that supports an AI feature?

What to coverThe posting calls for Python applications, reusable code, OOP, data structures and algorithms. Suggestion: Explain how you would separate data preparation, model interaction and application logic, and justify a data structure or algorithm choice.

How would you prepare and validate data before using it to train a model?

What to coverThe role includes preprocessing, cleaning, validation and transformation. Suggestion: Walk through checks for missing values, duplicates and inconsistent types, then explain how you would prevent training data from affecting evaluation results.

How would you train and test a basic machine-learning model?

What to coverThe posting asks for support with model training and testing and familiarity with Scikit-learn. Suggestion: Discuss a baseline, a suitable train/test split, a metric matched to the task and how you would investigate poor results.

How would you assess whether a prompt produces useful LLM responses?

What to coverLLMs, generative AI and prompt engineering appear under additional responsibilities. Suggestion: Describe task-specific examples, criteria for response quality and the trade-off between adding prompt detail and keeping prompts manageable.

How would you design and test a simple agentic workflow?

What to coverWorking knowledge of agentic AI and use of LangChain, LangGraph and MCP are listed requirements. Suggestion: Explain the roles of workflow steps and tools, when an explicit graph helps, and how you would check tool outputs and failure paths without assuming a particular project.

How would you expose a model through a backend service?

What to coverThe role includes integrating models with web applications or backend services and calls for REST API and JSON knowledge; Flask and FastAPI are awareness areas. Suggestion: Describe request validation, response format, error handling and what you would verify before deployment.

How would you troubleshoot a slow Python application that uses a model?

What to coverDebugging, troubleshooting and performance improvement are stated duties. Suggestion: Explain how you would measure time spent in data processing, model execution and service calls before choosing an optimization, and how you would confirm it preserves correct results.

When would you use SQL rather than Pandas during data preparation?

What to coverThe posting lists basic SQL and database knowledge alongside Pandas familiarity. Suggestion: Compare database-side filtering and aggregation with in-memory transformations, including data volume and ease of validation.

What would you check when a deep-learning model performs poorly?

What to coverDeep-learning basics and familiarity with TensorFlow or PyTorch appear under additional responsibilities. Suggestion: At a basic level, distinguish data problems from training problems and explain how you would use training and validation results to guide the next check.

How would you test and maintain a Python script used in an AI workflow?

What to coverDeveloping, testing and maintaining scripts, following coding standards, and documenting workflows are stated duties; Git or GitHub exposure is listed. Suggestion: Discuss tests for normal and invalid inputs, reviewable changes and documentation that helps someone reproduce the workflow.

Behavioural practice

Tell me about a time you resolved a difficult application defect.

What to coverDebugging and troubleshooting are part of the advertised work. Suggestion: Use situation, action and result to explain how you narrowed down the cause, verified the fix and observed its effect.

Describe a time you worked with others to integrate a model or data-dependent feature.

What to coverThe role includes assisting with model integration into web applications or backend services. Suggestion: Give a real situation, your specific actions to agree on inputs and outputs or resolve an integration issue, and the result.

Tell me about a proof of concept where you had to decide what to test first.

What to coverThe posting mentions contributions to proofs of concept and innovation initiatives. Suggestion: Describe the situation, the experiment and criteria you chose, what you did, and the result or limitation you reported.

Describe a time your documentation helped someone maintain or understand technical work.

What to coverDocumenting technical solutions, workflows and learnings is a stated responsibility. Suggestion: Use situation, action and result to show what you documented, how you made it usable and what happened afterward.

02

Sharpen your knowledge

Topics to prepare

  • Python design and algorithms

    Posting: Python, OOP, data structures and algorithms are explicit requirements. Exercise: explain how you would structure a reusable data-processing script, choose data structures for lookup and deduplication, and compare the time costs.

  • Machine-learning lifecycle

    Posting: the role supports model development, training, testing and deployment; basic ML/AI understanding is required. Exercise: diagram a small classification workflow and explain how you would separate training from testing and identify a data-quality problem.

  • Agentic AI and orchestration

    Posting: working knowledge of agentic AI and use of LangChain, LangGraph and MCP are specified. Exercise: sketch an agent workflow with a tool call, a decision point and a failure path; explain where each named technology would fit.

  • LLMs and prompt engineering

    Posting: LLMs, generative AI and prompt engineering appear under additional responsibilities. Exercise: compare two prompts for the same task and explain how you would judge whether the outputs followed the instructions. Treat this as preparation for an additional area, not a separate stated requirement.

  • Data and database fundamentals

    Posting: preprocessing, cleaning, validation and transformation are responsibilities; basic SQL and database knowledge are required. Exercise: describe checks for missing values and duplicates, then outline a SQL query to select and aggregate records before model use.

  • Service integration and deployment concepts

    Posting: the role assists with backend or web integration, requires REST API and JSON understanding, and lists model deployment concepts as an additional area. Exercise: trace a JSON request through validation, model inference and a response; identify where errors should be handled.

Skills to revise

  • Build and troubleshoot a Python script

    Exercise: write a reusable Python script that validates inputs, transforms records and includes tests for invalid and empty inputs; debug a slow section. This mirrors the posted development, testing, maintenance and performance work.

  • Prepare data with the listed libraries

    Exercise: use Pandas and NumPy to clean and validate a small dataset, then use basic SQL to retrieve a subset from a database. This practices the specified data-preparation responsibilities and library and SQL knowledge.

  • Train and inspect a baseline model

    Exercise: train and test a simple Scikit-learn model on the cleaned data and plot a relevant result with Matplotlib or Seaborn. This connects the listed libraries to the role’s model-training and testing support.

  • Prototype an agent workflow

    Exercise: make a small LangChain/LangGraph proof of concept with a tool-use step and a failure path; explain how MCP could be used to make a tool available. This targets the posting’s named agentic-AI technologies and POC work.

  • Expose a JSON model endpoint

    Suggested exercise: use Flask or FastAPI to accept a JSON request, validate it and return a model result with an error response for bad input. The posting requires REST/JSON understanding and integration work; Flask/FastAPI awareness is listed as an additional area.

  • Document a change with Git

    Exercise: commit the script and a short workflow note using Git or GitHub, explaining a bug fix and how to reproduce the test. This reflects the posted exposure to version control and responsibility to document technical solutions.

04

Your preparation checklist

  • Prepare a Python project walkthrough

    Choose a real application or script you can discuss. Summarize its purpose, your contribution, object-oriented design, tests and reusable code; these align with the posted responsibilities.

  • Show a data-to-model example

    Prepare a short walkthrough of data cleaning, validation and transformation, followed by model training and testing. Use NumPy, Pandas or Scikit-learn where they genuinely featured in your work.

  • Sketch an agentic AI design

    As a preparation exercise, draw a small workflow and explain where LangChain, LangGraph and MCP could fit. The posting asks for working knowledge of agentic AI and these tools, not a particular architecture.

  • Practice an integration design exercise

    Outline how a Python model could be exposed to a web application or backend service through a REST API and JSON. Identify testing and deployment considerations; Flask or FastAPI awareness is listed as an additional area.

  • Collect debugging and delivery evidence

    Prepare one example of troubleshooting or performance improvement, with the problem, investigation and result. Have relevant tests, documentation and Git history ready to explain if available.

  • Review adjacent AI concepts

    Make brief notes explaining LLMs, prompt engineering, deep learning basics and model deployment concepts. Distinguish hands-on experience from familiarity; the posting lists these as additional areas.

  • Write focused questions for Infosys

    Prepare questions about the Engineering Services team's mix of Python development, AI/ML integration and proofs of concept, and how it uses agentic AI tools. These are questions to ask, not assumptions about the role.

AI-generated from the job information · Prepared Sep 30, 2026 (UTC)Useful preparation, not a guarantee of eligibility or an offer.

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…