JD4 Track — Azure Agentic AI for Banking

Target role: Senior AI Engineer / Agentic AI Engineer — Banking & Financial Services on Microsoft Azure — the jd4.md role. This is the enterprise GenAI delivery archetype: the engineer a bank hires to ship Conversational AI, Document Intelligence, agentic workflow automation, and multimodal systems on Azure, to production, under regulatory scrutiny, serving large user bases in Arabic and English.

Why this track exists. The other three roles in AI Specialist/ target different jobs. JD1 is on-prem/air-gapped (Ollama, local RAG, QLoRA). JD2 is inference-systems/hardware (quantization, vLLM, TensorRT). JD3 is generic inference/orchestration plumbing at a startup. JD4 is none of those. It is Azure-managed, agentic, regulated-banking application engineering — a stack where you almost never touch a GPU, you call Azure OpenAI deployments, you ground answers in Azure AI Search, you orchestrate LangGraph / Microsoft Agent Framework / Foundry Agent Service agents, and every design decision is shaped by security, compliance, auditability, and cost because it's a bank. This track is the ~90% of JD4 that the other three never touch.

The promise of this track: from "I have used the OpenAI API once" → to an engineer who can architect a banking-grade agentic RAG platform on Azure, defend its security/compliance/cost on a whiteboard, build it with FastAPI + Cosmos + CI/CD, evaluate it for groundedness, and walk into the interview tomorrow able to answer any question on the stack from first principles.

Table of Contents

• 1. What JD4 Actually Demands (decoded)
• 2. Gap Analysis vs. the Existing Folder
• 3. The Mental Model: The Azure Agentic Banking Stack
• 4. Curriculum — Knowledge Modules
• 5. Curriculum — Labs
• 6. The Numbers & Facts Every Candidate Knows Cold
• 7. Demand Primer: The Business of Banking AI
• 8. Study Order & Milestones
• 9. The Interview-Tomorrow Fast Path
• 10. References

1. What JD4 Actually Demands (decoded)

The job description is HR-compressed. Decoded into engineering competencies:

The one-sentence job: Ship Azure-native, agentic, grounded GenAI applications into a regulated bank — fast, safe, observable, and cheap enough to scale to large user bases.

2. Gap Analysis vs. the Existing Folder

Verdict: the existing labs demonstrate local/on-prem application skill (JD1) and systems skill (JD2). JD4 is managed-Azure + agentic + regulated-banking, which is a third axis. On its own, the existing folder would get you screened out of JD4 at "tell me how you'd build this on Azure AI Search with a semantic reranker" — because you'd reach for ChromaDB. This track is the missing 90%.

3. The Mental Model: The Azure Agentic Banking Stack

Memorize this layered picture — it is the whiteboard you draw in the interview when asked "how would you architect this?"

┌────────────────────────────────────────────────────────────────────────────┐
│  L8  Channel        Web / Mobile / Teams / WhatsApp / IVR  (Arabic + English)│
├────────────────────────────────────────────────────────────────────────────┤
│  L7  API / BFF      FastAPI (async, SSE streaming) · APIM · Entra ID auth    │
├────────────────────────────────────────────────────────────────────────────┤
│  L6  Agent / Orchestr.  LangGraph / Microsoft Agent Framework / Foundry      │
│                         Agent Service — state, tools, routing, HITL, memory  │
├────────────────────────────────────────────────────────────────────────────┤
│  L5  Reasoning      Azure OpenAI deployments (gpt-4o / 4.1 / o-series)        │
│                     prompts · function/tool schemas · structured output      │
├────────────────────────────────────────────────────────────────────────────┤
│  L4  Knowledge / Retrieval   Azure AI Search (hybrid BM25+vector+semantic)   │
│                     embeddings (text-embedding-3-large) · chunking · filters │
├────────────────────────────────────────────────────────────────────────────┤
│  L3  Ingestion      Azure AI Document Intelligence · AI Vision · OpenCV/YOLO │
│                     (statements, KYC, cheques, IDs) → structured JSON        │
├────────────────────────────────────────────────────────────────────────────┤
│  L2  Data / State   Cosmos DB (conversations, state, vectors) · Blob · SQL   │
├────────────────────────────────────────────────────────────────────────────┤
│  L1  Platform / Trust  Entra ID · Managed Identity · Key Vault · Private      │
│                     Endpoints · Content Safety · Azure Monitor · Defender    │
├────────────────────────────────────────────────────────────────────────────┤
│  L0  Delivery       Git · CI/CD (GitHub Actions / Azure DevOps) · Bicep IaC  │
│                     · Docker → ACR → Container Apps / AKS · eval gates        │
└────────────────────────────────────────────────────────────────────────────┘

A strong candidate can start at any layer from a requirement ("the bot must never hallucinate a customer's balance") and walk the stack: ground balance in a tool call to core-banking, not the LLM (L5/L6); enforce with a system prompt + structured output (L5); verify with a groundedness evaluator (eval gate, L0); log the tool call for audit (L1). This track builds that traversal, layer by layer. L1 (Trust) and L0 (Delivery) are what make it "banking-grade" rather than a demo — they are where senior candidates separate from juniors.

4. Curriculum — Knowledge Modules

Each is a deep, from-first-principles document with its own TOC, worked examples, "under the hood" sections, production notes, common misconceptions, and references — to the depth standard of this curriculum.

5. Curriculum — Labs

Fully runnable today: 10 labs, 90 passing tests, all offline — no Azure account, no network, no model downloads. Each lab implements the real architecture in pure Python behind pluggable provider interfaces (Fake*/Local* by default; a documented one-class swap to Azure* to go live), with a run.py demo and a pytest suite. Run them all from labs/. Labs 01–08 build toward the capstone (a banking agentic assistant exercising every line of the JD); 09 (Streamlit/Flask PoC UI) and 10 (MCP + Semantic Kernel) cover the good-to-haves. Plus reference material: a Cost & PTU sizing calculator, a Glossary, and a printable Cheat-Sheet.

6. The Numbers & Facts Every Candidate Knows Cold

You should recite and use these without looking them up. (Derivations and current values live in the modules.)

1. A token ≈ 4 characters ≈ ¾ of a word in English; Arabic and code are less efficient (more tokens/word). You bill and budget context in tokens.
2. Azure OpenAI capacity is TPM (tokens-per-minute) and RPM (requests-per-minute) quota, or PTU (Provisioned Throughput Units) for reserved, predictable latency. PAYG = shared, bursty; PTU = reserved, costed monthly. Banks at scale buy PTUs.
3. text-embedding-3-large → 3072 dims (configurable down); text-embedding-3-small → 1536. Embedding dim sizes your vector index and Cosmos vector cost.
4. Hybrid search = BM25 (keyword) + vector (semantic), fused with Reciprocal Rank Fusion (RRF), then optionally re-ranked by the semantic ranker (a cross-encoder). Hybrid+semantic beats pure-vector on almost every enterprise benchmark.
5. RAG grounds facts at retrieval time; fine-tuning bakes in style/format. For a bank's changing facts (rates, policies, balances) → RAG/tools, never fine-tune.
6. Never put a live number (balance, rate) in the model's mouth — fetch it with a tool/function call to a system of record; the LLM only phrases it. This is the single most important banking-AI principle.
7. A token is generated autoregressively: prefill the prompt once, then decode one token at a time, each conditioned on all prior tokens. This is why output length drives latency and cost.
8. Cosmos DB is billed in RU/s (Request Units/sec) and partitioned by a partition key; a hot partition or a cross-partition query is the classic scaling failure. Pick the partition key on the highest-cardinality access pattern (e.g. userId or conversationId).
9. Content Safety has 4 harm categories (hate, sexual, violence, self-harm) at severity 0–7, plus Prompt Shields (jailbreak/injection) and Groundedness detection. It runs as an input and output filter.
10. Groundedness / faithfulness = "is every claim in the answer supported by the retrieved context?" It is the RAG quality metric in banking; you measure it with an LLM-judge evaluator (RAGAS / Foundry).
11. The agent loop: observe → think (LLM) → act (tool) → observe result → repeat → finish. LangGraph makes the loop a graph with durable state so it can pause (human approval), resume, retry, and be audited.
12. MCP (Model Context Protocol) standardizes how an agent discovers and calls tools/resources via a client–server JSON-RPC protocol — write a tool once, any MCP-aware host uses it.
13. Defense in depth for a bank: Private Endpoints (no public egress) + Managed Identity (no keys in code) + Key Vault (secrets) + Content Safety (in/out) + PII redaction + full audit logging + human-in-the-loop on high-risk actions.
14. $/1M tokens is your unit cost; cut it with prompt caching, smaller models for routing/classification, retrieval-trimmed context, and PTUs at scale.

7. Demand Primer: The Business of Banking AI

A senior engineer doesn't just wire APIs — they understand why a bank pays and what a bank fears. This is the commercial/regulatory context that makes you a "trusted engineer," not just an implementer.

Why this role exists now

By 2025–2026 every large bank ran GenAI pilots; the survivors are now in production at scale, and the bottleneck is engineers who can ship safely on a compliant cloud. Microsoft Azure is the default regulated-enterprise cloud (Azure OpenAI's data-handling commitments, EU/regional data residency, the Microsoft enterprise relationship, the Foundry governance story). Banks in the GCC/UAE (the Arabic requirement is a tell — likely a Gulf or MENA bank) standardize on Azure for exactly these reasons. The work has moved from "can GenAI do this?" to "ship it without a regulatory incident, and make it cheap enough for millions of customers."

The use cases a bank actually buys (and you'll be asked about)

What a bank fears (and every interviewer probes)

1. Hallucination of a fact that costs money or breaks a rule. → grounding + tools + eval gates.
2. Data leaving the boundary (PII to a public model, cross-border). → Azure data commitments, Private Endpoints, residency.
3. No audit trail. → log every prompt, retrieval, tool call, decision; immutable storage.
4. An autonomous action that shouldn't have been autonomous. → human-in-the-loop on high-risk steps.
5. Model risk / regulator non-compliance (SR 11-7, EU AI Act, local central-bank rules). → documentation, validation, monitoring.
6. Cost blowups at scale. → caching, model tiering, PTU planning.

A senior candidate answers every technical question with the relevant fear addressed. That instinct — "here's the design, and here's how it's safe/auditable/cheap" — is what gets you hired. The whole of K09 trains it.

8. Study Order & Milestones

Phase A — Platform & fundamentals (you can provision and reason about the stack). K00 → K01. Milestone: explain Azure OpenAI deployment + TPM/PTU + Private Endpoint + why the model hallucinates, from memory.

Phase B — Ground it (RAG). K02 + Lab 01. Milestone: build a hybrid+semantic RAG over banking docs with citations; explain RRF and reranking on a whiteboard.

Phase C — Make it act (agents). K03 + Lab 02. Milestone: a LangGraph agent that routes RAG vs tool vs refuse, with a checkpoint and a human approval node.

Phase D — Feed it the bank's documents & images. K04 → K05 + Labs 03, 04. Milestone: extract a statement to JSON and OCR an Arabic cheque correctly.

Phase E — Prompt, ship, and run it. K06 → K07 + Lab 05. Milestone: FastAPI+Docker+Cosmos+CI/CD deploy; a hardened system prompt.

Phase F — Prove it's safe. K08 → K09 + Lab 06. Milestone: a groundedness eval gate + content safety + PII redaction; answer the 5 banking fears.

Phase G — Capstone & interview. Lab 07 + interview-prep/. Milestone: pass a mock system-design ("design a banking conversational AI on Azure") and the rapid-fire.

If the interview is tomorrow, do not start at Phase A. Use §9.

9. The Interview-Tomorrow Fast Path

You have one evening. Spend it like this (≈4–5 hours, in order of marginal value):

1. Interview-Day Battle Plan (30 min) — the structure, the STAR stories, what to say in the first 2 minutes.
2. Concepts Rapid-Fire (90 min) — read every Q&A out loud. These are the screening questions.
3. System-Design Walkthroughs (60 min) — internalize the one reference architecture (§3 stack) and the 4 use-case variants. Be able to draw it.
4. Azure Services Deep-Dive Q&A (45 min) — the service-by-service "do you actually use this?" questions.
5. Behavioral & Banking-Domain (30 min) — the "tell me about a time" + "how is this safe for a bank" answers.
6. Skim §6 numbers above until you can recite them. (15 min)

If you have time for hands-on, do Lab 01 (RAG) end-to-end with the local fallback — being able to say "I built this last night" is worth more than any answer.

The 60-second self-introduction to memorize is in the Battle Plan.

10. References

Authoritative sources, current as of 2026. Each knowledge module has its own deeper list.

• Azure OpenAI Service — Microsoft Learn docs (learn.microsoft.com/azure/ai-services/openai).
• Azure AI Search — docs incl. vector search, hybrid search, semantic ranker, integrated vectorization.
• Azure AI Document Intelligence — docs (prebuilt/layout/custom/composed models).
• Azure AI Vision — Image Analysis & Read OCR docs; Florence foundation model.
• Azure AI Foundry / Microsoft Foundry — Foundry Agent Service docs (built on the OpenAI Responses API); model catalog; evaluators.
• Microsoft Agent Framework — Azure blog & Microsoft Learn (convergence of Semantic Kernel + AutoGen, public preview Oct 2025).
• LangChain / LangGraph — official docs (graphs, state, checkpoints, human-in-the-loop).
• Model Context Protocol (MCP) — modelcontextprotocol.io (Anthropic, Nov 2024).
• RAG — Lewis et al., "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks" (2020). RRF — Cormack et al. (2009).
• RAGAS — Es et al., "RAGAS: Automated Evaluation of Retrieval Augmented Generation" (2023).
• Azure AI Content Safety — docs (harm categories, Prompt Shields, Groundedness detection).
• Azure Cosmos DB — docs (NoSQL API, partitioning, RU/s, vector search / DiskANN).
• Model risk — US Federal Reserve SR 11-7 ("Guidance on Model Risk Management"); EU AI Act (2024). NIST AI RMF (2023).
• AI-102 — Study guide for Exam AI-102 (Microsoft Learn) — ⚠️ retires 2026-06-30; check Learn for the successor.

Each module restates the load-bearing facts in full so you never take a number on faith — per the depth standard of this curriculum.