New opportunity

Full Stack AI Engineer

Grazitti Interactive · Remote, India

About this role

Grazitti Interactive is seeking a Full Stack AI Engineer for its SearchUnify team. The role combines frontend and backend development with AI integrations to build scalable, enterprise-grade features, particularly AI agents that can reason, plan and execute tasks. The posting lists the location as Remote, India; its heading also references Panchkula, India.

Responsibilities

  • Design, develop and maintain high-performance agentic AI features on SearchUnify. Build end-to-end AI demos and proofs of concept across frontend, backend and orchestration layers.
  • Integrate NLP models, LLMs and reasoning engines into backend services and user-facing components. Work with product managers, ML engineers and designers to turn requirements into tested code.
  • Participate in Agile Scrum activities; perform unit, integration and API testing; troubleshoot production issues and maintain code quality. Follow internal QMS and information-security procedures and report incidents.

Qualifications and skills:

  • 3–5 years of professional software development experience across frontend, backend and APIs, plus experience building AI products, particularly agentic AI and workflow-related solutions.
  • Strong JavaScript, TypeScript, Python and Node.js skills; experience with modern JavaScript frameworks, REST and GraphQL APIs, and relational and non-relational databases, including Elasticsearch, Apache Solr, MySQL, PostgreSQL, MongoDB, Redis and Citus Data.
  • Familiarity with AI/ML integration, MCPs, NLP models and APIs for AI-driven products. Experience with multiple programming languages, hands-on agentic AI work in BFSI, healthcare, telecom or retail, and knowledge of AWS or GCP are advantages.

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

Skills for this role

Agentic AIAI agentsJavaScriptTypeScriptPythonNode.jsREST APIsGraphQLElasticsearchApache SolrMySQLPostgreSQLMongoDBRedisCitus DataMCPNatural Language ProcessingLarge Language ModelsAI/ML integrationAWSGCPAgile ScrumUnit testingIntegration testingAPI testingInformation Security Controls

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

  • Build agentic features for SearchUnify

    The role centers on designing and maintaining scalable, high-performance AI agents that reason, plan and execute tasks, including workflow-related solutions.

  • Deliver across the full stack

    The posting calls for end-to-end AI demos and proofs of concept spanning frontend, backend and orchestration, alongside ongoing feature development.

  • Connect AI to services and data

    A core responsibility is integrating NLP models, LLMs and reasoning engines into backend services and user-facing components. The role also calls for REST and GraphQL API experience and knowledge of relational and non-relational databases.

  • Ship tested, maintainable code

    The engineer works with product managers, ML engineers and designers to turn requirements into code, performs unit, integration and API testing, troubleshoots production issues, and follows internal quality and information-security procedures.

Likely challenges to think through

  • Balancing agent capability with dependable behavior

    Preparation hypothesis: agents that plan and execute tasks may be harder to test than fixed workflows. Prepare to explain how you would define task boundaries, handle failures and test behavior across the orchestration and API layers.

  • Moving from a convincing demo to a durable feature

    Preparation hypothesis: fast end-to-end proofs of concept may compete with the posting’s scalability, performance and code-quality goals. Prepare an approach for identifying what a demo proves, then adding the testing and engineering needed for a maintained feature.

  • Diagnosing issues across system boundaries

    Preparation hypothesis: a fault in a user-facing AI feature could originate in the UI, backend, model integration, API or data layer. Prepare a structured troubleshooting approach that isolates the failing layer while accounting for the posting’s production-support and information-security duties.

03

Practice your answers

Technical practice

How would you design an AI agent that can reason, plan, and execute a workflow?

What to coverSuggested preparation: Explain how you would represent the task, choose actions, manage state, and determine when the workflow is complete. Discuss how you would handle failed actions and limit unintended execution.

How would you build an end-to-end AI proof of concept across frontend, backend, and orchestration layers?

What to coverSuggested preparation: Trace a user request through the interface, APIs, orchestration, and response. Explain what you would build first to demonstrate the idea and what you would revisit before making it a maintained feature.

How would you integrate an NLP model, LLM, or reasoning engine into a user-facing feature?

What to coverSuggested preparation: Cover the backend integration and how its outputs would reach the user-facing component. Discuss how you would evaluate output usefulness and handle errors or uncertain results.

How would you divide an AI feature between a modern JavaScript frontend and Node.js or Python services?

What to coverSuggested preparation: Explain where interface logic, API handling, and model integration belong. Discuss type contracts and the trade-offs of using more than one language across the feature.

When would you choose REST or GraphQL for an API serving an AI-driven feature?

What to coverSuggested preparation: Compare their fit for the data a frontend needs, including response shape and API evolution. Show how you would make model-backed operations understandable to API consumers.

How would you choose among search, relational, document, and cache data stores for a feature?

What to coverSuggested preparation: Use the posting’s examples—Elasticsearch or Solr, MySQL or PostgreSQL, MongoDB, and Redis—to discuss query needs, consistency, and performance. Explain the workload that would justify each choice rather than assuming every feature needs every store.

What would you consider when connecting an agentic workflow to an MCP-based integration?

What to coverSuggested preparation: The posting asks for familiarity with MCPs; explain how you would assess the integration’s capabilities, inputs, outputs, and failure behavior. Describe how you would constrain access to actions or data before allowing an agent to use it.

How would you test an AI feature at unit, integration, and API levels?

What to coverSuggested preparation: Give a distinct purpose for each level, from deterministic workflow logic to service boundaries and API contracts. Explain how you would test failure cases without relying solely on variable model outputs.

How would you evaluate the performance and scalability of an agentic AI feature?

What to coverSuggested preparation: Discuss response time, concurrent requests, and the cost of multiple model or service calls. Explain what you would measure before choosing between optimizations that might affect answer quality.

How would you troubleshoot a production failure spanning the frontend, API, and AI integration?

What to coverSuggested preparation: Describe how you would isolate the failing layer using the request path and available error evidence. Cover safe mitigation, verification of the fix, and a test that could prevent recurrence.

Behavioural practice

Tell me about a time you turned cross-functional requirements into tested code.

What to coverSuggested preparation: Use a real situation involving product, ML, design, or comparable partners; state your responsibility and the actions you took to resolve ambiguity. Finish with the delivered result and how you verified it met the agreed requirements.

Describe a time sprint priorities changed while you were delivering a feature.

What to coverSuggested preparation: Explain the situation, how you raised trade-offs during planning or another team discussion, and what you did next. Give the result for delivery or team coordination.

Tell me about a production issue you helped resolve.

What to coverSuggested preparation: Set out the user or system impact, your specific troubleshooting and communication actions, and the outcome. Distinguish what you knew at the time from what you learned afterward.

Describe a time you identified a quality or information-security concern.

What to coverSuggested preparation: Choose a real example and explain the situation, the procedures or reporting path you followed, and your own actions. State the result without disclosing sensitive details or assuming a particular company policy.

Tell me about a time you evaluated an emerging AI or engineering tool for practical use.

What to coverSuggested preparation: Describe the need, how you assessed whether the tool was useful, and the trade-offs you communicated. End with the decision or result, even if the team chose not to adopt it.

02

Sharpen your knowledge

Topics to prepare

  • Agent reasoning and workflows

    The role calls for agents that reason, plan and execute tasks. As revision, diagram an agent workflow, including how it chooses a next step, handles a failed step and decides when to stop.

  • AI integration boundaries

    The posting names NLP models, LLMs, reasoning engines and MCPs. As revision, sketch where each could interact with a backend service and user-facing component; distinguish the posting’s stated technologies from your proposed design.

  • Full-stack architecture

    End-to-end features and scalable SearchUnify agentic AI features are stated responsibilities. As revision, trace one hypothetical request through a JavaScript frontend, backend API, orchestration layer and database, noting likely performance bottlenecks.

  • Data and search tradeoffs

    The posting lists relational and non-relational databases, Elasticsearch, Apache Solr and Citus Data. As revision, compare which listed options you would consider for structured records, cached state and search in a hypothetical AI feature, and explain the tradeoffs without assuming SearchUnify’s implementation.

  • Testing and operational responsibilities

    Unit, integration and API testing, production troubleshooting, internal QMS procedures and information-security controls are explicit. As revision, outline test boundaries for an AI-backed API and explain how you would investigate an incident while following the stated reporting obligation.

Skills to revise

  • Build a small end-to-end AI flow

    As practice, implement a minimal user-facing interaction with JavaScript or TypeScript, a Node.js or Python backend, and a model API integration; show a multi-step agent workflow. This rehearses the posting’s full-stack AI demo and POC work, not a specified employer project.

  • Design and consume APIs

    As practice, define a REST endpoint and a GraphQL operation for the same hypothetical AI feature, then exercise request validation, error responses and a consuming client. Both API styles and AI-system integration are explicitly listed.

  • Work with listed data technologies

    As practice, write a query against MySQL or PostgreSQL and a search query against Elasticsearch or Apache Solr for a hypothetical feature; explain where MongoDB, Redis or Citus Data might fit. The posting names these technologies but does not prescribe a particular design.

  • Test and troubleshoot an integration

    As practice, add unit tests for workflow decisions, an integration test for a backend-to-model call and an API-level test for failure handling; diagnose one deliberately broken response. This matches the stated testing and production-troubleshooting duties.

  • Translate requirements into tested code

    As practice, turn a short hypothetical product request into acceptance criteria and a small tested change, identifying questions for a product manager, ML engineer and designer. The posting explicitly describes collaboration with those roles.

04

Your preparation checklist

  • Outline an end-to-end AI project walkthrough

    Prepare a one-page account of a real project, if available, showing the frontend, backend, APIs, database and AI integration, plus your contributions and results. The SearchUnify role spans these layers and calls for AI demos and proofs of concept.

  • Sketch an agentic feature design

    As interview practice, diagram how an agent could reason, plan and execute a task through a user interface, orchestration layer and backend service. Explain model or tool integration, failure handling and scalability as design choices, not as claims about SearchUnify's architecture.

  • Gather evidence for the stated technical skills

    Select code or project examples, where available, for JavaScript, TypeScript, Python, Node.js, a modern JavaScript framework, REST or GraphQL, and relevant databases. Be ready to explain design trade-offs rather than claim experience with every listed technology.

  • Prepare a testing and incident-response example

    Outline how you used unit, integration and API tests to validate a feature and diagnosed a production issue, if applicable. Note how you handled information-security controls or incident reporting; the posting includes all of these responsibilities.

  • Rehearse a requirements-to-delivery story

    Prepare a concise example of working with product, ML or design colleagues to turn a requirement into tested code, including a trade-off and how work was coordinated. The role also includes Scrum activities.

  • Write targeted questions for the employer

    Ask which agent workflows and integrations the SearchUnify team prioritizes, how demos become maintained features, and how the listed data technologies are used. Clarify work location: the heading says Panchkula, while the page also says Remote, India.

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…