1 — Advanced Full-Stack .
NET Core
(AZ-204 & GenAI Integration)
Intro (15–20s)
“Hi — this is the Advanced Full-Stack .NET Core program: a 6-month, hands-on course that
pairs modern .NET backend development with frontend frameworks, Azure DevOps, and
practical GenAI integration to make developers job-ready.”
Curriculum highlights (35–45s)
• Backend (.NET Core) — [Link] Core, Web API, middleware, filters, custom middleware,
authentication/authorization (JWT, Azure AD), request/response pipeline, exception handling,
logging.
• Data & Patterns — EF Core, LINQ, repository/unit-of-work, migrations, connection pooling,
caching (Redis), transactions.
• Frontend — React or Angular: components, state management, routing, client-side form
validation, consuming REST APIs, CORS, authentication flow with JWT.
• Cloud & DevOps — Azure App Service, Functions, Blob Storage, Key Vault, Azure AD,
CI/CD pipelines in Azure DevOps, infrastructure as code.
• GenAI — Azure OpenAI/OpenAI API usage, prompt engineering basics, RAG
(retrieval-augmented generation), integrating LLMs for chatbots/code assistants.
• Practicals — 70+ labs, 3 projects, interview prep, resume review, unlimited batch access.
Project walkthrough (45–60s) — E-commerce Micro-app
Architecture: [Link] Core Web API (microservices-style modules) + React SPA. Data: SQL
Server (orders, users) + Redis cache. Auth: Azure AD B2C for SSO. CI/CD: Git repo → Azure
Pipelines → App Service. GenAI feature: product-recommendation assistant using an LLM +
RAG for product catalog. What you built: secure REST APIs, SPA with auth flow, payment mock
integration, deployment scripts, and a chatbot endpoint that answers product queries based on
catalog docs.
Likely questions + short answers (10–20s each)
Q: “How do you secure APIs?” — Use OAuth2/JWT, enforce scopes in middleware, validate
tokens via Azure AD, rate-limit and use Key Vault for secrets.
Q: “When to use caching?” — Cache read-heavy, less volatile data (product lists), use Redis for
distributed cache and set TTLs; hard-cache invalidation tied to write events.
Q: “What is RAG?” — Combine vector-search over documents with LLMs so the model
retrieves relevant context and avoids hallucination.
Closer (5–10s)
“I can demo the CI pipeline or walk through the LLM prompt flow if you want a live example —
thanks.”
2 — .NET Solution Architect Certification
Training
Intro
“Hello — the .NET Solution Architect program is a 6-month leadership track focused on
software architecture, system design, microservices, cloud-native patterns, and the operational
aspects needed for enterprise delivery.”
Curriculum highlights
• Architecture Fundamentals — architecture styles (monolith → microservices), quality
attributes (scalability, availability, maintainability), SOLID, domain-driven design (DDD) basics.
• Design Patterns & Anti-patterns — enterprise patterns, CQRS, event sourcing, circuit
breaker, saga pattern, when to avoid premature optimization.
• System Design & Scalability — load balancing, horizontal scaling, caching strategies,
read/write separation, database sharding, eventual consistency trade-offs.
• Microservices + Containers — decomposition strategies, API gateways (Ocelot), service
discovery, Docker, Kubernetes (AKS), observability (Prometheus/Grafana / Azure Monitor).
• DevOps & IaC — CI/CD design, blue/green and canary deployments, Terraform/ARM,
monitoring/SLIs, incident response.
• Soft Skills — technical leadership, design reviews, cost estimation, stakeholder
communication.
Project walkthrough — High-scale Order Processing System
Goal: design an order processing system for millions of daily events. Components: API
Gateway → Authentication → Order Service (stateless) → Payment Service → Inventory
Service. Infrastructure: AKS for services, managed PostgreSQL for OLTP, Redis for
session/carts, Kafka or Azure Service Bus for asynchronous messaging. Patterns used: CQRS
for read/write separation, Sagas for cross-service transaction coordination, retries and
dead-letter queues for resiliency. Delivery: Terraform for infra, GitOps pipelines, monitoring
dashboards, and chaos test to validate failure modes.
Likely questions + short answers
Q: “How would you design for eventual consistency?” — Use events for state propagation,
compensating transactions via sagas, idempotent consumers, and clear user UX to show
eventual status.
Q: “When to choose SQL vs NoSQL?” — SQL for transactional consistency; NoSQL
(document/Key-Value) for flexible schemas, high read throughput, or when denormalization
improves latency.
Q: “How to perform capacity planning?” — Model peak QPS, measure latency per operation,
compute resource needs with headroom, and run load testing.
Closer (5–10s)
“Happy to sketch a system on a whiteboard — tell me a business constraint and I’ll design a
resilient approach.”
3 — Azure AI & GenAI Engineer
Certification Training
Intro (15–20s)
“This 4-month Azure AI & GenAI Engineer program teaches practical model integration, Azure
AI services, deployment patterns, and production-grade considerations for LLMs and classical
ML.”
Curriculum highlights (35–45s)
• Foundations — Python (Pandas/NumPy), model evaluation basics, data preprocessing, and
building REST endpoints (FastAPI).
• Azure AI Services — Cognitive Services (Vision, Speech, Language), Document Intelligence,
Azure ML for model training and endpoints, Azure OpenAI or Azure AI Foundry.
• Generative AI & LLMs — prompt engineering, few-shot prompting, RAG pipelines (vector
DBs like Azure Cognitive Search, Milvus), fine-tuning vs adapters, cost control.
• MLOps & Governance — model versioning, CI/CD for models, monitoring (data drift,
performance), privacy, security and Responsible AI practices.
• Practicals — 4 projects, sandbox access, deployment to managed endpoints.
Project walkthrough (60–75s) — Document Processing + Chatbot
Use case: ingest invoices and contracts, extract entities, and provide a user chat interface to
query document contents. Pipeline: ingest PDFs → OCR & Document Intelligence → store
embeddings in vector DB → serve queries using RAG + Azure OpenAI → expose API via
FastAPI → host on Azure App Service/Function. Key production points: batching, retry logic,
embedding freshness strategy, cost control using temperature/rate limits, telemetry for user
queries and hallucination checks.
Likely questions + short answers
Q: “How do you reduce hallucinations?” — Use RAG with high-quality context, limit generation
length, include grounding prompts, validate critical facts via deterministic microservices.
Q: “When to fine-tune vs use prompts?” — Fine-tune for repeated domain-specific behavior or
safety constraints; use prompts/RAG for flexible, low-cost adaptions.
Q: “How to monitor model performance in prod?” — Track latency, accuracy on sampled
labeled queries, data drift metrics, and user feedback loops; set alerts for degradation.
Closer (5–10s)
“I can quickly show the prompt template and retrieval pipeline for the chatbot if you want to see
how we guard against hallucinations.”
4 — Java Microservices with AWS
Developer Certification Training
Intro (15–20s)
“This is a 4-month program focused on building production-ready Java microservices on AWS
using Spring Boot, container orchestration, and DevOps automation.”
Curriculum highlights (35–45s)
• Core Java & Spring — Spring Boot, Spring MVC, Spring Data JPA, security (Spring Security
+ JWT/OAuth), exception handling, testing (JUnit/Mockito).
• Microservices Patterns — decomposition, API contracts, circuit breaker (Resilience4j),
bulkhead, retry, distributed tracing.
• AWS Services — EC2, S3, RDS, DynamoDB/DocumentDB, Lambda for serverless, API
Gateway, SQS, SNS, Secrets Manager, CloudWatch.
• Containers & K8s — Docker builds, Helm charts, Kubernetes basics, EKS or k8s on EC2.
• CI/CD & Observability — GitHub Actions/CodeBuild/CodePipeline, automated infra via
CloudFormation/Terraform, logging/metrics with CloudWatch and OpenTelemetry integration.
Project walkthrough (60–75s) — Ride-hailing Microservices App
Modules: User Service, Driver Service, Booking Service, Payment Service. Each is a Spring
Boot microservice with its own DB (RDS/DynamoDB depending on access patterns).
Communication: REST for sync calls, SQS/SNS for async events (booking confirmation).
Deployment: Docker images → ECR → CodePipeline → EKS. Resilience: Resilience4j for
retries and circuit breakers; distributed tracing with OpenTelemetry and CloudWatch
dashboards. Security: API Gateway with Cognito for auth, Secrets Manager for DB credentials.
Likely questions + short answers
Q: “How to handle distributed transactions?” — Prefer eventual consistency with sagas; use
orchestrator (Saga pattern) or choreography with events; avoid two-phase commit in highly
distributed systems.
Q: “How to secure microservice secrets?” — Use AWS Secrets Manager, IAM roles for service
access, short-lived credentials, and least privilege.
Q: “When to use Lambda vs containers?” — Lambda for short, event-driven tasks with bursty
load; containers for long-running, stateful or complex services where dependencies matter.
Closer (5–10s)
“I can diagram the booking flow and show exactly how events flow between services if you
want to discuss edge cases.”