AI Centre of Excellence, Full-Stack Engineer (Generative AI)

What matters most

• Put generative AI into production

  The role integrates LLMs into enterprise applications, designs AI-powered workflows and enables knowledge retrieval. Prepare to explain an end-to-end approach using embeddings, a vector database and an orchestration tool, including how you would assess whether it delivers business value.

• Build maintainable applications across the stack

  KPMG calls for scalable Python backend services and user-friendly TypeScript and Next.js interfaces. Prepare to discuss API design, system architecture and reusable components, with attention to security, efficiency and maintainability.

• Own cloud delivery

  The engineer will define infrastructure as code, set up automation pipelines and support robust, compliant, scalable deployments. Prepare to walk through a Terraform-based deployment and the roles of networking, security, CI/CD and containers.

• Translate needs across disciplines

  The posting emphasizes working with architects, product owners, designers and other stakeholders, as well as sprint planning and code reviews. Prepare examples of turning product requirements into technical decisions and explaining trade-offs to non-technical colleagues.

Likely challenges to think through

• Retrieval quality versus operational constraints

  Likely challenge, not a stated employer problem: improving the usefulness of retrieved information may add latency or complexity to an AI workflow. Prepare to discuss how you would evaluate retrieval results and decide when a more complex design is justified.

• Release speed versus controls

  Likely challenge, not a stated employer problem: deploying AI-enabled applications quickly may conflict with the posting’s security, compliance and robustness goals. Prepare to explain which checks and safeguards you would build into infrastructure and deployment pipelines.

• Polished experience versus maintainable architecture

  Likely challenge, not a stated employer problem: evolving product requirements can make it difficult to deliver a seamless interface without tightly coupling it to backend or AI behavior. Prepare to describe how you would define API boundaries, reuse components and handle changes across the stack.

Topics to prepare

• Embeddings and knowledge retrieval

  Revise how documents become embeddings, how vector search retrieves relevant material, and how retrieved context reaches an LLM. Practice: sketch a retrieval flow and explain where irrelevant results could degrade an answer. The role explicitly includes intelligent knowledge retrieval and names embeddings and vector databases.

• Conversational workflow design

  Revise how a conversational agent or AI-augmented workflow coordinates model calls and application logic. Practice: draw a request-to-response flow and identify where LangChain or LlamaIndex could help. The posting requires experience designing these workflows and familiarity with either orchestration tool.

• Production service architecture

  Revise service boundaries, reusable design patterns, and trade-offs among security, efficiency, maintainability and scale. Practice: diagram a Python API serving a Next.js interface and explain two design choices. The role calls for production-grade services and a solid understanding of architecture and design patterns.

• Cloud deployment and security fundamentals

  Revise networking, security, containerisation and how infrastructure-as-code supports repeatable deployments. Practice: outline a deployment path from application container to cloud service, marking network and security decisions. These areas are explicitly named; Azure is preferred, while AWS and GCP are also listed.

• Engineering collaboration

  Revise how to turn product and design requirements into technical decisions and explain trade-offs to non-technical stakeholders. Practice: give a short explanation of a retrieval feature, then identify questions for a product owner and points to raise in code review. The posting emphasizes cross-functional work, sprint planning, reviews and clear communication.

Skills to revise

• Build a Python API

  Practice: implement a small request-and-response endpoint in FastAPI, Flask or Django, with clear input handling and error responses. The posting requires strong Python skills for production-grade APIs and services; this is a revision exercise, not a specified interview task.

• Implement a retrieval-backed workflow

  Practice: embed a small set of documents, retrieve matches with pgvector, Pinecone or Weaviate, and pass the results into a conversational response flow. This directly rehearses the listed LLM, embedding, vector-database and workflow experience.

• Create a reusable frontend component

  Practice: build a TypeScript and Next.js interface for submitting a question and displaying a response, using a reusable ShadCN/UI component styled with Tailwind CSS. These frontend technologies and reusable components are explicitly named.

• Define cloud infrastructure with Terraform

  Practice: write and review a small Terraform configuration for an application deployment in a cloud environment you know, and explain its security and networking choices. Terraform proficiency and cloud experience are required; Azure is preferred, not mandatory.

• Automate and package a deployment

  Practice: containerise a sample service with Docker and draft a CI/CD pipeline using GitHub Actions or an equivalent tool to check and deploy it. The posting names containerisation and automation pipelines; the exercise is a preparation suggestion, not a prescribed KPMG pipeline.

• Explain a technical trade-off

  Practice: present a two-minute comparison of two retrieval or deployment approaches for a non-technical stakeholder, including the impact on maintainability and scale. This rehearses the posting’s emphasis on problem-solving, ownership and clear cross-functional communication.

• Prepare a Generative AI project walkthrough

  The posting calls for hands-on LLM, embedding, vector-database and conversational-workflow experience. Prepare an architecture diagram and a concise account of your own relevant work, covering retrieval, orchestration, evaluation and your specific contributions; label any hypothetical example clearly.

• Practice a knowledge-retrieval design exercise

  The role includes AI-powered workflows and intelligent knowledge retrieval. Sketch a proposed enterprise workflow, then explain document ingestion, retrieval choices, access controls, failure handling and how you would test answer quality. This is preparation, not a stated interview exercise.

• Show production Python API decisions

  The posting requires Python services using frameworks such as FastAPI, Flask or Django. Prepare an API example or design that shows service boundaries, validation, testing, error handling and maintainability trade-offs.

• Prepare a frontend walkthrough

  The posting names TypeScript, Next.js, ShadCN/UI and Tailwind CSS. Select a relevant interface example or sketch reusable components for a knowledge-retrieval experience, including loading, error and citation states.

• Map out deployment and security

  The role includes Terraform, cloud deployment, CI/CD, networking, security and containerisation; Azure is preferred. Prepare a deployment diagram showing infrastructure-as-code, pipeline stages, secrets and identity handling, and operational checks. Treat Auth0 or Azure AD as preferred, not required.

• Rehearse stakeholder and team discussions

  The posting emphasizes work with architects, product owners and designers, plus sprint planning and code reviews. Prepare one example of explaining a technical trade-off to non-technical stakeholders and one of incorporating cross-functional feedback.

• Draft focused questions for KPMG

  Ask which retrieval and orchestration approaches the team uses, how it evaluates trustworthy AI solutions, and how application and infrastructure ownership are divided. You can also ask how the advertised Take Charge: Flexi-work framework applies to this role; the posting does not specify a work mode.