New opportunity

Assoc/Snr Assoc, Agentic AI Engineer, Risk Technology, Risk Management Group

DBS Bank Ltd · Singapore

About this role

The Agentic AI Engineer works within Risk Technology at DBS to build scalable applications and AI capabilities for risk management. The role is based in Singapore - Central (DBS Asia Central) and is full-time.

Responsibilities

Collaborate with business stakeholders to gather and refine technical and AI requirements. Design, develop and maintain applications, microservices, APIs and backend services using Python, Java, Node.js, FastAPI and Spring Boot.
Develop LLM-powered copilots, chatbots and decision-support tools. Apply prompt and context engineering and retrieval-augmented generation (RAG); integrate LLM APIs, embeddings and vector databases for semantic search.
Build and orchestrate AI agents, Agent Harness implementations and multi-agent workflows. Develop evaluation and testing harnesses and guardrails to support AI performance and reliability.
Apply object-oriented design principles and design patterns; design SQL databases and use ORM tools. Contribute to full-stack development and UI/UX with JavaScript and TypeScript.
Manage development, testing, deployment and maintenance across the software development lifecycle. Implement CI/CD pipelines for application and AI workloads and support DevOps automation, monitoring and scalability.

Requirements

Bachelor’s degree in Computer Science, Software Engineering or a related field, plus 5+ years of software development experience.
Strong Python proficiency; working knowledge of JavaScript, TypeScript, Java and Kotlin; hands-on FastAPI, Spring Boot and backend-framework experience; and experience building RESTful APIs and microservices.
Experience or exposure to LLMs, prompt engineering or AI application development. Understanding of RAG, embeddings, vector databases and semantic search; familiarity with LangChain and Agent Harness concepts; and knowledge of AI evaluation, guardrails and hallucination mitigation.
Understanding of backend architecture, distributed systems, object-oriented programming and design patterns. Proficiency in SQL, relational databases and Hibernate/JPA, plus experience with CI/CD, Git, DevOps and deployment automation. Strong communication skills and an ability to explain complex engineering and AI concepts.

Preferred

Familiarity with NoSQL databases such as MongoDB is a plus.

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

Skills for this role

PythonJavaScriptTypeScriptJavaKotlinNode.jsFastAPISpring BootRESTful APIsMicroservicesLarge Language ModelsPrompt EngineeringContext EngineeringRAGAI AgentsMulti-agent WorkflowsLangChainAgent HarnessVector DatabasesEmbeddingsSemantic SearchAI EvaluationAI GuardrailsHallucination MitigationSQLRelational DatabasesHibernateJPAMongoDBOOP בר Design Patterns

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

Translate risk needs into technical requirements
The role collaborates with business stakeholders to gather and refine technical and AI requirements. Prepare to explain how you would turn a decision-support need into a defined application scope and communicate design choices clearly.
Build scalable backend services
The posting calls for applications, RESTful APIs, microservices, and backend services using Python, Java, Node.js, FastAPI, and Spring Boot. It also covers SQL design and ORM tools. Prepare to discuss architecture, data-model, and maintainability decisions rather than treating the frameworks as a checklist.
Deliver LLM features with effective retrieval
Copilots, chatbots, and decision-support tools are stated duties, alongside prompt and context engineering, RAG, embeddings, vector databases, and semantic search. Prepare to walk through how retrieval and context selection affect an LLM feature’s answers.
Orchestrate agents and assess their outputs
The role explicitly includes AI agents, Agent Harness implementations, multi-agent workflows, evaluation and testing harnesses, and guardrails. Focus preparation on how to test behavior and mitigate hallucinations, not just how to assemble agents.
Own delivery through deployment and maintenance
Responsibilities span the full software development lifecycle, CI/CD for application and AI workloads, DevOps automation, monitoring, and scalability. Prepare to describe how changes would be tested, deployed, observed, and maintained.

Likely challenges to think through

Agent flexibility versus predictable behavior
Preparation hypothesis, not a stated DBS problem: multi-agent workflows may handle varied tasks but make failures harder to isolate. Prepare to explain when a simpler workflow is preferable and how evaluation harnesses and guardrails would expose unreliable outputs.
Retrieval coverage versus answer quality
Preparation hypothesis: adding retrieved context can improve coverage while also introducing irrelevant material or unsupported answers. Prepare to discuss how you would assess search relevance, context selection, and hallucination mitigation in a RAG feature.
Fast iteration versus dependable operation
Preparation hypothesis: changes to AI behavior and backend services may need different tests while sharing a deployment pipeline. Prepare to explain how CI/CD, monitoring, and maintenance would help detect regressions without making every change unnecessarily slow.

Practice your answers

Technical practice

How would you design a RESTful backend for an LLM-powered decision-support tool?

What to coverThe posting calls for scalable APIs and backend services using Python, FastAPI, Java and Spring Boot. Suggested answer focus: explain service boundaries, API contracts and how you would handle errors and changing requirements.

What trade-offs would you consider when splitting an application into microservices?

What to coverThe role includes microservices, distributed systems and scalability. Suggested answer focus: compare independent deployment with added communication and operational complexity, and explain how you would diagnose a slow request across services.

How would you build and assess a retrieval-augmented generation pipeline?

What to coverThe posting names RAG, embeddings, vector databases and semantic search. Suggested answer focus: cover document preparation, retrieval and answer generation, then distinguish retrieval quality from the quality of the final answer.

How would prompt and context engineering improve an LLM-powered copilot?

What to coverPrompt engineering, context engineering and copilots are stated responsibilities. Suggested answer focus: discuss relevant context, clear instructions and testing responses when context is missing or misleading.

When would you use an AI agent or multi-agent workflow instead of a simpler application flow?

What to coverThe role covers AI agents, Agent Harness concepts, multi-agent workflows and familiarity with LangChain. Suggested answer focus: explain task orchestration and the trade-off between flexibility and the complexity of controlling and testing agent behaviour.

How would you evaluate an AI feature and mitigate unreliable answers?

What to coverThe posting explicitly calls for evaluation, testing harnesses, guardrails and hallucination mitigation. Suggested answer focus: describe representative test cases, measures of answer quality and failure handling, including how you would detect regressions.

How would you diagnose and improve a slow SQL-backed service?

What to coverThe role includes SQL database design and optimization, plus Hibernate/JPA. Suggested answer focus: examine queries, indexes and ORM-generated access patterns, while explaining the trade-offs of a proposed change.

How would you apply object-oriented design to keep an AI-enabled service maintainable?

What to coverOOP, OOAD and design patterns are stated requirements. Suggested answer focus: show how you would separate business logic from LLM integration and data access, and avoid adding abstractions without a clear need.

How would you connect a JavaScript or TypeScript interface to an AI-backed API?

What to coverThe posting includes full-stack development and UI/UX alongside backend APIs. Suggested answer focus: discuss API contracts, user-visible handling of loading and errors, and how the interface would communicate an uncertain result.

How would you release and monitor changes to both application code and AI workloads?

What to coverThe role covers end-to-end SDLC, CI/CD, deployment automation and monitoring for application and AI workloads. Suggested answer focus: distinguish software tests from AI evaluations, then explain deployment checks and how you would investigate a post-release regression.

Behavioural practice

Tell me about a time you turned an ambiguous stakeholder request into technical requirements.

What to coverThe posting calls for gathering and refining business stakeholders’ technical and AI requirements. Suggested answer structure: give the situation, the questions and trade-offs you worked through, and the resulting agreed scope or outcome.

Describe a time you explained a complex engineering or AI decision to a non-specialist.

What to coverThe role explicitly calls for communication and explaining complex concepts. Suggested answer structure: identify the audience and decision, show how you adapted your explanation, and state what the audience was able to decide or do.

Tell me about a time testing exposed a reliability problem before release.

What to coverThe posting emphasizes testing, AI evaluation, guardrails and reliability. Suggested answer structure: describe the failure, your investigation and changes, and the evidence that the outcome improved.

Describe a time you investigated a problem in a deployed service.

What to coverDeployment, maintenance, DevOps automation and monitoring are part of the stated work. Suggested answer structure: explain the situation, how you narrowed down the cause and coordinated a response, and what changed afterward.

Tell me about a time you coordinated a change across frontend, backend or deployment work.

What to coverThe role spans full-stack development, backend services and the end-to-end software lifecycle. Suggested answer structure: describe the people and dependencies involved, your specific actions to keep work aligned, and the delivery result.

Sharpen your knowledge

Topics to prepare

RAG and semantic search
Revise how context engineering, embeddings, vector databases and retrieval affect an LLM response. Exercise: sketch a retrieval-to-answer flow and explain where irrelevant context could enter. The posting explicitly calls for RAG and semantic-search understanding.
Agent and multi-agent design
Revise agent orchestration, LangChain familiarity and Agent Harness concepts. Exercise: diagram a single-agent workflow, then explain what changes when two agents coordinate. Building agents and multi-agent workflows is an explicit responsibility.
AI reliability
Revise evaluation, testing harnesses, guardrails and hallucination mitigation. Exercise: define test cases for a decision-support response that is unsupported by its retrieved context. These are explicit reliability concerns in the posting.
Backend and object-oriented architecture
Revise microservices, distributed systems, OOAD and design patterns. Exercise: compare two service boundaries for an LLM-powered feature and justify how each affects scalability and maintenance. The role calls for scalable services and sound backend design.
Relational data design
Revise SQL schema and query design alongside Hibernate/JPA mapping concepts. Exercise: model records for a hypothetical AI application and identify a query to optimize. SQL, relational databases and ORM proficiency are stated requirements; MongoDB is only a plus.
Delivery lifecycle and requirements
Revise how stakeholder requirements move through development, testing, deployment and maintenance. Exercise: turn a hypothetical decision-support request into technical requirements and explain them in plain language. Stakeholder collaboration, communication and end-to-end SDLC are explicit.

Skills to revise

Build a Python API
Practice implementing and testing a small RESTful FastAPI service, with a minimal JavaScript or TypeScript interface if time permits. Python proficiency, FastAPI, APIs and some full-stack contribution are stated in the posting; the sample service is a preparation exercise.
Implement a Spring Boot data path
Practice a Java Spring Boot endpoint that reads and writes relational data through Hibernate/JPA, then explain its SQL behavior. This targets the stated hands-on framework, backend and ORM requirements.
Prototype retrieval-backed responses
Practice connecting an LLM API to embedding-based retrieval and recording which retrieved passages informed an answer. This is a suggested exercise for the posted LLM integration, RAG and semantic-search responsibilities, not a specified project.
Orchestrate an agent workflow
Practice specifying agent steps, handoffs and failure behavior in a small Agent Harness or LangChain example. The posting names agent orchestration, multi-agent workflows and familiarity with those concepts.
Create an AI test harness
Practice running a fixed set of prompts and recording unsupported answers, guardrail outcomes and regressions. This directly rehearses the requested AI evaluation, testing and hallucination-mitigation work.
Automate and explain a release
Practice using Git and a CI/CD pipeline to test and deploy a small service, then explain what you would monitor after release. CI/CD for application and AI workloads, deployment automation and monitoring are explicit responsibilities.

Your preparation checklist

Map your evidence to the requirements
Prepare a one-page evidence map for the stated degree and 5+ years of development experience, plus Python, FastAPI, Spring Boot, REST APIs, SQL/Hibernate/JPA, and working knowledge of JavaScript, TypeScript, Java and Kotlin. Mark gaps honestly rather than implying hands-on experience.
Rehearse a stakeholder-to-delivery walkthrough
Choose a real project and explain how you refined business requirements, made technical trade-offs, communicated decisions and maintained the service after deployment. The posting emphasizes stakeholder collaboration and end-to-end delivery; use only work you actually did.
Sketch a scalable backend design
Prepare a short design exercise for a hypothetical risk-management decision-support service: draw its APIs, microservice boundaries, SQL model and ORM interactions, then explain scalability, failure handling and relevant OOP or design-pattern choices. Label the scenario as your preparation example, not a DBS system.
Diagram a RAG and agent workflow
Show how a hypothetical copilot would use context engineering, embeddings, vector search and an LLM API. Add an agent or multi-agent flow, explain where an Agent Harness or LangChain could fit, and identify the trade-offs between that approach and a simpler workflow.
Build an evaluation and guardrail plan
Prepare sample test cases and a compact scorecard for retrieval quality, answer reliability and hallucination mitigation. Explain how a testing harness would detect failures and how guardrails would respond; these are responsibilities named in the posting, not claimed DBS procedures.
Show how you would ship and operate it
Outline Git-based testing, CI/CD and deployment for both the application and AI workload, including monitoring and maintenance. Bring a real example if available, and be ready to distinguish your own contributions from team-wide work.
Prepare focused questions for DBS
Write questions about which risk-management users and requirements the team serves, how it evaluates agent reliability, and how application and AI deployments are monitored. Ask where full-stack JavaScript/TypeScript work fits alongside backend responsibilities.

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 Singapore. Matched to this role, not your profile.

Explore more jobs

Finding similar opportunities…