AI engineering · Corporate teams only · 40 hours
Production AI Engineering Training
A private 40-hour programme for company engineering teams building retrieval-augmented generation (RAG) systems, controlled agent workflows and Model Context Protocol (MCP) integrations — with evaluation, security and operations treated as engineering work.
Learning as an individual rather than with your company’s team? See the AI Engineering Course for individual developers
- Duration
- 40 hours · onsite: 5 × 8 h or 10 × 4 h
- Cohort
- Confirmed in proposal
- Delivery
- Corporate onsite or private live online
- Level
- Advanced · Python required
What is the Production AI Engineering Training course?
Production AI Engineering Training is a private, 40-hour, instructor-led Technovids programme for company engineering teams that build LLM applications. Engineers practise RAG pipelines, stateful agent workflows, tool calling and MCP servers, then test them with evaluation sets, security checks and human-approval points. Onsite training can run as five 8-hour days or ten 4-hour days; a private live-online session plan is agreed separately. Participants need working application Python.
Is this the right course for you or your team?
Who it is for
- Backend and full-stack engineers assigned to LLM features
- ML engineers and data scientists moving prototypes into services
- Tech leads and architects choosing retrieval and agent designs
- Platform and DevOps engineers responsible for AI services in production
Situations it fits
- A RAG prototype works in a demo but answers are unreliable on real documents
- Agent workflows need clear control, retries and human approval before they touch real systems
- The team is planning MCP servers or tool integrations and needs a security model
- Nobody can say whether a change made the system better or worse
- Engineers use different frameworks and patterns with no shared approach
Prerequisites
- Strong intermediate Python: functions, classes, type hints, exceptions, API calls and virtual environments
- Basic async Python, FastAPI, SQL and Git strongly recommended
- Hands-on familiarity with at least one LLM assistant or API
- A laptop prepared using the lab setup instructions sent before the course
Which AI engineering programme fits?
Technovids offers several AI engineering routes. They differ in who attends and how the learning is organised.
| Course | Best for | Choose it when |
|---|---|---|
| Production AI Engineering Training This course | Company engineering teams — private training only | Choose this when a company wants a private 40-hour programme for its engineers, scoped to the team’s stack and projects. |
| AI Engineering Course | Individual developers | Choose it when you are learning as an individual rather than through a company programme. |
| 1:1 AI Engineering Mentorship | One engineer, one mentor | Choose it for a three-month, one-to-one programme built around an individual’s own projects. |
| Claude Code Training | Developers adopting an AI coding assistant | Choose it to use Claude Code for day-to-day development work, rather than to build and operate AI applications. |
| AI Programming with Python | Engineers not yet ready for this course | Choose it first when participants need the backend Python skills — FastAPI, async, APIs and testing — this programme assumes. |
The gap between an AI demo and a system a team can run
Many teams can build a working demonstration. The harder work is making retrieval dependable, keeping agents under control, and knowing whether a change helped.
| Task | The usual problem | What participants practise |
|---|---|---|
| Retrieval quality | Answers are fluent but draw on the wrong passages, or miss the right ones. | Chunking, hybrid search, metadata filters and re-ranking, measured against a test set. |
| No way to measure | Changes to prompts, models or chunking are judged by trying a few questions. | Build an evaluation set with agreed metrics and thresholds, and run it on every change. |
| Uncontrolled agents | Multi-step workflows loop, fail silently or take actions nobody approved. | Explicit state, conditional routing, retries and human-approval interrupts. |
| Tool and data access | Integrations get broad credentials because narrow ones take longer to set up. | Least-privilege tool design, scoped tokens and a permission matrix for each tool. |
| Untrusted input | Retrieved documents and tool results can carry instructions of their own. | Test for prompt injection, validate outputs and keep instructions separate from data. |
| Operating the system | There is no tracing, no owner for incidents and no way back after a bad release. | Tracing, audit events, versioned prompts and models, and a rollback plan. |
What participants will be able to do
By the end, participants should be able to design, build and test the main parts of a production LLM application — and explain the trade-offs behind each decision.
Design a RAG pipeline
Choose chunking, embedding, search and re-ranking approaches for a given corpus and justify them.
Evaluate retrieval and answers
Build a test set, pick metrics and thresholds, and compare changes against a baseline.
Build controlled agent workflows
Model a multi-step workflow with explicit state, routing, retries and human-approval points.
Design reliable tool calls
Write tool schemas and structured outputs that fail safely and are easy to validate.
Build and secure an MCP server
Expose a small set of tools through MCP with authentication, scoped permissions and error handling.
Test for LLM-specific risks
Probe for prompt injection, sensitive-data disclosure, excessive agency and improper output handling.
Instrument the system
Add tracing and audit events so failures can be found, explained and reproduced.
Prepare a release decision
Assemble evidence for a go/no-go review: evaluation results, known limits, owners and a rollback plan.
Role-based use cases
How each team applies it to real work
Engineers from different roles attend together. Each takes something different from the same labs, and some decisions always stay with the team.
Backend engineers
- Typical responsibility
- Building the API, retrieval and tool-calling code behind an LLM feature.
- What they practise
- RAG pipelines, structured outputs, tool schemas and error handling in a FastAPI service.
- What to verify
- That outputs are validated before use and failures are handled, not swallowed.
- Decision that stays with the team
- Which data the feature may read, and which actions it may take.
ML engineers & data scientists
- Typical responsibility
- Choosing models and embeddings and measuring quality.
- What they practise
- Evaluation sets, retrieval metrics, baselines and comparison runs.
- What to verify
- That the test set reflects real questions and scores are not tuned to it.
- Decision that stays with the team
- The quality threshold that is good enough to release.
Tech leads & architects
- Typical responsibility
- Deciding how retrieval, agents and integrations fit together.
- What they practise
- Trade-offs between simple chains, stateful graphs and multi-agent designs.
- What to verify
- That the simplest design that meets the requirement was chosen.
- Decision that stays with the team
- Framework and vendor choices, and the long-term maintenance cost.
Platform & DevOps engineers
- Typical responsibility
- Deploying, monitoring and operating AI services.
- What they practise
- Tracing, audit events, secrets handling, versioning and rollback.
- What to verify
- Latency, cost and error rates under realistic load, not only in a demo.
- Decision that stays with the team
- When a release is rolled back, and who is on call for it.
Security-minded engineers
- Typical responsibility
- Reviewing agents, tools and MCP servers before they reach users.
- What they practise
- Threat models, permission matrices and prompt-injection tests.
- What to verify
- That each tool has only the access it needs and tokens are scoped to it.
- Decision that stays with the team
- Residual risk acceptance, which follows your organisation’s own review process.
Engineering managers
- Typical responsibility
- Planning AI work, staffing it and reporting on it.
- What they practise
- How to read evaluation results and what a release checklist should contain.
- What to verify
- That claims about quality are backed by test results.
- Decision that stays with the team
- Priorities, ownership and whether a use case should be built at all.
What the programme covers, and how the stack is chosen
The four areas below are covered in every delivery. Specific frameworks, vector stores and model providers are chosen to match your stack wherever practical.
Retrieval and RAG
Core
Grounding answers in your approved documents and data.
Covers
- Chunking, embeddings and vector search
- Hybrid search, metadata filtering and re-ranking
- Query rewriting and context compression
- Citations and source traceability
Depends on
- A vector store — managed or self-hosted, agreed before delivery
- Representative, non-sensitive documents for the labs
What to verify
Check that retrieved passages actually support the answer, not just that the answer sounds right.
Agent workflows
Core
Multi-step workflows that stay observable and under control.
Covers
- Stateful graphs with LangGraph
- Routing, retries and failure handling
- Human-approval interrupts before consequential actions
- When a single agent is enough, and when it is not
Depends on
- Approved model API access; account, key and usage arrangements agreed before delivery
What to verify
Confirm every write or external action has an explicit approval point and a way to resume or abandon it.
Tool calling and MCP
Core
Connecting models to tools and data. MCP is an open-source standard for connecting AI applications to external systems.
Covers
- Tool schemas and structured outputs
- Read-only and write tools with different controls
- Building an MCP server and connecting a client
- Authentication and scoped permissions
Depends on
- Sandboxed or test versions of any systems the labs connect to
What to verify
Check each tool’s permissions and token scope against what it needs; the MCP specification forbids passing through tokens not issued for the server.
Evaluation, security and operations
Core — across every module
The work that decides whether a system is ready to release and safe to run.
Covers
- Evaluation sets, metrics and release thresholds
- Prompt-injection and data-disclosure testing
- Tracing, audit events and incident ownership
- Versioning, change control and rollback
What to verify
Agree the release thresholds before building, so results are judged against a standard set in advance.
Framework and product details change quickly. For example, AutoGen and Semantic Kernel now direct new users to Microsoft Agent Framework. Tool choices are confirmed against current documentation when the programme is scoped.
40 hours · onsite: 5 × 8 h or 10 × 4 h
Detailed curriculum
Six modules across 40 hours, each built around a hands-on lab, with security, evaluation and operations running through all of them. The two onsite schedules cover the same curriculum; the live-online session plan, emphasis and lab stack are agreed with your team.
Module 1 RAG foundations
- Retriever, generator and context window
- Embeddings and similarity search
- Fixed, recursive, semantic and document-aware chunking
- Choosing a vector store
- Answers with citations
Practical activityBuild a document question-answering service that cites its sources.
Module 2 Retrieval quality and evaluation
- Common retrieval failure modes
- Hybrid search, metadata filtering and re-ranking
- Query rewriting and context compression
- Evaluation sets, metrics and baselines
- Detecting unsupported answers
Practical activityMeasure a multi-document assistant against a test set, change one thing, and measure again.
Module 3 Controlled agent workflows
- Agent loops: plan, act, observe
- LangGraph state, nodes, edges and conditional routing
- Single-agent and multi-agent designs
- Retries, reflection and failure handling
- Human-approval interrupts
Practical activityBuild a research workflow that pauses for approval before any external action.
Module 4 Tool calling and integration
- Tool schemas and structured outputs across model providers
- Database-querying agents with read-only access
- Calling internal APIs safely
- Timeouts, retries and idempotency
- Tracing agent runs
Practical activityConnect an agent to a sandboxed database and API, with tracing switched on.
Module 5 Model Context Protocol
- MCP architecture: hosts, clients and servers
- How MCP differs from calling a REST API directly
- Building a custom MCP server
- Authorization, token audience and scope minimisation
- Local server risks and sandboxing
Practical activityBuild a small MCP server exposing least-privilege tools, and connect a client to it.
Module 6 Security, release and operations
- Threat modelling data, retrieval, agent, tool and MCP boundaries
- Prompt-injection and sensitive-data tests
- Audit events, monitoring and incident ownership
- Versioning, change control and rollback
- Release evidence and go/no-go criteria
Practical activityCapstone: test the combined system and prepare the evidence for a release review.
Need the agenda built around your team’s work?
Share the roles attending and the tasks to improve. The proposal sets out the adapted agenda.
Exercises and practical outputs
Labs run on participants’ own laptops, prepared with setup instructions sent in advance, and use representative, non-sensitive data unless your organisation approves something else. Each module follows the same rhythm.
How every module runs
Explain
A short design discussion and live build of the pattern.
Build
Participants implement it in the agreed environment, in pairs or small groups.
Measure
The result is tested against agreed checks, not judged by eye.
Review
Code and design decisions are reviewed with the trainer and the group.
Module 1 Exercise 1: Document Q&A with citations
Ingest a set of representative documents and answer questions with page-level citations.
Practice output A working RAG service and notes on the chunking choices made.
Module 2 Exercise 2: Hybrid search over structured records
Combine keyword and vector search with metadata filters over synthetic records.
Practice output A search endpoint with a comparison of filtered and unfiltered results.
Module 2 Exercise 3: Evaluated knowledge assistant
Build a test set, measure a baseline, then improve retrieval and measure again.
Practice output A before-and-after evaluation report.
Module 3 Exercise 4: Agent with an approval step
Model a multi-step workflow that pauses for human approval before acting.
Practice output A graph with explicit state, routing and an interrupt.
Module 4 Exercise 5: Tool-calling agent on a sandbox
Give an agent read-only database access and one approved write action.
Practice output A traced agent run and a tool-permission matrix.
Module 5 Exercise 6: Least-privilege MCP server
Expose a small set of tools through MCP with authentication and scoped permissions.
Practice output A working server, a client connection and a note of each tool’s access.
Module 6 Exercise 7: Red-team session
Attack the group’s own system with prompt-injection and data-disclosure tests.
Practice output A list of findings and the fixes applied.
Module 6 Exercise 8: Release review
Bring evaluation results, known limits, owners and a rollback plan to a go/no-go review.
Practice output Release evidence for discussion — practice material, not a certification.
Exercises use representative, non-sensitive examples. Outputs are produced during the workshop for practice and review; anything participants keep is their own working material.
Security, evaluation and human oversight
Security and governance are practised in every module rather than taught as a separate policy session. These principles apply throughout.
Links point to the official OWASP, NIST, MCP and LangGraph sources. They change — check the current versions when you scope the work.
Map the system before choosing controls
Name the owner, users, data flows, risk level and limits of each system before deciding which controls it needs.
Treat retrieved content and tool results as untrusted
Documents, web pages and tool outputs can contain instructions. Keep them separate from system instructions and validate what the model returns.
Give tools the least privilege they need
Start read-only, grant narrow scopes, and require step-up approval for writes. Excessive agency is a named OWASP risk.
Secure MCP servers like any other service
Validate token audience, never pass client tokens through to downstream APIs, and sandbox local servers.
Keep a person in the loop for consequential actions
Actions that change records, send messages or spend money pause for approval, and the workflow can resume or stop cleanly.
Decide release thresholds in advance
Agree what “good enough” means — quality, latency, cost and failure cases — before the results are in.
Make failures traceable and reversible
Version prompts and models, record audit events, name an incident owner and keep a tested rollback path.
Training is not a compliance sign-off
The programme is informed by recognised AI risk and application-security practice. It does not certify a system as compliant; your own security, privacy and legal review still applies.
How the course is tailored and delivered
An engineering programme only works when a few decisions are made before the first session. We work through them with you, and the answers go into the written proposal.
What your team decides before booking
Goal and participants
What the team is building, who will attend, and whether everyone meets the Python prerequisite — or needs the bridge course first.
Schedule and delivery
For onsite delivery, choose five 8-hour days or ten 4-hour days. A private live-online session plan is agreed separately; every option totals 40 hours.
Stack and model providers
Which cloud, model APIs, vector store and frameworks the labs should use, so the patterns transfer.
Laptops and lab environment
Participants bring their own laptops and complete the setup instructions Technovids sends in advance. A managed sandbox or VM can be arranged on request, for an additional charge confirmed in the proposal.
Accounts, data and code
Agree who supplies model API accounts and keys, and who covers usage costs, in the proposal. You also decide whether labs use representative or prepared internal data, and where lab code is kept.
How success is judged
What the team should be able to do afterwards and how that will be reviewed. We do not promise a measured productivity figure.
Onsite schedule options
5 days × 8 hours
Best for: Teams that can step away from delivery for a working week
Five full training days at your office in India; dates and daily timings are agreed in the proposal.
10 days × 4 hours
Best for: Teams with ongoing delivery commitments
Ten onsite half-days, leaving part of each day for project work. Session dates are agreed in the proposal.
Both onsite schedules cover the same six modules, labs and outcomes. A private live-online delivery also totals 40 hours, with its session pattern confirmed in the proposal.
Delivery modes
Onsite at your office
Choose either onsite schedule. Venue and dates in India are confirmed in the proposal.
Private live online
Live sessions for one company’s team. The 40-hour session pattern is agreed in the proposal.
Inside our instructor‑led training sessions
A selection of Technovids instructor-led training sessions.
Photo 1 of 10: Hands-on session 
Photo 2 of 10: Group photo 
Photo 3 of 10: Hands-on session 
Photo 4 of 10: Group photo 
Photo 5 of 10: Classroom session 
Photo 6 of 10: Group photo 
Photo 7 of 10: Computer-lab session 
Photo 8 of 10: Group photo 
Photo 9 of 10: Classroom session 
Photo 10 of 10: Group photo
For L&D and procurement teams
The published course parameters on one page. Final scope, dates and fees are confirmed in the written proposal.
Discuss your team’s requirements| Course | Production AI Engineering Training |
|---|---|
| Course | Production AI Engineering Training |
| Provider | Technovids Consulting Pvt. Ltd., Bengaluru |
| Audience | Company software, data, ML and platform engineering teams — private training only |
| Level | Advanced — strong intermediate Python required |
| Delivery | Corporate onsite at your office in India, or private live online |
| Language | English |
| Duration | 40 hours |
| Schedule options | Onsite: 5 days × 8 hours or 10 days × 4 hours; live-online session pattern and dates confirmed in the written proposal |
| Cohort size | Confirmed in the written proposal |
| Core topics | RAG, agent workflows, tool calling, MCP, evaluation, security and operations |
| Technology | Adapted to your approved stack where practical; confirmed when scoping |
| Laptops | Provided by participants; Technovids sends lab setup instructions in advance |
| Managed sandbox or VM | Available on request, for an additional charge confirmed in the proposal |
| Model API accounts and usage | Account, key and usage-cost responsibility confirmed in the written proposal |
| Post-training support | May be available — scope and duration agreed in writing |
| Certificates | May be available — eligibility agreed in writing |
| Course materials | May be available — format and access period agreed in writing |
| Pricing | Custom quote based on schedule, delivery mode, cohort and customisation |
Meet the trainer panel
Technovids assigns the trainer or trainer combination according to the team’s stack, the modules emphasised and the agreed delivery plan.
Pankaj Rana
Co-founder & Lead Instructor, Technovids Consulting
Pankaj is a co-founder and the lead instructor at Technovids Consulting. His programme work spans practical AI adoption, AI engineering, evaluation, responsible production AI, data analytics and corporate learning design, with an emphasis on hands-on exercises connected to workplace tasks.
Expertise:
- Practical AI adoption
- Prompting and evaluation
- Responsible AI
- Corporate learning design
Junaid Khateeb
AI & Machine Learning Trainer, Strategist and Consultant
Junaid is an AI and machine-learning trainer, strategist and consultant with more than 22 years of training experience. His work combines enterprise AI education, business-centred adoption, responsible AI practices and applied solution design, helping professional audiences connect AI concepts to real organisational needs.
M.E. in Computer Engineering, specialising in Artificial Intelligence · author of programming books on Python, Java and C++
Expertise:
- Enterprise AI and ML training
- AI strategy and adoption
- Responsible AI
- Applied AI solution design
Pradeep Varadarajan
Technical Trainer & Curriculum Architect
Pradeep is a technical trainer and curriculum architect with more than 20 years of experience across enterprise technology, cloud infrastructure and advanced AI systems. He designs practitioner-focused programmes, labs and assessments covering AI, LLM systems, Python and machine learning, translating complex technical subjects into structured learning experiences.
Bachelor of Engineering in Electrical Engineering · instructor-led, virtual and blended delivery
Expertise:
- AI and LLM systems
- Curriculum architecture
- Python and machine learning
- Hands-on lab design
The trainer or trainer combination for a specific programme is confirmed in the written proposal.
Updated
Organisations we have trained, and what participants say
These organisations have received Technovids training, and the reviews come from participants across Technovids programmes. They are not specific to this engineering course.
Organisations we have delivered training for
Practical training programmes delivered for learners, professionals and teams across AI, data, cloud, productivity and professional skills.
Participant experiences across workplace roles
What professionals found useful, practical and relevant to their day-to-day work.
- Gauraw DeshmukhData Engineer · Capgemini
Technovids AI training was very practical and well structured. The sessions helped me understand how AI concepts can be applied in real data engineering and business workflows, instead of only learning theory. The trainer explained the topics clearly with relevant examples, which made the learning experience valuable and easy to follow.
- PriyanshaSoftware Developer
The AI training from Technovids helped me gain a better understanding of Generative AI, prompt engineering, and practical AI use cases for software development. The course was clear, interactive, and focused on real-world applications. It gave me confidence to explore AI tools more effectively in my work.
- Sidda RajuData Engineer
Technovids delivered the AI training in a very practical and industry-relevant way. As a data engineer, I found the examples and hands-on discussions useful for understanding how AI can improve data workflows, automation, and decision-making. The sessions were well planned and easy to understand.
- Akshat KabraData Engineer
The AI training program by Technovids was insightful and professionally delivered. It covered important AI concepts in a simple and practical manner, with examples that connected well with data and analytics use cases. The sessions helped me build a stronger foundation in applying AI in real business scenarios.
- MangeshSoftware Engineer · Siemens
Technovids conducted the AI training in a very effective and engaging manner. The sessions were practical, easy to follow, and focused on how AI can be used in real software engineering and business workflows. It was a valuable program for understanding the current direction of AI adoption in the industry.
- ReshuSoftware Developer
Technovids AI training was a very useful learning experience. The course explained AI concepts in a practical way and showed how developers can use AI tools to improve productivity, problem-solving, and application development. The trainer's approach was simple, clear, and focused on industry use cases.
Common questions before planning this course
Answers about the published course. The written proposal records any agreed customisation, delivery details and commercials.
What is production AI engineering?
It is the engineering work of building LLM applications that can be tested, secured, monitored and changed safely — retrieval pipelines, agent workflows and tool integrations — rather than stopping at a working demonstration.
Who is this programme for?
Company engineering teams: backend and full-stack engineers, ML engineers and data scientists, tech leads and platform engineers who build or operate LLM applications. It is not designed for non-developers.
Can individuals join this programme?
No. It is private training for one company’s team at a time. Individual developers should see the AI Engineering Course instead.
How much Python do participants need?
Strong intermediate application Python: functions, classes, type hints, exceptions, API calls and virtual environments. Basic async Python, FastAPI, SQL and Git are strongly recommended. Python fundamentals are not taught.
What if some engineers know Python but not FastAPI or async?
They should start with the AI Programming with Python bridge course, which covers the backend Python skills this programme assumes.
How is this different from the AI Engineering Course?
The AI Engineering Course is Technovids’ route for individual developers, and its format and schedule are described on its own page. This programme is 40 hours of private training for one organisation’s engineers, scoped to their stack and projects.
How is it different from Claude Code Training?
Claude Code Training teaches developers to use an AI coding assistant in their daily work. This programme teaches teams to build and operate their own AI applications.
What is the difference between RAG and fine-tuning?
RAG retrieves relevant information at request time without changing the model. Fine-tuning changes model behaviour by training on examples. RAG often suits knowledge that changes or answers that need sources; fine-tuning can help with specialised behaviour. Some systems use both.
How is LangGraph different from LangChain?
LangChain provides components for prompts, retrievers, models and tools. LangGraph adds stateful graph execution for workflows that branch, loop, retry or pause for human approval.
What is MCP, and is it covered in depth?
MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems. The programme covers building a server, connecting a client, and securing it with authentication and scoped permissions.
Which frameworks and vector stores are used?
They are chosen to match your stack where practical and confirmed when the programme is scoped. Framework details change: for example, AutoGen and Semantic Kernel now direct new users to Microsoft Agent Framework.
Can the labs use our own data or code?
Only when your organisation approves it and the material is prepared for training. Otherwise labs use representative, non-sensitive data and sandboxed systems.
What environment and equipment are needed?
Participants bring their own laptops, set up using the lab instructions Technovids sends in advance. A managed sandbox or VM can be arranged on request for an additional charge confirmed in the proposal. Responsibility for model API accounts, keys and usage costs is agreed in the proposal.
How long is the programme, and how is it scheduled?
It is 40 hours. Onsite delivery can run as five 8-hour days or ten 4-hour days, with the same curriculum. Private live-online delivery is also available; its session pattern and all dates are confirmed in the written proposal.
What will participants build?
Representative lab projects: a cited document Q&A service, an evaluated knowledge assistant, an agent with an approval step, a tool-calling agent, an MCP server and a tested capstone. These are practice builds, not guaranteed production deliverables.
Does the programme cover AI governance and LLM security?
Yes, in every module: risk mapping, least-privilege tools, prompt-injection and data-disclosure testing, human approval, evaluation thresholds, audit events, monitoring and rollback.
Does completing it certify a system as compliant?
No. It does not provide certification, a legal opinion or regulatory approval for any system. Each organisation completes its own security, privacy and legal review before production use.
Are post-training support, certificates and course materials included?
They may be available, but their scope, eligibility and access periods are agreed in writing in the proposal. None is included unless the proposal says so.
Who delivers the programme, and how is it priced?
The trainer or trainer combination is selected from the Technovids trainer panel and confirmed in the written proposal. Pricing is a custom quote based on the schedule, delivery mode, cohort size and customisation.
Turn a training requirement into a clear course proposal
Share the audience, team size, delivery preference and the work you want to improve. Technovids will scope the programme and confirm the details in a written proposal.