New opportunity

AI Native Software Engineering Senior Analyst

Accenture · Jaipur, India

About this role

Accenture seeks an AI Native Software Engineering Senior Analyst in Jaipur to build HANA-optimized SAP applications and extensions with governed, agentic AI capabilities. The role combines ABAP on HANA engineering with LLM tool use, retrieval grounding and evaluation to deliver production-ready SAP workflows; it does not focus on training or fine-tuning foundation models.

Responsibilities

  • Develop performant ABAP solutions using HANA pushdown principles, CDS views and, where appropriate, AMDP and SQLScript. Model reusable business data for transactions, analytics, integrations and AI retrieval.
  • Build maintainable ABAP services and APIs with secure coding, authorization checks, stable contracts and modern software design practices. Integrate SAP services with cloud and non-SAP systems.
  • Connect ABAP services to LLMs for controlled SAP actions through tool calling and retrieval-grounded responses. Develop prompts, tool schemas, context assembly and deterministic fallbacks when confidence or grounding is weak.
  • Test ABAP services and data artifacts for correctness and performance. Evaluate AI behavior with golden datasets, scenario tests and online monitoring; apply authorization-aware filtering, redaction, action confirmations and audit logs.
  • Instrument production services with logs, metrics and traces; design retries, idempotency and safe failure modes. Collaborate with UX, integration, data and platform teams to move prototypes into secure, scalable production systems.

Requirements

At least 3 years of experience and 15 years of full-time education. The posting header also lists an experience band of 2–5 years. Required capabilities include hands-on ABAP development on HANA, performance tuning and pushdown, CDS data modeling, AMDP/SQLScript, software testing and CI/CD practices, and LLM integration, retrieval grounding, tool orchestration, AI evaluation and safety boundaries.

Strongly beneficial: OData and API lifecycle design; SAP integration with cloud runtimes; benchmarking, load testing and query-plan tuning; and SAP security, authorizations and compliance for sensitive data.

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

Skills for this role

SAP ABAP Development for HANASAP HANAABAPCDS viewsAMDPSQLScriptODataAPI designLLM integrationAI agentsTool callingRAGPrompt engineeringAI evaluationAI guardrailsSAP authorizationsPerformance tuningAutomated testingCI/CDObservabilityCloud integration

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

  • HANA-optimized ABAP

    The role emphasizes performant ABAP on HANA: push down suitable processing, minimize data movement, and use AMDP or SQLScript where appropriate, with governance and testing.

  • Reusable CDS data models

    Build CDS views with consistent business definitions and authorization concepts so transactional, analytical, integration, and AI-retrieval consumers can use the same data reliably.

  • Governed AI-enabled SAP workflows

    Connect ABAP services to LLMs through controlled tool calls and retrieval-grounded context. The posting calls for prompts, tool schemas, and deterministic fallbacks—not foundation-model training.

  • Measured quality and safety

    Test ABAP services and data artifacts for correctness and performance; evaluate AI behavior with golden datasets, scenarios, and monitoring. Apply context filtering, redaction, confirmations, and audit logs to AI-enabled actions.

  • Production-ready service delivery

    Build stable, secure APIs; instrument logs, metrics, and traces; and design retries, idempotency, and safe failures. Work with UX, integration, data, and platform teams to take prototypes into production.

Likely challenges to think through

  • Choosing the right pushdown boundary

    A likely trade-off is HANA performance versus maintainable, governed logic: not every operation belongs in AMDP or SQLScript. Prepare to explain how you would compare access patterns, measure performance, and test a pushdown decision.

  • Making AI actions useful without overreaching

    Tool calls and retrieval can help SAP workflows, but weak grounding or insufficient authorization checks could make an action unsafe. Prepare a design example covering approved APIs, filtered context, low-confidence fallback, action confirmation, and auditability.

  • Diagnosing cross-layer failures

    When ABAP services, integrations, and AI behavior interact, a failure may be hard to locate while retries risk repeating an action. Prepare to discuss contract and scenario tests, correlation IDs, idempotency, monitoring, and safe failure modes as a connected approach.

03

Practice your answers

Technical practice

How would you diagnose and improve a slow ABAP workload on HANA?

What to coverThe posting emphasizes pushdown, efficient SQL access and performance tuning. Suggested preparation: explain how you would measure the bottleneck, inspect data movement and query plans, then compare a database-side change against a simpler ABAP approach.

How would you design CDS views for transactional, analytical and AI retrieval consumers?

What to coverThe role calls for reusable business entities with associations, annotations, authorization concepts and consistent definitions. Suggested preparation: discuss how you would choose semantics and access patterns while preserving clear lineage and appropriate data access.

When would you use AMDP or SQLScript instead of another ABAP on HANA approach?

What to coverThe page calls for AMDP and SQLScript where performance-critical logic warrants controlled pushdown. Suggested preparation: weigh measured performance gains against complexity, governance, testability and maintenance.

How would you expose a stable, secure ABAP service to other systems?

What to coverThe posting mentions OData/service exposure, contract-first behavior, versioning and authorization checks. Suggested preparation: describe a service contract, how changes remain compatible, and where you would enforce security across data and service layers.

How would you assemble grounded context for an LLM response using SAP data?

What to coverThe role includes retrieval over governed SAP data and documentation, prompts or templates, and context assembly. Suggested preparation: explain how you would select authorized context, limit ambiguity and handle an answer that lacks sufficient grounding.

How would you let an LLM request a SAP action without giving it uncontrolled access?

What to coverThe page specifies tool calling through approved APIs, tool schemas, action confirmations and audit logs. Suggested preparation: walk through validation and authorization before execution, plus a deterministic fallback or safe refusal when the request is uncertain.

How would you evaluate an AI-enabled SAP workflow before and after release?

What to coverThe posting calls for golden datasets, scenario tests and online monitoring for drift or regressions. Suggested preparation: distinguish offline checks from production signals and explain how failures would inform changes to grounding, tools or guardrails.

What automated tests would you use for ABAP services and data artifacts?

What to coverThe role specifies unit, integration and contract tests, regression coverage, and a CI/CD orientation. Suggested preparation: map tests to correctness, service compatibility and performance, including what should block a release.

How would you troubleshoot and safely recover a failing production workflow?

What to coverThe page names logs, metrics, traces, correlation IDs, retries, idempotency, runbooks and safe failure modes. Suggested preparation: describe how you would trace a request, decide whether retrying is safe, and prevent duplicate or partially completed actions.

How would you integrate an ABAP service with a cloud or non-SAP system?

What to coverThe posting covers SAP and non-SAP ecosystems, including event-driven patterns, API gateways and integration layers. Suggested preparation: compare integration options in terms of contracts, error handling, security and end-to-end performance without assuming a specific platform.

Behavioural practice

Tell me about coordinating a delivery across teams with different priorities.

What to coverThe role involves collaboration with UX, integration, data and platform teams. Suggested preparation: use a real situation, your actions to resolve a dependency or disagreement, and the resulting delivery outcome.

Describe a time you helped move a prototype toward production readiness.

What to coverThe posting calls for rapid prototypes that evolve into secure, scalable systems. Suggested preparation: give the situation, the testing, security or operational gaps you addressed, and the observed result.

Tell me about an incident you investigated and what you changed afterward.

What to coverThe role includes incident support, structured diagnostics and hardening based on failure patterns. Suggested preparation: explain the situation, your diagnostic and recovery actions, and the measurable or observable result.

Describe a time you had to put a safety or access boundary ahead of a convenient solution.

What to coverThe posting emphasizes authorizations, sensitive-data controls and governed AI actions. Suggested preparation: recount the actual constraint, how you handled the trade-off, and what happened; do not imply you have AI-specific experience if the example came from another system.

Tell me about using feedback from a demonstration to improve a solution.

What to coverThe page calls for frequent demonstrations and iterative delivery. Suggested preparation: describe the initial situation, the feedback you acted on, and the result, including any trade-off you had to communicate.

02

Sharpen your knowledge

Topics to prepare

  • HANA pushdown decisions

    The posting prioritizes performant ABAP on HANA and controlled use of AMDP/SQLScript. Revision exercise: explain when to use a CDS view, AMDP/SQLScript, or ABAP processing for a data-heavy operation, including how each choice affects data movement and testing.

  • CDS semantics and authorization

    The role calls for CDS associations, annotations, authorization concepts, and consistent business definitions. Revision exercise: sketch a reusable business-entity model and explain how it would serve transactional, analytical, and AI-retrieval consumers without exposing unauthorized data.

  • Governed LLM actions and grounding

    The posting specifies approved SAP actions through tool calling, retrieval over governed data, and deterministic fallbacks. Revision exercise: trace a sample request from retrieved context to an approved action, identifying where grounding, authorization, confirmation, and fallback decisions occur.

  • AI evaluation and safety boundaries

    The role includes golden datasets, scenario tests, online monitoring, redaction, and audit logs. Revision exercise: define a small set of grounded-answer, unauthorized-access, and low-confidence scenarios, then state what a passing response would do in each.

  • Production reliability and integration

    The posting emphasizes SAP and non-SAP integration, logs/metrics/traces, retries, idempotency, and safe failures. Revision exercise: diagram a service call across an integration boundary and explain how to diagnose a failed or repeated request using correlation IDs.

Skills to revise

  • Tune ABAP data access

    Hands-on ABAP on HANA, efficient SQL access, and performance tuning are stated primary skills. Suggested exercise: refactor a row-by-row data retrieval example toward database-side processing; compare the access pattern and explain how you would verify correctness and performance.

  • Build a CDS data artifact

    The role requires CDS modeling with associations, annotations, and authorization concepts. Suggested exercise: draft a CDS view for a business entity, document its associations and consumer-facing fields, and check that its authorization approach matches the exposed data.

  • Implement controlled pushdown

    The posting calls for AMDP/SQLScript in performance-critical cases where appropriate. Suggested exercise: outline a narrowly scoped AMDP/SQLScript operation, its ABAP-facing contract, and tests comparing its results with expected business rules.

  • Design a stable SAP service contract

    The role calls for secure ABAP services and APIs; OData and API lifecycle design are strongly beneficial. Suggested exercise: draft an OData-style service contract with input validation, authorization checks, versioning considerations, and an integration error response.

  • Prototype a grounded tool workflow

    LLM integration, retrieval grounding, tool orchestration, and safety boundaries are primary skills. Suggested exercise: write a prompt template and tool schema for a read action and a confirmed write action, with authorization-aware context, redaction, and a deterministic low-grounding fallback.

  • Test and diagnose an end-to-end flow

    The posting specifies ABAP unit/integration/contract tests, CI/CD orientation, AI evaluation, and production observability. Suggested exercise: prepare a compact test set covering data correctness, API contracts, grounded responses, and rejected actions; specify the logs, metrics, and traces needed to investigate a failure.

04

Your preparation checklist

  • Prepare a HANA performance walkthrough

    The role calls for ABAP pushdown and performance tuning. Prepare one project example showing the original bottleneck, the revised data access approach, how you measured performance, and the outcome.

  • Sketch a reusable CDS data model

    The posting specifies CDS associations, annotations, authorization concepts, and transactional and analytical consumers. Draw a small business-entity model and explain its access controls and reuse.

  • Practice a governed AI workflow design

    The role includes LLM tool calling and retrieval over governed SAP data. Sketch an ABAP service, approved tool schema, context assembly, authorization filtering, action confirmation, and fallback for weak grounding.

  • Assemble testing and evaluation evidence

    Prepare examples of ABAP unit, integration, or contract tests and CI/CD practices. For the AI design, outline a golden dataset, scenario tests, and checks for incorrect or unauthorized responses.

  • Explain production failure handling

    The posting calls for logs, metrics, traces, retries, idempotency, correlation IDs, and safe failure modes. Prepare a brief incident walkthrough or design showing how a failed SAP action would be detected, diagnosed, and handled safely.

  • Prepare focused questions for Accenture

    Ask which SAP workflows and integration patterns this Jaipur role would support, how AI actions are approved and evaluated, and how the stated 2–5-year experience band relates to the minimum three-year requirement.

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…