50+ Generative AI Interview Questions and Answers (2026)
Generative AI interview questions cover the full stack of GenAI knowledge: what large language models are, how transformers and attention work, how to build RAG systems, when to fine-tune versus prompt, and how to ship GenAI features responsibly. This bank contains 50+ real generative AI interview questions with concise model answers, grouped from fundamentals to advanced and tagged by role, so you can revise at your level the night before a real round.
A typical GenAI interview has four stages: a fundamentals screen (can you define things clearly?), a core concepts round (prompting, RAG, fine-tuning), a deeper technical round (attention mechanisms, embeddings, vector databases, sometimes diffusion or GANs), and an applied or behavioural round (how would you build it, how do you keep up). Work through the sections below in order, starting at your level. For any topic where you find a gap, fix it with the full generative AI roadmap before the interview.
How to Use This Generative AI Interview Guide
What are generative AI interview questions? Generative AI interview questions are the technical and conceptual questions employers ask when hiring for GenAI roles: questions about LLMs, transformers, embeddings, RAG, fine-tuning, prompt engineering, hallucination, and system design. This guide gives you 50+ of these questions with concise model answers, grouped by difficulty and theme so you can revise efficiently.
Start at your level: freshers begin with fundamentals; experienced engineers jump to advanced and scenario sections. Every answer is40-110 words, the length a strong candidate would say out loud. For deeper teaching, follow the internal links. Read each question, cover the answer, try your version out loud, then compare.
Generative AI Interview Questions for Freshers (Fundamentals)
12 questions. Role tag: entry-level / GenAI-curious. These are the "can you define it clearly" questions that every GenAI interview opens with.
Q1. What is generative AI, and how is it different from traditional (discriminative) AI?
Generative AI creates new content (text, images, code, audio) by learning the underlying data distribution. Traditional discriminative AI classifies or predicts labels for existing data: spam detection, image classification, fraud scoring. The key distinction: discriminative models learn the boundary between classes, while generative models learn the data itself. GPT generating text or Stable Diffusion generating images are generative; a spam classifier is discriminative. For a deeper comparison, see how generative AI differs from other AI.
Q2. What is a large language model (LLM)?
A large language model is a neural network trained on massive text corpora to predict the next token in a sequence. Models like GPT-4, Claude, Gemini, and Meta Llama are LLMs. They learn grammar, facts, reasoning patterns, and world knowledge from their training data. "Large" refers to both the parameter count (billions of parameters) and the training data size. LLMs are the backbone of modern generative AI applications: chatbots, code assistants, summarisation tools, and RAG systems all use an LLM as their reasoning engine.
Q3. What are tokens and tokenisation? Why do they matter?
Tokens are the units an LLM reads and generates. Tokenization is the process of splitting text into these units. A token is roughly 3/4 of a word in English, but it varies: "unhappiness" might split into "un" + "happiness." Tokens matter because LLMs have a fixed context window measured in tokens (not words), and API pricing is token-based. Understanding tokenisation helps you write more efficient prompts and estimate costs. If your prompt is 1,000 tokens and the context window is 128K tokens, you have room for a long conversation.
Q4. What is an embedding, in plain terms?
An embedding is a numerical vector (a list of numbers) that represents the meaning of a piece of text, image, or data in a way that computers can compare. Similar meanings produce vectors that are close together in the embedding space. "King" and "queen" have similar embeddings; "king" and "banana" do not. Embeddings are the foundation of semantic search and RAG: you embed your documents, embed the user query, find the closest matches, and feed them to the LLM as context.
Q5. What is a transformer, and why did it change NLP?
The transformer is the neural network architecture introduced in the 2017 paper "Attention Is All You Need." Before transformers, NLP used RNNs and LSTMs that processed tokens sequentially (slow and bad at long-range dependencies). The transformer processes all tokens in parallel using self-attention, which lets it capture relationships between any two tokens regardless of distance. This parallelism made it possible to train much larger models much faster. Every major LLM today (GPT, Claude, Gemini, Llama) is a transformer. For the full mechanism, see how transformers use attention.
Q6. What is the difference between generative AI and machine learning?
Machine learning is the broader field: algorithms that learn patterns from data to make predictions. Generative AI is a subset of ML focused on creating new content. All generative AI uses machine learning, but most ML applications (fraud detection, recommendation, regression) are not generative. Generative AI specifically refers to models that produce novel outputs: text, images, code, audio. A random forest predicting house prices is ML but not generative. GPT writing an email is both.
Q7. What is a foundation model?
A foundation model is a large model trained on broad data that can be adapted to many downstream tasks without task-specific training from scratch. GPT-4, Claude, Gemini, and Llama are foundation models. The term was coined by Stanford's HAI in 2021 to describe this shift: instead of training a separate model for each task, you train one large model and use it for everything via prompting, fine-tuning, or RAG. Foundation models are the base layer of the modern AI stack.
Q8. What is a context window, and why does it matter?
The context window is the maximum number of tokens an LLM can process in a single input. It includes both the prompt and the generated output. GPT-4 Turbo has a 128K token context window; Claude has 200K. It matters because longer context means more information can be passed to the model: longer documents, more conversation history, or more retrieved chunks in RAG. However, longer contexts are more expensive and slower, and models sometimes lose information in the middle of long contexts (the "lost in the middle" problem).
Q9. What is the difference between a discriminative model and a generative model?
A discriminative model learns the boundary between classes: given input X, it predicts label Y (P(Y|X)). A generative model learns the data distribution itself: it can generate new samples that look like the training data (P(X) or P(X,Y)). A spam classifier is discriminative; GPT is generative. Generative models can do discriminative tasks (GPT can classify text) but discriminative models cannot generate new content. The trade-off: generative models are larger and harder to train, but far more versatile.
Build an AI-First Career, Master the Complete Skillset
Choose from our industry-leading programs designed for career success
Modern Software and AI Engineering Program
Master full-stack development with AI integration
+1000 moreModern Data Science and ML with specialisation in AI
Advanced data science techniques with AI specialization
+1000 moreAdvanced AIML with Specialisation in Agentic AI
Deep dive into AIML with focus on Agentic systems
+1000 moreDevOps, Cloud & AI Platform Engineering
Build and manage AI-powered cloud infrastructure
+1000 moreAI Engineering Advanced Certification by IIT-Roorkee
Premier AI engineering certification from IIT-Roorkee
AI Forward Deployed Engineer Program
Full-stack engineering, production AI and client-facing consulting
+1000 moreQ10. What is zero-shot learning?
Zero-shot learning means getting a model to perform a task without any task-specific training examples. You describe the task in the prompt, and the model uses its pre-training knowledge to execute it. For example, asking GPT to "classify this review as positive or negative" without showing it any labelled examples first. This works because LLMs have seen similar tasks during pre-training. Zero-shot is the simplest prompting strategy; few-shot (providing examples in the prompt) and fine-tuning are progressively more involved.
Q11. What is prompt engineering?
Prompt engineering is the practice of crafting input instructions that guide an LLM to produce the desired output. It includes choosing the right wording, providing examples (few-shot), setting constraints, specifying output format, and using techniques like chain-of-thought (asking the model to reason step by step). Good prompt engineering is often the fastest and cheapest way to improve LLM performance without any model changes. It is the first tool in every GenAI engineer's toolkit.
Q12. What is hallucination in LLMs?
Hallucination is when an LLM generates plausible-sounding but factually incorrect or fabricated information. It happens because LLMs are probabilistic next-token predictors: they generate what is likely to follow, not what is true. Hallucination is one of the biggest challenges in deploying GenAI in production, especially in healthcare, finance, and legal domains. Mitigation strategies include RAG (grounding answers in retrieved documents), guardrails, human-in-the-loop review, and prompt constraints that ask the model to say "I don't know" when uncertain.
Core Generative AI Interview Questions (Prompting, RAG and Fine-tuning)
13 questions. Role tag: GenAI developer / GenAI engineer. This is the most-tested band in GenAI interviews. Spend the most care here.
Prompt Engineering Questions
If prompt engineering is a weak area, see how to structure your prompt-engineering prep for a structured learning path.
Q13. What is the difference between zero-shot and few-shot prompting?
Zero-shot prompting gives the model a task with no examples: "Classify this email as spam or not spam." Few-shot prompting includes a few input-output examples in the prompt before the actual task. Few-shot is more reliable because it shows the model the exact format and reasoning pattern you expect. Zero-shot is faster and cheaper; few-shot is more accurate for complex or ambiguous tasks. The choice depends on how well the model already understands the task from its pre-training.
Q14. What is chain-of-thought (CoT) prompting?
Chain-of-thought prompting asks the model to show its reasoning steps before giving a final answer. Instead of asking "What is 15% of 840?", you ask "What is 15% of 840? Think step by step." This dramatically improves accuracy on math, logic, and multi-step reasoning tasks because the model generates intermediate reasoning tokens that help it reach the correct conclusion. CoT is especially effective when combined with few-shot examples that demonstrate the reasoning pattern.
Q15. What is a system prompt?
A system prompt is a hidden instruction at the start of a conversation that sets the model's behaviour, role, and constraints. It is not visible to the end user but shapes every response. For example: "You are a helpful legal assistant. Only answer questions based on the provided documents. If the documents don't contain the answer, say so." System prompts are critical for controlling tone, safety, and output format in production applications. They are the first layer of guardrails.
Q16. How do you reduce prompt injection risk?
Prompt injection happens when a user's input tricks the model into ignoring its system prompt or instructions. Mitigation strategies: (1) clearly separate system instructions from user input using role markers; (2) sanitise user input to remove instruction-like text; (3) use output validation to detect when the model has deviated from expected behaviour; (4) add guardrails that check if the response contains instructions or claims that violate the system prompt. No solution is 100% effective; defence in depth is the practical approach.
RAG (Retrieval-Augmented Generation) Questions
Q17. What is retrieval-augmented generation (RAG), and why use it?
RAG is a technique that supplements an LLM's generated response with relevant information retrieved from an external knowledge base. Instead of relying solely on the model's parametric memory (which has a knowledge cutoff and can hallucinate), RAG retrieves the most relevant documents or passages at query time and includes them in the prompt. This grounds the model's answers in actual data, reduces hallucination, and keeps information current without retraining. RAG is the standard architecture for enterprise GenAI applications.
Q18. What are the components of a RAG pipeline?
A RAG pipeline has five components: (1) a document ingestion layer that loads and preprocesses data; (2) a chunking strategy that splits documents into manageable segments; (3) an embedding model that converts chunks into vectors; (4) a vector database (Pinecone, Weaviate, Chroma) that stores and retrieves vectors by similarity; (5) an LLM that generates the final answer using the retrieved context. Each component has its own failure modes: bad chunking loses context, weak embeddings miss relevant docs, and poorly framed prompts confuse the LLM. For a deep dive, see the components of a RAG pipeline.
Video: RAG is the single most-tested GenAI interview topic. This video explains the exact failure modes (weak retrieval, embeddings, vector DBs) a candidate must be able to talk through:
![Why Your RAG Isn't Working]
Q19. When should you use RAG versus fine-tuning?
Use RAG when you need access to dynamic, frequently updated knowledge (company documents, product catalogues, real-time data). Use fine-tuning when you need the model to consistently adopt a specific style, format, or domain behaviour that prompting alone cannot achieve. RAG is cheaper and easier to update; fine-tuning changes the model's weights and requires retraining for updates. Many production systems use both: fine-tune for behaviour, RAG for knowledge. The table below breaks down the comparison.
Q20. Why does a RAG system sometimes return wrong answers?
Common failure modes: (1) the retrieval step returns irrelevant or insufficiently relevant documents because the chunking strategy loses context or the embedding model does not capture the query's intent; (2) the embedding model is too weak to handle domain-specific terminology; (3) the retrieved chunks are too short and lack the surrounding context needed to answer the question; (4) the prompt template does not instruct the LLM to base its answer only on the retrieved context, so it "hallucinates beyond the context." Diagnosing which layer failed is the key skill.
Q21. RAG vs fine-tuning vs prompt engineering: how do they compare?
| Aspect | Prompt Engineering | RAG | Fine-tuning |
|---|---|---|---|
| What it changes | Nothing; you craft better inputs | Adds external knowledge at query time | Changes the model's weights via training |
| Cost | Lowest (no compute beyond inference) | Medium (vector DB + retrieval latency) | Highest (GPU training, data preparation) |
| Knowledge freshness | Limited to what the model already knows | Real-time (you update the data source) | Frozen at training time |
| Behaviour control | Limited (relies on model's pre-training) | Moderate (retrieval shapes the context) | Strong (model learns the behaviour) |
| When to use | Simple tasks, quick prototyping | Knowledge-intensive, frequently updated data | Specific format, tone, or domain expertise |
Fine-tuning and Customisation Questions
Q22. What is fine-tuning?
Fine-tuning is the process of continuing to train a pre-trained model on a smaller, task-specific dataset so it adapts to your particular use case. You take a foundation model (like Llama or GPT) and train it further on your data (customer support transcripts, domain-specific Q&A, style guides). The model's weights are updated so it learns your patterns without forgetting its general capabilities. Fine-tuning is powerful but expensive: it requires GPU time, high-quality training data, and careful evaluation to avoid overfitting.
Q23. What are LoRA and PEFT?
PEFT (Parameter-Efficient Fine-Tuning) is a family of techniques that fine-tune only a small subset of a model's parameters instead of all of them. LoRA (Low-Rank Adaptation) is the most popular PEFT method: it adds small trainable matrices to the model's attention layers while freezing everything else. The result: you get 90-95% of full fine-tuning's performance at a fraction of the cost and compute. LoRA adapters are also small (megabytes vs gigabytes), making them easy to store and swap. This makes fine-tuning practical for teams without massive GPU clusters.
Q24. When is fine-tuning the wrong choice?
Fine-tuning is wrong when: (1) the problem can be solved with better prompting or RAG (always try the cheaper option first);
(2) your training data is too small or low-quality (fine-tuning on bad data makes the model worse);
(3) the knowledge changes frequently (fine-tuning is a snapshot, not a live feed);
(4) you need the model to cite sources (RAG does this naturally; fine-tuning cannot). The rule of thumb: if you can solve it with prompt engineering or RAG, do that first. Fine-tuning is the last resort, not the first.
Advanced and Technical Generative AI Interview Questions
13 questions. Role tag: experienced GenAI engineer / data scientist. These are the questions that separate juniors from seniors.
LLM Internals and Training
For a structured deep dive into LLM architecture and training, see how large language models are built.
Q25. Explain self-attention.
Self-attention is the mechanism that lets a transformer weigh the relevance of every token in a sequence relative to every other token. For each token, it computes three vectors: a query (what am I looking for?), a key (what do I contain?), and a value (what information do I pass on?). The attention score between two tokens is the dot product of one token's query with another's key, scaled by the square root of the dimension. High scores mean high relevance. This lets the model capture long-range dependencies: in "The animal didn't cross the street because it was too tired," self-attention helps the model know "it" refers to "animal," not "street."
Q26. What is the difference between encoder-decoder and decoder-only architectures?
Encoder-decoder models (like T5 and the original transformer) have two halves: the encoder processes the input, the decoder generates the output. They excel at sequence-to-sequence tasks like translation and summarisation. Decoder-only models (like GPT and Llama) have only the decoder; they generate tokens autoregressively, one at a time. Decoder-only models have proven more scalable for general-purpose language tasks and dominate the LLM landscape. Encoder-decoder models are still used in specialised applications where input and output are clearly separate sequences.
How Scaler Transformed Careers in Different Fields
Scaler learners achieved 2.5x salary growth with average post-Scaler CTC reaching ₹23L.
Google
Amazon
Microsoft
Flipkart
Adobe1200+ moreQ27. What is quantisation?
Quantisation is the process of reducing the precision of a model's weights from 32-bit or 16-bit floating point to lower precision (8-bit, 4-bit, or even 2-bit integers). This makes the model smaller and faster with minimal accuracy loss. A 70B parameter model at FP16 needs ~140GB of memory; at 4-bit quantisation, it needs ~35GB. Quantisation is essential for deploying large models on consumer hardware or in cost-sensitive production environments. Common methods: GPTQ, AWQ, GGML. The trade-off: lower precision can reduce quality on complex reasoning tasks.
Q28. What causes hallucination, and how do you mitigate it at a system level?
Hallucination is an inherent property of autoregressive generation: the model predicts likely next tokens, not true statements. Causes include gaps in training data, ambiguous prompts, and the model's inability to distinguish fact from plausible fiction. System-level mitigations: (1) RAG to ground answers in retrieved documents; (2) guardrails that validate outputs against structured rules; (3) temperature reduction to make outputs more deterministic; (4) citation requirements (the model must point to its sources); (5) human-in-the-loop for high-stakes applications. No single fix eliminates hallucination; layer multiple mitigations.
Q29. What do temperature, top-p, and top-k control?
These are sampling parameters that control the randomness of an LLM's output. Temperature scales the logits before softmax: higher temperature (e.g., 1.0) increases randomness; lower (e.g., 0.2) makes output more deterministic. Top-k limits sampling to the k most probable next tokens. Top-p (nucleus sampling) limits sampling to the smallest set of tokens whose cumulative probability exceeds p. Temperature 0.7 with top-p 0.9 is a common production setting. For factual tasks, use low temperature; for creative tasks, increase it.
Other Generative Architectures
Q30. What is a diffusion model?
A diffusion model generates data (usually images) by reversing a gradual noising process. During training, it learns to add noise to data step by step and then reverse the process: starting from pure noise, it iteratively denoises until a clean image emerges. Stable Diffusion, DALL-E, and Midjourney use diffusion models. Diffusion models have overtaken GANs for image generation because they are more stable to train, produce higher-quality outputs, and are easier to control (via text prompts or conditioning signals).
Q31. What is a GAN, and how does it work?
A GAN (Generative Adversarial Network) consists of two neural networks competing: a generator that creates fake data and a discriminator that tries to distinguish fake from real. They train adversarially: the generator gets better at fooling the discriminator, and the discriminator gets better at catching fakes. Over time, the generator produces increasingly realistic outputs. GANs were the dominant image generation architecture before diffusion models. They are still used in some applications (super-resolution, style transfer) but are harder to train due to mode collapse and instability.
Q32. What are multimodal models?
Multimodal models can process and generate multiple types of data: text, images, audio, and video within a single architecture. GPT-4V accepts images and text as input; Gemini handles text, images, video, and audio. Multimodal models are trained on paired data (image-caption pairs, video-transcript pairs) to learn cross-modal relationships. They enable applications like visual question answering, image captioning, and video understanding. The trend in 2026 is toward unified models that handle any modality natively rather than specialised models per modality.
Vector Databases and Retrieval Internals
Q33. What is a vector database, and why can't you use a normal database?
A vector database is optimised for storing and searching high-dimensional vectors (embeddings) by similarity. A normal SQL database searches by exact match or range queries; a vector database finds the "closest" vectors using distance metrics like cosine similarity. This is essential for RAG: you embed a query, then find the document chunks with the most similar embeddings. Normal databases cannot do this efficiently at scale. Popular vector databases: Pinecone, Weaviate, Chroma, Milvus, pgvector.
Q34. What is cosine similarity?
Cosine similarity measures the angle between two vectors, giving a value between -1 (opposite) and 1 (identical direction). It ignores vector magnitude and focuses on direction, making it robust to differences in document length or embedding scale. In RAG, cosine similarity is the most common metric for comparing a query embedding against document chunk embeddings to find the most relevant passages. A cosine similarity of 0.95 means the vectors point in nearly the same direction, indicating high semantic similarity.
Q35. What is semantic search, and how does it differ from keyword search?
Semantic search uses embeddings to find results based on meaning, not just keyword overlap. Keyword search (BM25, TF-IDF) matches exact terms: a search for "car" misses documents that say "automobile." Semantic search embeds both the query and documents into the same vector space and returns the closest matches by meaning. This is why RAG systems use semantic search: a user asking "how to fix a flat tyre" will match a document titled "changing a punctured tyre" even though no words overlap directly.
Q36. What is re-ranking, and when do you need it?
Re-ranking is a second-pass retrieval step that reorders the top-k results from initial retrieval using a more accurate (but slower) model. Initial retrieval (using embeddings or BM25) is fast but approximate; re-ranking uses a cross-encoder that evaluates the query-document pair together for a more precise relevance score. You need re-ranking when the initial retrieval returns many near-matches and you need to surface the truly best results first. It adds latency but significantly improves RAG answer quality.
Applied and Scenario-Based Generative AI Interview Questions
9 questions. Role tag: GenAI engineer (system design flavour). These are the "how would you build it" questions experienced candidates get.
Q37. How would you design a chatbot over a company's internal documents?
I would build a RAG system. Ingest documents (PDFs, Confluence, Slack), chunk them into overlapping ~500-token segments, embed with a model like text-embedding-3-small, and store in a vector database. At query time, retrieve the top5-10 chunks by similarity and pass them as context to the LLM with a system prompt restricting answers to the retrieved context. Add guardrails: source citation, a fallback "I don't know" response, and PII filtering.
Q38. How would you reduce hallucinations in a production LLM app?
Layer multiple mitigations: (1) RAG to ground answers in retrieved documents with citation requirements; (2) lower temperature to reduce creative liberties; (3) guardrails that check factual claims against a knowledge base; (4) structured output validation; (5) human review for high-stakes outputs. Hallucination is a system problem, not just a model problem.
Turn Learning into Career Growth
Q39. How would you evaluate a generative AI system?
Use automated and human evaluation. Automated: measure faithfulness (does the answer match the source?), relevance, and groundedness. Frameworks like RAGAS and DeepEval automate this. Use LLM-as-a-judge for scalable evaluation. Human eval: domain experts rate a sample on accuracy, helpfulness, and safety. Track metrics over time and set a quality threshold below which features don't ship.
Q40. How would you cut latency and cost in an LLM application?
(1) Route easy queries to smaller models, complex ones to larger models.
(2) Implement semantic caching for similar queries.
(3) Reduce prompt size: shorter system prompts, fewer retrieved chunks.
(4) Use streaming for perceived latency.
(5) Quantise the model (4-bit or8-bit).
(6) Batch non-real-time requests.
(7) Use prompt compression to shrink input tokens.
Q41. What guardrails would you add before shipping a GenAI feature to users?
(1) Input filtering to block harmful or PII-containing queries.
(2) Output validation for policy violations and format compliance.
(3) Citation requirements for factual claims.
(4) Fallback responses when the model is uncertain.
(5) Rate limiting.
(6) Logging and monitoring for drift and bias.
(7) A/B testing before full rollout. Guardrails are a shipping requirement, not an afterthought.
Q42. How do agentic AI systems differ from a plain LLM call?
A plain LLM call is stateless: you send a prompt, get a response, and the interaction is over. An agentic AI system can plan multi-step tasks, use external tools (databases, APIs, code execution), maintain memory across steps, and make decisions about what to do next. Agents use frameworks like LangChain or LlamaIndex to orchestrate tool calls and reasoning loops. The key difference: a plain LLM generates text; an agent takes actions in the real world. For the full comparison, see how RAG and agentic AI differ.
Q43. How would you implement a RAG system that handles multi-step reasoning questions?
Use an agentic RAG approach: a loop where the LLM decomposes the question into sub-questions, retrieves for each, and retrieves again if the answer is incomplete. LangGraph supports this pattern. Alternatively, use HyDE (Hypothetical Document Embeddings): generate a hypothetical answer first, embed it, and use it as the retrieval query. Multi-step RAG trades latency for accuracy.
Q44. How would you handle questions outside the RAG knowledge base?
Set a confidence threshold: if the cosine similarity between the query and the top retrieved chunk falls below a set value (e.g., 0.75), respond with "I don't have information on that" rather than hallucinating. Log out-of-scope queries to identify knowledge gaps. A RAG system that confidently answers questions it has no data for is worse than one that admits ignorance.
Python and Implementation Questions for GenAI Roles
5 questions. Role tag: GenAI developer. These serve the "Python gen AI interview questions" intent. Keep answers concept-first with minimal code.
Q45. Which Python libraries would you use to build a GenAI app?
Core stack: transformers (Hugging Face) for model loading, langchain or llama-index for RAG orchestration, sentence-transformers for embeddings, openai or anthropic SDK for API models, chromadb or pinecone-client for vector storage, streamlit or gradio for prototyping. For production: add mlflow for tracking, redis for caching, fastapi for serving. The exact stack depends on self-hosted versus cloud API models.
Q46. How do you call an LLM API and handle streaming in Python?
Using the OpenAI SDK as an example: instantiate the client with your API key, call client.chat.completions.create() with the model, messages, and stream=True. Iterate over the response chunks to get tokens as they arrive. For retries, use tenacity or exponential backoff on rate-limit errors (HTTP 429). For streaming to a web client, use Server-Sent Events (SSE) to forward each chunk. The key pattern: never block the user waiting for the full response; stream tokens as they are generated.
Q47. How would you chunk and embed a set of documents in Python?
(1) Load documents using langchain's document loaders (PDFLoader, TextLoader, etc.). (2) Split into chunks using RecursiveCharacterTextSplitter with a chunk size of ~500 tokens and overlap of 50-100 tokens to preserve context at boundaries. (3) Generate embeddings using sentence-transformers (e.g., all-MiniLM-L6-v2) or the OpenAI embeddings API. (4) Store the vectors and metadata (source file, page number) in a vector database like Chroma or Pinecone. (5) Test retrieval with sample queries to verify chunk quality before building the rest of the pipeline.
Q48. How do you manage prompts and outputs (parsing, validation) in code?
Use a prompt template system (LangChain's PromptTemplate or ChatPromptTemplate) to separate prompt structure from variable inputs. For output parsing, use Pydantic models or LangChain's output parsers to enforce structured JSON output from the LLM. Validate outputs against a schema: check that required fields exist, types are correct, and values are within expected ranges. If parsing fails, retry with a more explicit prompt or fall back to a default. The principle: never trust raw LLM output; always validate before using it downstream.
Q49. How would you build a simple RAG pipeline in Python using LangChain?
Load documents with a document loader, split into chunks with RecursiveCharacterTextSplitter, embed with OpenAIEmbeddings or a local model, store in a Chroma or FAISS vector store, create a retrieval chain with RetrievalQA.from_chain_type(), and call chain.invoke({"query": "your question"}). For production, add metadata filtering, re-ranking, and streaming. The entire pipeline is ~30-40 lines of Python. Test each component independently before composing them.
Behavioural and Role-Fit Questions for Generative AI Jobs
5 questions. Role tag: all. The round most candidates under-prepare for.
For a broader view of GenAI career paths and roles, see generative AI career opportunities and roles.
Q50. Walk me through a GenAI project you've built.
Use STAR framing (Situation, Task, Action, Result). Example: "My team needed to automate customer FAQ handling. I built a RAG chatbot: chunked 2,000 product pages, embedded them, stored in Pinecone, served responses through GPT-4 restricted to retrieved context. We reduced support tickets by 35% with 92% answer accuracy." Be specific about tools, numbers, and decisions. Even a personal project counts if you can walk through the architecture and trade-offs clearly.
Q51. How do you keep up with a field that changes monthly?
"I follow a structured system: arXiv daily digest for production-relevant papers, a curated list of20-30 trusted researchers on X/Twitter, hands-on testing of new tools (not just reading about them), and short internal notes on what changed and why it matters. The goal is not to know everything; it is to evaluate whether a new development is relevant to our work within48 hours."
Q52. How do you decide whether a problem even needs generative AI?
"I start with three questions: (1) Is the output unstructured (text, images, code) or does it require understanding natural language input? If it is purely numerical classification or tabular prediction, traditional ML is probably better. (2) Is there a knowledge gap that RAG or fine-tuning can fill? (3) Is the cost and latency of an LLM justified by the value it adds? I have seen teams use GPT-4 for tasks a regex or a simple classifier could handle faster and cheaper. Generative AI is powerful but not free; use it when the problem genuinely needs generation or language understanding."
Q53. Tell me about a time a model behaved unexpectedly. What did you do?
"I deployed a summarisation model that started producing verbose, off-topic summaries for a specific document type (legal contracts). Root cause: the documents had a structure the model had rarely seen during pre-training. I fixed it by (1) adding contract-specific few-shot examples to the prompt, (2) constraining the output to a structured template with explicit sections, and (3) adding an evaluation metric (ROUGE and a human quality score) to track improvement. The fix was prompt-level, not fine-tuning-level. The lesson: always have a measurement framework before deploying, so you catch drift early."
Q54. How do you think about the ethical risks of generative AI?
"I think about ethics in three layers: (1) bias and fairness: the model's outputs can reflect biases in training data, so I advocate for bias testing in every evaluation framework; (2) misuse: generative AI can create deepfakes, misinformation, or harmful content, so guardrails and content policies are not optional; (3) transparency: users should know when they are interacting with AI, and outputs should be traceable to sources where possible. In practice, this means shipping with guardrails, logging for audits, and having a clear escalation path when the system produces something harmful."
What Service Companies Like TCS, Infosys, Deloitte and EY Actually Ask
Service companies like TCS, Infosys, Deloitte, EY, Cognizant, Capgemini, Wipro, Accenture, and PwC follow a predictable pattern: (1) a fundamentals screen (define LLM, transformer, embedding), (2) one applied scenario ("design a chatbot" or "reduce hallucinations"), and (3) "have you shipped anything?" Consulting roles lean more on business-value framing than deep internals. The fundamentals and scenario sections of this guide cover the first two rounds. For the third, have a project walkthrough ready, even if it is a personal build.
How to Prepare for a Generative AI Interview (A2-Week Plan)
Week1: Fundamentals and core concepts. Days1-2: LLMs, transformers, attention, tokens, embeddings. Days3-4: prompt engineering (zero-shot, few-shot, chain-of-thought). Days5-6: RAG (components, chunking, vector DBs, failure modes) versus fine-tuning (LoRA, PEFT). Day7: revise definitions out loud. Use the AI engineer roadmap if you find gaps.
Week2: Deep/technical + one project + mock interviews. Days8-10: LLM internals (self-attention, quantisation, hallucination), diffusion models, GANs, vector databases. Days11-12: build one small project end-to-end (a RAG chatbot over a PDF). Days13-14: practise every answer out loud or do mock interviews. The night before: skim this bank once and sleep. Understanding beats memorisation.
FAQs
What are the most common generative AI interview questions? The most common questions cover LLM definitions, transformer architecture, embeddings, RAG versus fine-tuning, prompt engineering techniques (zero-shot, few-shot, chain-of-thought), hallucination causes and mitigation, and scenario questions like "how would you design a RAG system." Expect at least one question on each of these in any GenAI interview.
How do I prepare for a generative AI interview as a fresher? Start with the fundamentals section of this guide: make sure you can define LLM, transformer, token, embedding, and hallucination clearly. Then learn the core concepts: prompt engineering and RAG basics. You do not need to have shipped a production system, but building one small project (even a simple RAG chatbot over a PDF) will set you apart. Follow the full generative AI roadmap for a structured learning path.
What is the difference between RAG and fine-tuning?
RAG adds external knowledge at query time by retrieving relevant documents and including them in the prompt. Fine-tuning changes the model's weights by training it on task-specific data. RAG is better for dynamic, frequently updated knowledge. Fine-tuning is better for adopting a specific style, format, or domain behaviour. RAG is cheaper and easier to update; fine-tuning requires GPU time and data curation. Many production systems use both.
Do generative AI interviews require coding?
Yes, for GenAI developer and engineer roles. Expect questions on Python libraries (transformers, LangChain, sentence-transformers), how to call LLM APIs, how to chunk and embed documents, and how to build a basic RAG pipeline. For consulting or use-case roles, coding is less emphasised, but understanding the implementation conceptually is still expected. Prepare a small code walkthrough for your GenAI project.
What questions do companies like TCS, Infosys and Deloitte ask on GenAI?
They follow a three-part pattern: a fundamentals screen (define LLM, transformer, embedding), one applied scenario (design a chatbot or reduce hallucinations), and one "have you shipped anything" question. Consulting roles lean more on business-value framing. The questions are not leaked or confidential; they follow the same patterns covered in this guide. Prepare the fundamentals and scenario sections thoroughly.
What is the difference between generative AI and agentic AI in interviews?
Generative AI refers to models that produce content (text, images, code) in response to a prompt. Agentic AI refers to systems that go beyond generation: they plan multi-step tasks, use external tools (APIs, databases, code execution), maintain memory, and make decisions autonomously. An LLM call is generative; an AI agent that searches the web, retrieves data, and writes a report is agentic. Interviewers test this distinction in scenario questions, not just definitions.
How many generative AI interview questions should I prepare?
Breadth across all five bands (fundamentals, core, technical, applied, behavioural) beats depth in one. Prepare at least 10 questions per band. This guide covers 50+, but mastering 40-50 solid answers across all bands is more valuable than memorising 100 questions from one category. Focus on understanding the concepts so you can handle follow-up questions that are not in any guide.
Reading answers is one thing: saying them under pressure is another. Practise your generative AI answers out loud with Scaler's AI mock interview and walk into the real round already warmed up.
