New opportunity

AI Engineer

Shuru Technologies Private Limited · Bangalore North, India

About this role

Shuru Technologies Private Limited seeks an AI Engineer to build production-grade AI agents, workflows, and automation systems. The role involves taking features from problem statement through production, working in small engineering squads that ship in weekly cycles.

Responsibilities

Build and ship end-to-end AI and LLM workflows, including prompting, RAG, structured outputs, tool calling, and agent workflows.
Develop backend services using Python and FastAPI.
Build evaluations to measure accuracy and prevent regressions; debug and improve AI systems using real-world data.
Use AI coding tools such as Claude Code, Cursor, GitHub Copilot, or Codex.

Requirements

The requirements specify 2–4 years of software engineering experience; the job information section lists 2–5 years.
Strong Python and TypeScript experience, hands-on experience building with LLMs and AI agents, and experience shipping production-grade applications.
Strong ownership and the ability to work with ambiguous requirements.

Preferred

OCR or document extraction experience; LLM evaluation and benchmarking; exposure to enterprise workflows, ERP, finance, or automation; or open-source projects or independently built AI products.

This is a full-time position in Bangalore North, India. The posting mentions a competitive salary and benefits package, learning and development opportunities, and work on diverse projects, but does not state a salary amount.

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

Skills for this role

PythonTypeScriptFastAPILarge language modelsAI agentsPrompt engineeringRAGStructured outputsTool callingLLM evaluationBenchmarkingOCRDocument extractionClaude CodeCursorGitHub CopilotCodex

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 end-to-end AI workflows
The role centers on production-grade AI agents and automation, including prompting, RAG, structured outputs, and tool calling. Prepare to explain how a workflow moves from a use case to a shipped application.
Build production backend services
The posting calls for Python and FastAPI backend development, strong TypeScript experience, and experience shipping production-grade applications. Focus preparation on concrete implementation and delivery decisions rather than model behavior alone.
Measure and improve AI behavior
Building evaluations to measure accuracy and prevent regressions, then debugging with real-world data, are explicit responsibilities. Prepare examples of how results informed changes to an AI system.
Own delivery in a fast-moving squad
Engineers work in small squads that ship weekly, and this role owns features from problem statement to production. The posting also says AI coding tools are a standard part of development; prepare to explain how you use them while retaining responsibility for the result.

Likely challenges to think through

Turning ambiguity into a shippable scope
A likely challenge is choosing what to clarify, simplify, or defer when requirements are ambiguous and delivery runs in weekly cycles. Prepare a concise example of defining scope and validating decisions before release; this is a preparation hypothesis, not a stated employer problem.
Balancing agent capability with predictable outputs
Because the role includes RAG, tool calling, agents, and structured outputs, a likely trade-off is flexibility versus behavior that can be checked and maintained. Prepare to discuss where you would constrain a workflow and how you would test it; the posting does not prescribe an architecture.
Improving quality without slowing delivery
The combination of weekly shipping, real-world debugging, and regression-preventing evals suggests a potential tension between iteration speed and dependable releases. Prepare to explain how you would select meaningful test cases and use failures to guide fixes; this is an inference, not a confirmed issue at Shuru.

Practice your answers

Technical practice

Suggested practice: How would you take an AI workflow from a problem statement to production?

What to coverThe posting calls for end-to-end AI/LLM workflows and ownership through production. As preparation, explain how you would define the task, choose workflow components, test the result, and decide it is ready to ship.

Suggested practice: How would you improve a prompt that gives inconsistent results?

What to coverPrompting is explicitly part of the role. Discuss how you would inspect failures, revise instructions or examples, and check that improvements hold across representative inputs rather than a few hand-picked cases.

Suggested practice: When would you use RAG, and how would you troubleshoot poor answers?

What to coverRAG is listed among the required workflow techniques. Explain the trade-off between retrieving relevant source material and relying on the model alone, then describe how you would distinguish retrieval failures from answer-generation failures.

Suggested practice: How would you make LLM outputs usable by a backend service?

What to coverThe posting names structured outputs and production-grade applications. As preparation, cover schema design, validation, handling missing or invalid fields, and what the service should do when an output cannot be used.

Suggested practice: How would you design a reliable tool-calling agent?

What to coverTool calling and agent workflows are stated responsibilities. Explain how you would define tool boundaries, verify inputs and results, and limit or recover from incorrect actions while balancing flexibility against predictability.

Suggested practice: How would you implement an AI feature across Python, FastAPI, and TypeScript?

What to coverThe posting specifies Python and FastAPI backend services and strong TypeScript experience. Describe an API contract and how you would handle validation, errors, and changes between the service and its TypeScript consumer; the particular consumer is not specified.

Suggested practice: How would you evaluate an LLM workflow before and after a change?

What to coverBuilding evaluations to measure accuracy and prevent regressions is an explicit responsibility; benchmarking is also good to have. Discuss representative test cases, a task-appropriate measure of correctness, and how you would compare versions without hiding important failure categories.

Suggested practice: How would you debug an AI system using real-world data?

What to coverThe role calls for debugging and improving AI systems using real-world data. Explain how you would group observed failures, trace them to prompts, retrieval, tools, or service behavior, and verify that a fix does not introduce a regression.

Suggested practice: How would you approach document extraction as input to an AI workflow?

What to coverOCR or document extraction is listed as good to have, not a requirement. If relevant to your experience, discuss how you would detect extraction errors, preserve useful document structure, and evaluate their effect on downstream answers.

Suggested practice: How would you use an AI coding agent while maintaining code quality?

What to coverThe posting says engineers use AI-assisted development tools and names Cursor, Claude Code, Copilot, and Codex. Explain what work you might delegate, how you would review generated code, and what tests or checks you would run before shipping.

Behavioural practice

Suggested practice: Tell me about resolving an ambiguous engineering requirement.

What to coverThe posting calls for strong ownership and an ability to work with ambiguous requirements. Use a real situation/action/result example showing how you clarified the goal, chose a direction, and checked whether it solved the original problem.

Suggested practice: Tell me about owning a feature through production.

What to coverEnd-to-end feature ownership is an explicit responsibility. Describe a real situation, your actions from definition through release, and the result, making your own contribution clear.

Suggested practice: Tell me about delivering in a short engineering cycle.

What to coverThe posting describes small squads shipping in weekly cycles. Use a real situation/action/result example that shows how you scoped work, coordinated with others, and handled a trade-off without claiming you followed Shuru's process.

Suggested practice: Tell me about changing your approach after seeing production failures.

What to coverThe role includes debugging and improving AI systems with real-world data. Describe the situation, how you investigated and acted on the evidence, and what changed as a result.

Suggested practice: Tell me about a technical disagreement within a team.

What to coverThe posting describes work in small, dedicated squads. As preparation, choose a real situation/action/result example that shows how you weighed alternatives, listened to others, and reached a workable decision.

Sharpen your knowledge

Topics to prepare

RAG and grounded answers
The posting explicitly names RAG. Suggested revision exercise: sketch how a workflow would retrieve relevant passages from a small document set, use them in a prompt, and handle a question the documents cannot answer.
Agent workflow design
The role explicitly covers prompting, structured outputs, tool calling, and AI agents. Suggested revision exercise: diagram a request from prompt to tool selection to structured response, including what happens if the tool fails or returns unusable data.
Evaluation and regression prevention
Building evals to measure accuracy and prevent regressions is a stated responsibility. Suggested revision exercise: define a small test set, an accuracy measure, and a rule for comparing results before and after a prompt change.
Production ownership under ambiguity
The posting asks for ownership from problem statement to production and the ability to work with ambiguous requirements. Suggested revision exercise: take a vague AI feature request and write its assumptions, acceptance criteria, release checks, and questions needing clarification.

Skills to revise

Build a Python and FastAPI service
Python and FastAPI are explicitly named for backend services. Suggested revision exercise: implement an endpoint for an AI workflow with input checks, a defined response shape, and handling for a failed workflow step.
Use TypeScript in an application flow
Strong TypeScript experience is an explicit requirement. Suggested revision exercise: write a typed caller for the sample FastAPI endpoint and handle valid responses and errors. The caller is a preparation suggestion, not a specified architecture.
Implement an end-to-end LLM workflow
The job explicitly calls for hands-on LLM and agent work. Suggested revision exercise: connect prompting, retrieval from sample documents, a simple lookup tool, and a structured output into one runnable workflow.
Debug against real-world examples
The posting calls for improving AI systems using real-world data. Suggested revision exercise: collect a small set of representative inputs, classify failures, make one targeted change, and rerun the same evaluation to check for regressions.
Review AI-assisted code
The team uses AI coding tools and names Claude Code, Cursor, Copilot, and Codex. Suggested revision exercise: use one of the named tools to draft a small change, then inspect its behavior, tests, and edge cases before accepting it.

Your preparation checklist

Prepare an end-to-end AI workflow walkthrough
Use a real project if available, or label it as a hypothetical design. Show the problem, prompting or RAG choices, structured outputs, tool calls, agent behavior, and path to production; these are named in the role.
Sketch the backend implementation
Produce a small architecture diagram or API outline showing where Python and FastAPI services fit and how TypeScript is used. Be ready to explain reliability and failure handling as design considerations, not stated job requirements.
Bring evidence of evaluation and debugging
Prepare a sample eval plan with test cases, an accuracy measure, a regression check, and an example of how real-world data would guide an improvement. Distinguish results you measured from proposed tests.
Rehearse an ownership example
Outline how you would turn an ambiguous problem statement into a scoped feature, decisions, validation, and release. The posting emphasizes ownership, production delivery, and weekly shipping cycles.
Show how you use AI coding tools
Prepare a brief example of using a tool such as Cursor, Claude Code, Copilot, or Codex, including how you review and test its output. The posting names these tools but does not require expertise in every one.
Select relevant optional work
If applicable, prepare one concise artifact from OCR or document extraction, LLM benchmarking, enterprise automation, open source, or an independently built AI product. The posting lists these as good-to-have areas.
Write questions for the employer
Ask how the squad defines production readiness for agents, obtains data for evals, handles regressions, and scopes work within weekly cycles. These are questions to clarify the role, not claims about its current 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…