Agents or plain automation?
Most engineers cannot yet say when an agent earns its cost and when a deterministic script is simply better. That judgement is the first thing interviewers probe.
Applied agentic AI · AI-native quality engineering
Become an AI-native test engineer and AI engineer in 100 days.
Software quality has entered an agentic era. Systems now reason about goals, call tools, generate and heal their own tests, and run inside real CI/CD pipelines. This program takes you from scripted automation to designing, evaluating and defending production AI systems — taught from production code, in a cohort of 35.
100days live
35+sessions
8+1projects
35seats / cohort
AI·QE pipeline you will buildlive
01Ingest requirementsRAG
02Plan & generate testsagents
03Author Playwright specsMCP
04Execute & self-healruntime
05Evaluate & guardevals
06Ship & observeCI/CD
Every stage is a working module in the curriculum — not a slide.
The shift
Calling an LLM API is easy. Making one behave inside a quality pipeline is not.
AI systems no longer just generate text. They reason about goals, call tools, generate and heal tests, and operate inside real delivery pipelines. That changes what it means to be a test engineer — and it has opened a gap that most QA professionals have not yet crossed.
Engineers building AI into quality work run into the same wall every time: hallucinated test steps, flaky locators, weak orchestration, no evaluation layer, and token costs nobody budgeted for. This program is built to close exactly that gap by developing real engineering judgement, not tool familiarity.
How we teach itFrameworks that survive production
Building an AI test framework that is reliable, grounded and cost-aware is a different discipline from calling an LLM API. Hallucinated steps, flaky locators and runaway token spend are the usual casualties.
Defending the design
You will be asked to explain failure modes, latency budgets and why you chose one architecture over another. Reasoning out loud under pressure is a trainable skill, and we train it.
Four pillars
A program built around engineering judgement
Not a demo-based course. You work on real systems, analyse failures, practise structured thinking, and learn to defend decisions clearly.
AI engineering & agentic systems
Design, build, evaluate and operate production-grade AI applications, agents and RAG systems used inside real workflows.
AI-native test engineering
Apply AI engineering to quality: AI-powered test generation, self-healing automation, Playwright and MCP pipelines, and AI evaluation of AI systems.
AI interview preparation
Explain agent architectures, trade-offs, failure modes and system decisions with clarity — for AI Engineer, AI Test Engineer and Architect panels.
Career support
Resume optimisation, LinkedIn positioning, mock interviews and guidance through an active job search, so preparation converts into offers.
Choose your track
Four programs, one engineering spine
The programs share a common AI foundation but differ in depth, projects, tools and career outcomes. Pick the one that matches where you are starting from.
Flagship · 100 days
AI Testing & AI Engineering Mastery
The full track. Agents, RAG, MCP, Playwright generation, self-healing automation, evaluation and guardrails — then deployment, interview prep and career support.
Explore the flagship
Working professionals
AI-Powered Professional
Do not replace your experience — add AI to it. For functional QA, automation engineers, SDETs, BAs and DevOps engineers who want to stay ahead of their own market.
See the track
Graduates
AI Engineer Launchpad
From graduate to AI engineer. Python and software engineering foundations through RAG, agents, evaluation, guardrails and cloud deployment, ending in a production-style capstone.
See the track
Developers
Production AI Agent Engineer
Build AI. Build agents. Build production systems. Advanced RAG, agent engineering, MCP and A2A, evaluation engineering, observability and an enterprise agent platform capstone.
See the track100 days · three tracks · one capstone
The curriculum, week by week
Every topic is tied to a real engineering decision: when to use agents, when not to, and how to control cost, latency, hallucination and reliability.
Track 1 — AI Engineering
- Set up your AI engineering environment the way real teams do.
- Refresh Python, APIs and testing fundamentals.
- See how input, reasoning, tools and responses connect end to end.
Stack: Python · VS Code · Git & GitHub · Postman
- Learn how LLMs reason and, more importantly, where they fail.
- Master zero-shot, few-shot, chain-of-thought and prompt chaining.
- Design structured outputs and system prompts that behave predictably.
- Engineer context windows, tokens and embeddings deliberately.
Stack: OpenAI · Claude · Gemini · DeepSeek · Pydantic
- Understand why retrieval fails and how to measurably improve accuracy.
- Design agents that answer only from approved documents.
- Build RAG and GraphRAG pipelines with real vector and graph stores.
- Ship a retrieval system you could genuinely deploy inside your company.
Stack: Pinecone · Qdrant · FAISS · Neo4j · Embeddings
- Learn when agents make sense — and when plain code is the better answer.
- Break complex work into planner, executor and reviewer roles.
- Build orchestrated workflows with LangChain and LangGraph.
- Understand coordination cost, latency budgets and failure modes.
Stack: LangChain · LangGraph · OpenAI Agents SDK
- Learn why structured tool communication beats free text at scale.
- Build and wrap MCP servers for real tools.
- Connect agents to browsers, databases and test runners safely.
Stack: MCP Protocol · Playwright MCP · FastAPI
Track 2 — AI-Native Testing
- Generate grounded test cases from requirements and Jira stories.
- Control hallucination through grounding and structured outputs.
- Decide test count and type distribution with LLM planners.
Stack: Jira · Pydantic · Pytest · RAG
- Generate Playwright TypeScript specs from natural language.
- Solve locator uniqueness and section-scoped disambiguation.
- Use accessibility snapshots and ref-based selection over brittle XPath.
- Replace hardcoded waits with reliable dynamic wait strategies.
Stack: Playwright · Playwright MCP · TypeScript
- Design three-layer healing: generation-time, runtime and post-run patching.
- Score locator candidates with fuzzy matching against golden flows.
- Track heal history and flakiness statistics your team can act on.
Stack: DOM capture · Fuzzy scoring · Heal dashboards
- Evaluate agents at both component and system level.
- Protect agents from prompt injection and misuse.
- Add guardrails, schema validation and approval flows for risky actions.
- Build an agent safe enough for customer-facing use.
Stack: LangSmith · Ragas · DeepEval · Guardrails
Track 3 — Production & Career
- Learn when fine-tuning is worth the cost versus prompting and RAG.
- Prepare datasets for domain adaptation.
- Make trade-offs you can explain to stakeholders and architects.
Stack: Hugging Face · Datasets · Cost modelling
- Build AI services with FastAPI and package them with Docker.
- Wire CI/CD with GitHub Actions; manage secrets and configuration.
- Track latency, cost and failure rates; design rollback strategies.
Stack: FastAPI · Docker · GitHub Actions · CI/CD
- Design a complete AI quality system from scratch.
- Integrate retrieval, agents, execution, evaluation and safety.
- Deploy and test it like a real production service.
- Present and defend your architecture the way a senior engineer would.
Stack: Full stack · Live architecture review
- Practise AI system design interviews with case-based reasoning.
- Explain agent architectures, trade-offs and failure modes clearly.
- Optimise your resume and LinkedIn for AI-native roles.
- Sit mock interviews with structured behavioural coaching.
Stack: Mock panels · Resume clinic · LinkedIn audit
- Revisit classes and assignments as often as you need.
- Get guidance during your active job search.
- Convert preparation into offers.
Stack: Lifetime recordings · Community access
What you build
Eight guided projects, then an enterprise capstone
Each project builds on the one before it and mirrors a real production system. You leave with a portfolio you can walk an interviewer through line by line.
01
First LLM-Powered Test Agent
Build your first LLM-powered agent and understand exactly how agents differ from scripts and chatbots. Learn how LLMs act as reasoning engines, how tools and memory fit into agent architecture, and how agent behaviour is actually controlled.
02
RAG Test-Case Generator (with evaluation)
Build a document-grounded test-case generator using retrieval-augmented generation. Ingest requirements and user stories, design chunking strategies, retrieve relevant context, and evaluate retrieval quality so hallucinated test steps never reach your suite.
03
Multi-Agent QA Pipeline
Design a multi-agent system on a Planner → Executor → Critic pattern. Agents collaborate to plan coverage, generate cases and critique outputs, demonstrating task decomposition, coordination and closed quality loops.
04
Self-Healing Test Automation Agent
Build a self-healing automation layer with golden-flow DOM capture, fuzzy locator scoring and LLM-based runtime re-resolution. Track every heal in a history dashboard and learn when healing genuinely helps versus when it quietly hides real defects.
05
NLP-to-Playwright Script Generator (MCP)
Generate Playwright TypeScript specs from natural-language steps using the Model Context Protocol. Solve locator uniqueness, section-scoped disambiguation and ref-based element selection — the hardest real problems in AI test generation.
06
Agentic API & Data Validation Agent
Build a vertical agent that validates APIs and data pipelines. Handle authentication, rate limits, retries and caching, and return structured, schema-validated results that a real CI system can consume.
07
AI Evaluation & Observability Harness
Design dataset-based evaluations and regression tests for LLM systems. Trace agent decisions with LangSmith, track cost, latency and failure rates, and turn feedback into measurable quality improvements.
08
Production-Ready QA Copilot
Build a production-ready quality copilot with RAG, safety guardrails, evaluation pipelines and cost/latency dashboards, deployed with Docker and GitHub Actions. Learn to operate AI agents responsibly under real-world constraints.
The stack
Tools you will use, not just hear about
A core stack taught to hands-on mastery, and an exposure layer so you can compare and justify alternatives in an interview.
Languages & dev tools
- Python
- VS Code
- Git & GitHub
- TypeScript
Application & API
- FastAPI
- Pydantic
- Pytest
- REST
Agent frameworks
- LangChain
- LangGraph
- MCP Protocol
- Agents SDK
LLMs & APIs
- OpenAI
- Claude
- Gemini
- DeepSeek
- Ollama
Retrieval & data
- RAG & GraphRAG
- Pinecone
- Qdrant
- FAISS
- Neo4j
- Embeddings
- pgvector
Testing & execution
- Playwright
- Playwright MCP
- Self-healing automation
- Selenium
Evaluation & safety
- LangSmith
- Ragas
- DeepEval
- Guardrails
- OWASP LLM Top 10
Deployment & ops
- Docker
- GitHub Actions
- CI/CD
- PostgreSQL
- Redis
AI coding tools
- Cursor
- Claude Code
- GitHub Copilot
- Codex
Your mentor
Taught from production code, not slides
Your mentor is a Quality Engineering Director with more than 17 years in test automation and enterprise quality engineering across banking and healthcare, and the creator of a multi-agent AI quality platform built on 30 specialised agents spanning generation, execution, intelligence, compliance and operations.
The self-healing frameworks, MCP-based Playwright generation, RAG pipelines and evaluation harnesses you build in this program are the same architectures running in real enterprise engagements today. One accountable mentor stays with your cohort across all 100 days — not a rotating cast of instructors.
Why the single-mentor model matters. Interview readiness is not transferable between instructors. The person who reviews your architecture in week 6 is the person who runs your mock interview in week 15, which means the feedback compounds instead of resetting.
Built for three audiences
Wherever you are starting from
Working professionals in India
Weekend live classes in IST, weeknight office hours, and a curriculum designed around the constraints of a full-time delivery job. Local hiring context for 15 cities.
Indian professionals in the US
You already have the domain depth. What is missing is the AI engineering vocabulary and a portfolio that survives a US technical panel. A US-friendly weekend slot makes it workable alongside a demanding job.
Indian students in the US
For F-1, OPT and STEM-OPT students who need production-style projects rather than coursework, and interview preparation that matches how US teams actually hire AI engineers.
Program details
How the 100 days are structured
| Duration | 100 days live and self-paced · 35+ hands-on sessions · lifetime access to recordings |
|---|---|
| Weekends | Mentor-led live interactive classes, Saturday and Sunday (plus a US-friendly slot) |
| Weekdays | Pre-class material and personal practice, 5–10 hours |
| Weeknights | Doubt-clearing and office hour sessions |
| Assessments | Mini-assignments · 8 live guided projects · 1 capstone |
| Cohort size | 35 participants, with personal mentorship and one-on-one assistance |
| Typical load | 15–20 hours per week |
Career outcomes
Roles this program prepares you for
Titles vary by employer, but the underlying capability is the same: you can design an AI system, evaluate it honestly, and explain why you built it that way.
- AI Test Engineer
- AI Quality Engineer
- AI Engineer
- GenAI Engineer
- Agentic AI Engineer
- RAG Engineer
- LLM Engineer
- AI Automation Architect
- AI Platform Engineer
- AI Solutions Architect
Where our learners join from
Live cohorts across India, and a weekend slot built for the US
Classes are online and mentor-led, so your city decides your commute, not your curriculum. These pages cover local hiring context, batch timings and the employers actively recruiting AI-native engineers.
Questions
Common questions before you enrol
Manual and automation test engineers, SDETs, QA leads and architects, software developers, DevOps engineers, and engineering managers moving into AI-first delivery. There is also a dedicated track for 2025 and 2026 graduates. You need working knowledge of testing or programming fundamentals — not prior AI experience.
No. This is an AI engineering program, not a data science program. You will not be training models from scratch. You will be designing, building, evaluating and operating systems that use models — which is what the overwhelming majority of AI roles actually involve. The self-paced bonus tracks cover AI, ML, NLP and transformer fundamentals if you want the theory alongside.
Learners typically spend 15–20 hours a week. That breaks down as roughly 10 hours of live weekend classes, one guided project lab, and 5–10 hours of weekday pre-class material and personal practice. Weeknight office hours are available for doubt clearing.
Both. Live mentor-led interactive classes run on Saturday and Sunday, with weeknight doubt-clearing sessions. Every session is recorded and you keep lifetime access, which is what makes the program workable across time zones.
Yes. We run a US-friendly weekend slot alongside the India cohort, and every class is recorded within hours. Many of our US-based learners attend live on weekends and catch office hours asynchronously. See the US professionals page for details.
We provide placement assistance, not a job guarantee — and we would be suspicious of anyone who promises otherwise. What you get is a portfolio of eight production-style projects plus a capstone, resume and LinkedIn optimisation, mock interviews for AI Engineer and AI Test Engineer panels, and guidance through your active job search.
Because the mentorship model is personal. One accountable mentor stays with the cohort across all 100 days, reviews your project work, and sits your mock interviews. That does not scale to 300 people in a webinar.
Eight live guided projects — an LLM test agent, a RAG test-case generator with evaluation, a multi-agent QA pipeline, a self-healing automation agent, an NLP-to-Playwright generator over MCP, an agentic API validation agent, an evaluation and observability harness, and a production QA copilot — followed by one of three enterprise capstones. See the projects page.
Next cohort
The next cohort is 35 seats. Then it closes.
Reserve your place, get the detailed syllabus, and talk to admissions about which track fits your background.
Cohort snapshot35 seats
01100 days live + self-paced15 wks
02Mentor-led weekend classes10 hrs/wk
038 guided projects + capstoneportfolio
04Interview prep & career supportongoing
Weeknight office hours · lifetime access to recordings · one accountable mentor across all 100 days