Crio.Do
Fellowship Program in AI Engineering

The detailed curriculum
and projects.

Every sprint, every session theme, and every build explained in plain language — what it is, the business problem it solves, what you build, and how success is measured. Six 4-week build sprints, a 2-week interview sprint, 17 builds plus 4 optional ones.

6 months + 2-week interview sprint60+ live sessions17 builds — 10 mini projects · 6 guided · 1 capstone+4 optional self-buildsIndustry mentors~10 h a week

Course outline.

Core sprints run back to back; the sixth ends with your capstone demo day. Optional modules are self-paced and included in the fee.

BlockModuleWhenBuilds you shipThemes
Sprint 1Foundations & the AI-App MindsetWeeks 1–4PromptForge · ModelSwitch · SnapClassifyLLM Foundations · Prompt Engineering · Context Engineering · Structured Outputs
Sprint 2Grounding with Data — RAGWeeks 5–8FindIt · AskDocsEmbeddings · Chunking · Hybrid Search · Re-ranking
Sprint 3Agents, Protocols, MCP & Enterprise IntegrationWeeks 9–12ToolAgent · GateKeeper MCP · TriageOpsAgent Loop · Tool Calling · MCP · RBAC & Audit
Sprint 4Eval-Driven Development, Fine-Tuning & Coding Agents IWeeks 13–16EvalLab · TinyTune · DomainCopilotLLM-as-Judge · Deploy Gates · LoRA / QLoRA · DPO
Sprint 5Production, Cloud, Compliance & Real-TimeWeeks 17–20RouteCache · SafeOps · VoiceMate · ShipItObservability · Drift & Incidents · Cost & Latency · Caching
Sprint 6Coding Agents II–III, Problem → Production & CapstoneWeeks 21–24RepoAgent · CapstoneCoding Agents · md-files & Hooks · Agentic Review · Spec & Metrics
Interview sprintInterview Preparation SprintWeeks 25–26Practice rounds · portfolio walkthroughSystem design · Decomposition · Behavioural · Portfolio
OptionalData Structures & AlgorithmsSelf-paced—300+ problems on the platform with guided session recordings
OptionalSystem DesignSelf-paced—Low-level and high-level design with hands-on scenarios

Curriculum deep dive.

Sprint by sprint: what is taught, the tools you'll use, and the builds you leave with. Ten live sessions per sprint with industry mentors, about 20 hours of take-home builds, every build assessed automatically against a rubric. Each build links to its full explanation further down the page.

01
Weeks 1–4

Foundations & the AI-App Mindset

4 weeks · 10 live sessions

Learn how AI applications differ from traditional software and master the LLM building blocks — with a hands-on ML/DL refresher.

What you'll learn

  • How AI apps differ — non-determinism and the build-examine-decide loop
  • LLM foundations: tokenization, context windows, sampling, caching, tool calling, multimodal inputs
  • Prompt & context engineering; structured (JSON) outputs and validation
  • Design patterns for AI apps — and when not to use AI/agents
  • Evaluation 101: the error-analysis loop and a first eval harness
  • ML/DL refresher (bias/variance, metrics, transformers) and a computer-vision primer
  • System-design recap for AI apps: API design, data models, auth, async
LLM FoundationsPrompt EngineeringContext EngineeringStructured OutputsDesign PatternsEvals 101ML RefresherCV Primer

You ship

  • PromptForgemini projectStructured-output extractor / prompt playground with schema validation.
  • ModelSwitchmini projectMulti-model router with a first eval harness measuring tokens, latency, cost and quality.
  • SnapClassifymini projectTransfer-learning image classifier deployed as a web app.

Every build is deployed, evaluated and assessed automatically against a rubric. Full detail on each one further down this page.

02
Weeks 5–8

Grounding with Data — RAG

4 weeks · 10 live sessions

Ground models in real data — the most widely deployed production pattern — with retrieval-engineering depth.

What you'll learn

  • Embeddings, vector search and index types; storage tiers and when to pick each
  • Chunking strategies and parsing real documents (PDF/HTML/tables) into LLM-ready inputs
  • Hybrid search — dense + sparse fused with Reciprocal Rank Fusion; re-ranking
  • RAG end-to-end with citations and groundedness; agentic RAG (query rewriting, multi-hop)
  • Beyond vectors: knowledge graphs and a semantic layer over SQL
  • Data engineering for AI — pipelines, quality & freshness, incremental sync
  • Retrieval evaluation — recall@k, faithfulness, golden sets, eval-in-CI
EmbeddingsChunkingHybrid SearchRe-rankingRAGAgentic RAGKnowledge GraphsRetrieval Evals

You ship

  • FindItmini projectDense + sparse search fused with RRF and a reranker over a real dataset.
  • AskDocsguided appCited Q&A over a real doc source (Notion / Google Drive) with hybrid retrieval + reranking, conversation memory and guardrails. Ships as a live assistant + eval report + cost/latency dashboard.

Every build is deployed, evaluated and assessed automatically against a rubric. Full detail on each one further down this page.

03
Weeks 9–12

Agents, Protocols, MCP & Enterprise Integration

4 weeks · 10 live sessions

Move from single LLM calls to agents that act — reliably and safely — over real enterprise systems.

What you'll learn

  • The agent loop; workflows vs agent harness; tool/function calling in depth
  • MCP servers — multi-tenant scoping, RBAC at the tool boundary, audit logs
  • Agent design patterns (ReAct, plan-and-execute, reflection, router); memory & context
  • Multi-agent orchestration; vendor agent SDKs compared with LangGraph
  • Agent communication protocols (A2A/ACP); typed schemas & state machines for reliable messaging
  • Human-in-the-loop, guardrails, safe write-actions & permissions; agent evaluation & tracing
  • Integration over real systems: OAuth/SSO, webhooks; a text-to-SQL agent with a verification loop
Agent LoopTool CallingMCPRBAC & AuditMulti-AgentA2A / ACPHuman-in-the-LoopAgent Evals

You ship

  • ToolAgentmini projectA ReAct agent calling a live API.
  • GateKeeper MCPmini projectA multi-tenant MCP server with RBAC, per-tenant scoping and audit logs.
  • TriageOpsguided appSupervisor + specialist agents that classify tickets, draft grounded replies and route/escalate — via your multi-tenant MCP server, with human approval on writes. Ships as a deployed agent + trace/eval console.

Every build is deployed, evaluated and assessed automatically against a rubric. Full detail on each one further down this page.

04
Weeks 13–16

Eval-Driven Development, Fine-Tuning & Coding Agents I

4 weeks · 10 live sessions

Make quality measurable, customise models when it pays, and start using coding agents properly.

What you'll learn

  • Deterministic vs LLM-as-judge vs human evaluation; building eval sets from traces
  • Regression testing, evals as a CI deploy gate, evaluate-your-evals
  • Prompt vs RAG vs fine-tune; the PEFT landscape (LoRA, QLoRA, adapters)
  • Hands-on fine-tuning with 4-bit quantisation and before/after evaluation
  • Post-training concepts — DPO, RL-style methods, reasoning models
  • Distillation, quantisation and serving fine-tuned models
  • Coding agents I — how a harness wraps an LLM; the plan → execute → deploy workflow
LLM-as-JudgeDeploy GatesLoRA / QLoRADPODistillationQuantisationModel ServingCoding Agents

You ship

  • EvalLabmini projectLLM-as-judge harness + a regression set wired in as a CI deploy gate.
  • TinyTunemini projectLoRA/QLoRA fine-tune + before/after eval + a distillation demo.
  • DomainCopilotguided appFine-tuned open model + RAG grounding, measured against the base model and a frontier API, with cost-vs-quality analysis; published to a model hub. Ships as your own domain model + app + eval report.

Every build is deployed, evaluated and assessed automatically against a rubric. Full detail on each one further down this page.

05
Weeks 17–20

Production, Cloud, Compliance & Real-Time

4 weeks · 10 live sessions

Run AI reliably, cheaply, safely and compliantly; ship on a hyperscaler; build for real-time.

What you'll learn

  • Observability & tracing; drift, statistical regression testing, incident fire-drills
  • Cost & performance — routing, semantic + prompt caching, token budgets, cost-per-query
  • Security, governance & compliance literacy — injection, PII, guardrails, audit
  • Deployment — containers, CI/CD with eval gates, versioning/rollbacks, scaling LLM APIs
  • Cloud AI ecosystems — AWS Bedrock + AgentCore, SageMaker (Azure/GCP introduced)
  • Hands-on AWS: productionise an earlier build with monitoring and cost alarms
  • Real-time & voice — cascaded vs realtime speech, LiveKit, interrupt patterns, latency/cost
ObservabilityDrift & IncidentsCost & LatencyCachingSecurity & ComplianceCI/CDAWS BedrockVoice Agents

You ship

  • RouteCachemini projectModel-router + semantic-cache gateway; cost/latency before-vs-after.
  • SafeOpsmini projectTracing + PII redaction + a blocked prompt-injection + a drift alert.
  • VoiceMateguided appSpeak-in / speak-out support agent with tool use and interrupt handling, tuned for latency and cost — with a justified cascaded-vs-realtime design choice. Ships as a live voice demo + latency/cost report.
  • ShipItguided appTake an earlier build to AWS Bedrock/AgentCore or SageMaker with eval-gated CI/CD, monitoring, cost alarms, an incident fire-drill and a handover doc. Ships as "deployed on AWS" on your résumé — with the dashboard to prove it.

Every build is deployed, evaluated and assessed automatically against a rubric. Full detail on each one further down this page.

06
Weeks 21–24

Coding Agents II–III, Problem → Production & Capstone

4 weeks · 10 live sessions

Master coding agents, own the path from problem to production, and ship your capstone.

What you'll learn

  • Coding agents II — autonomy levels, safe permissions, md-files (AGENTS.md/CLAUDE.md), hooks, MCP, parallel agents
  • Coding agents III — behavioural + functional tests, agentic code review, security/architecture audits
  • Problem → production I — framing the right problem, success metrics, the one-page spec, MVP vs careful build
  • Problem → production II — building within real constraints: existing systems, data, security, tenancy; stack decisions
  • Problem → production III — deploy, hand over & own: eval gates, fire-drills, runbooks, demoing to stakeholders
  • Production-hardening clinic — multi-agent failure modes, RAG at scale, cost under load
  • Capstone clinics and demo day
Coding Agentsmd-files & HooksAgentic ReviewSpec & MetricsConstraintsHandoverHardeningCapstone

You ship

  • RepoAgentguided appImplement a real feature in a large open-source repo with coding agents — spec → plan → build → review — and build the evals that prove it works. Ships as a merge-quality PR + eval suite.
  • Capstoneyour own productChoose from an industry menu or bring your own problem. Write the one-page spec and success metrics, build, deploy on AWS, evaluate, monitor — and tell the story on demo day.

Every build is deployed, evaluated and assessed automatically against a rubric. Full detail on each one further down this page.

Demo day closes the program — present your capstone live, its eval report and what you would do next.
★
Weeks 25–26

Interview Preparation Sprint

2 weeks · 6 sessions + practice · after the six sprints

Prepare for AI Engineer and Forward Deployed Engineer (FDE) interviews the way AI companies, GCCs and startups actually run them.

What you'll learn

  • Agentic-system-design rounds — research agents, text-to-SQL over large schemas, multi-agent coordination
  • Ambiguous-problem decomposition round — clarify, decompose, propose a 4-week scope, name the riskiest assumption
  • Behavioural preparation for engineering roles; communicating technical trade-offs
  • Security & architecture interrogation with a question bank
  • Portfolio walkthrough & architecture defence; résumé/LinkedIn review
System DesignDecompositionBehaviouralArchitecture DefencePortfolio

You get

Practice rounds with scored feedback, a reviewed résumé and LinkedIn, and a portfolio walkthrough you can defend — plus 5 referral interviews to SDE or AI Engineer roles.

Sequencing may be refined with our subject-matter experts before the cohort starts.

How the projects build on each other.

The projects form a ladder. Mini projects teach one skill each; guided projects combine several skills into a product; later builds reuse earlier ones — ShipIt takes AskDocs or DomainCopilot to AWS, TriageOps runs on your own GateKeeper MCP server, SafeOps hardens an earlier build. The capstone is your own product, built from everything above.

ThemeMini projectsGuided project
LLM foundations & the AI-app mindsetP1 PromptForge · P2 ModelSwitch · P3 SnapClassify—
Grounding with data (RAG)P4 FindItB1 AskDocs
Agents, MCP & enterprise integrationP5 ToolAgent · P6 GateKeeper MCPB2 TriageOps
Evaluation & fine-tuning; coding agents IP7 EvalLab · P8 TinyTuneB3 DomainCopilot
Production, cloud, compliance, voiceP9 RouteCache · P10 SafeOpsB4 VoiceMate · B5 ShipIt
Coding agents II–III; problem → production—B6 RepoAgent · CAP Capstone
Optional self-builds—O1 AutoClaims Assist · O2 MedAuth Assist · O3 CallReview · O4 QueryPilot

Every project on one page.

Ten mini projects, six guided production projects, your capstone — and four optional self-builds. Click a name for the full explanation.

#ProjectIn one lineSkill it proves
P1PromptForgeTurns messy text into clean, validated JSONPrompt & context engineering, structured outputs
P2ModelSwitchRoutes requests across 4 models and measures eachModel routing, first evals, cost/latency
P3SnapClassifyImage classifier deployed as a web appDeep-learning & computer-vision basics
P4FindItHybrid keyword + semantic search with a rerankerRetrieval engineering
P5ToolAgentAn agent that calls a live API to get things doneTool calling, the agent loop
P6GateKeeper MCPSecure, multi-tenant tool server for agentsMCP, permissions (RBAC), audit logs
P7EvalLabAutomated quality gate that blocks bad releasesEvaluation-driven development, CI gates
P8TinyTuneFine-tunes a small model and proves it improvedFine-tuning, quantisation, distillation
P9RouteCacheGateway that cuts LLM cost and latencyCaching, routing, cost engineering
P10SafeOpsTracing, PII redaction, injection defence, drift alertObservability, security, guardrails
B1AskDocsCited Q&A assistant over a company's real documentsProduction RAG end-to-end
B2TriageOpsMulti-agent support operations over a real helpdeskEnterprise agents, MCP, human-in-the-loop
B3DomainCopilotFine-tuned industry copilot vs a frontier modelFine-tuning + RAG + cost/quality analysis
B4VoiceMateReal-time voice agent that can actVoice AI, latency engineering
B5ShipItAn earlier build productionised on AWSCloud deployment, CI/CD, monitoring, handover
B6RepoAgentA real feature shipped into a large codebase with coding agentsCoding agents, agentic review, evals
CAPCapstoneYour own AI product, deployed on AWSProblem → production, end to end
O1AutoClaims AssistInsurance claims triage with human reviewRegulated multi-agent decisioning
O2MedAuth AssistHealthcare prior-authorisation co-pilotCompliance-first co-pilot
O3CallReviewCall-centre QA & compliance pipelineSpeech-analytics pipeline
O4QueryPilotReliable text-to-SQL over a 200-table warehouseAgents over structured data

Part 1 — mini projects.

Small, focused builds of 4–5 hours each. Every one ends in a working, deployed artifact and a measured result. They exist to build the muscle before the guided projects.

P1

PromptForge

Structured-output playground
Prompt & context engineering, structured outputs
What it is
A tool that takes messy text — emails, invoices, support tickets, résumés — and returns clean, validated JSON in a fixed format, plus a playground for testing prompts.
Business problem
Most business AI starts with 'extract structured data reliably'. Raw model output is inconsistent; production systems need a guaranteed shape.
You build
Prompt and context engineering, JSON-mode outputs, a schema (Pydantic) that validates every response, automatic retries when the model gets it wrong.
Proof it works
Extraction accuracy against a labelled set; % of responses that pass validation first time.
Why it matters
The first thing you learn is to never trust raw model output — every response is validated against a contract. That is what separates a demo from a product.
P2

ModelSwitch

Multi-model router + first eval harness
Model routing, first evals, cost/latency
What it is
A router that sends each request to Claude, Gemini, OpenAI or a local open model (via Ollama), and a harness that scores every model on quality, speed, tokens and cost.
Business problem
Companies over-spend by sending everything to the biggest model. They want to choose models on evidence, not hype.
You build
Multi-provider access behind one gateway, routing rules, and the first evaluation harness — a reusable habit for the whole program.
Proof it works
A comparison table: quality vs latency vs cost per model on the same tasks.
Why it matters
By week 3 you can tell a CTO which model to use for which task — with numbers.
P3

SnapClassify

Deployed image classifier
Deep-learning & computer-vision basics
What it is
An image classifier built with transfer learning in PyTorch, deployed as a small web app, then compared with a multimodal LLM on the same task.
Business problem
Not every problem needs an LLM. Teams need engineers who know when a small classical model is cheaper, faster and better.
You build
Deep-learning and computer-vision basics (CNNs, transfer learning), model deployment, a classical-model-vs-LLM comparison.
Proof it works
Accuracy, inference speed and cost of the classifier vs the multimodal LLM.
Why it matters
A computer-vision primer is built in, so you don't graduate as a one-trick LLM engineer.
P4

FindIt

Hybrid search with a reranker
Retrieval engineering
What it is
A search engine over a real dataset (e.g. a product catalogue) that combines keyword search and semantic (meaning-based) search, fuses the results, then re-ranks them.
Business problem
Pure semantic search misses exact terms (part numbers, names); pure keyword search misses meaning. Real systems need both.
You build
Embeddings, sparse/keyword retrieval, Reciprocal Rank Fusion, a cross-encoder reranker — and you measure the gain from each step.
Proof it works
Recall@k before and after each retrieval improvement.
Why it matters
Retrieval quality makes or breaks a RAG system. You learn it as engineering, with measurements — not as a library call.
P5

ToolAgent

ReAct agent on a live API
Tool calling, the agent loop
What it is
The minimum viable agent: a model that reasons, calls a real external API (e.g. GitHub, weather, a helpdesk), looks at the result and decides the next step.
Business problem
Chatbots answer; agents act. Companies want systems that can look things up and take steps, not just talk.
You build
Tool/function calling, the reason → act → observe loop, error handling and retries, basic guardrails.
Proof it works
Task-completion rate and tool-call accuracy on a set of tasks.
Why it matters
This is where you move from prompting a model to building something that does work.
P6

GateKeeper MCP

Multi-tenant MCP server with RBAC & audit
MCP, permissions (RBAC), audit logs
What it is
A server built on the Model Context Protocol (MCP) — the standard way to give AI agents access to tools and data — with per-customer isolation, role-based permissions, OAuth and audit logs.
Business problem
Enterprises will not connect agents to internal systems without permissions, compliance literacy and an audit trail. This is the #1 blocker to agent adoption.
You build
An MCP server exposing real tools, multi-tenant scoping, RBAC at the tool boundary, audit logging — reused later by TriageOps.
Proof it works
Permission tests (tenant A cannot see tenant B), a complete audit trail for every tool call.
Why it matters
Most courses show MCP as a demo. You build the enterprise-safe version — the one a security team would approve.
P7

EvalLab

LLM-as-judge + regression set as a CI gate
Evaluation-driven development, CI gates
What it is
An automated quality gate: a set of test cases plus an AI 'judge' that scores outputs, wired into the release pipeline so a change that lowers quality is blocked automatically.
Business problem
AI systems silently regress when prompts or models change. Teams need the equivalent of unit tests for AI.
You build
Evaluation sets built from real failures, an LLM-as-judge with a calibrated rubric, regression testing in CI (GitHub Actions) that catches a planted regression.
Proof it works
The gate blocks the planted regression; judge agreement with human labels.
Why it matters
Evaluation is the spine of the program — every later build ships with evals in CI. Hiring managers ask about this in every interview.
P8

TinyTune

LoRA/QLoRA fine-tune + distillation
Fine-tuning, quantisation, distillation
What it is
A small open model fine-tuned for a narrow task using efficient methods (LoRA/QLoRA) on a single GPU, evaluated before and after, then distilled into an even smaller model.
Business problem
Frontier APIs can be too costly, too slow or not private enough. Companies need engineers who know when fine-tuning pays and how to do it cheaply.
You build
Dataset preparation, 4-bit quantisation, LoRA/QLoRA training with Hugging Face, before/after evaluation, a distillation demo.
Proof it works
Quality gain vs the base model; cost and latency vs a frontier API.
Why it matters
You don't just call APIs — you can customise and shrink models when the economics demand it.
P9

RouteCache

Model router + semantic-cache gateway
Caching, routing, cost engineering
What it is
A gateway in front of the LLM providers that routes each request to the cheapest capable model and answers repeated questions from a semantic cache (Redis) instead of calling the model again.
Business problem
LLM bills and latency grow with usage. Routing and caching are the two biggest levers, often cutting cost 30–70% — you measure your own number.
You build
Routing rules, semantic + prompt caching, token budgets, a cost-per-query dashboard.
Proof it works
Cost and latency before vs after, on the same traffic.
Why it matters
Cost engineering is a job requirement now. You leave with a dashboard showing the savings you achieved.
P10

SafeOps

Observability + guardrails + drift alert
Observability, security, guardrails
What it is
Production safety added to an earlier build: end-to-end tracing of every request (Langfuse), automatic PII redaction (Presidio), a demonstrably blocked prompt-injection attack, and an alert when quality drifts.
Business problem
Security and compliance teams ask: what data went to the model, was PII protected, can it be manipulated, will we know when it degrades?
You build
Tracing, PII redaction, injection defence, drift detection and alerting (Prometheus/Grafana).
Proof it works
A trace for every request, redaction tests, a blocked attack in the logs, a fired drift alert.
Why it matters
You can answer a CISO's questions about an AI system — with evidence.

Part 2 — guided production projects.

Each guided project is ~10–12 hours, built with mentor checkpoints, and deployed and operated with evaluation, observability and cost control. Every one ships with a one-page spec, success metrics, an eval report and a demo narrative — the same artefacts an AI engineer produces at work.

B1

AskDocs

Workspace-intelligence assistant over real documents
Production RAG end-to-end
What it is
A 'chat with your company documents' assistant connected to a real source (Notion or Google Drive) that gives grounded, cited answers and remembers the conversation.
Business problem
Teams cannot find answers across scattered docs; generic chatbots make things up. Answers must be trustworthy and traceable to a source.
You build
Ingestion with incremental sync → chunking → hybrid retrieval + reranking → cited answers → conversation memory → guardrails for off-topic and injection; an agentic-RAG extension for multi-step questions.
Proof it works
A golden Q&A set; recall/precision, faithfulness (does the answer match the source?), answer quality by LLM-judge; latency and cost per query; evals run in CI.
Ships as
Live assistant + eval report + cost/latency dashboard.
Why it matters
This is the most requested enterprise AI pattern — and yours is built over real Notion/Drive data with citations and measurable accuracy, not a PDF demo.
B2

TriageOps

Support-operations agent over a real helpdesk
Enterprise agents, MCP, human-in-the-loop
What it is
A multi-agent system running on a real helpdesk: a supervisor agent routes each ticket to a classifier, a knowledge-grounded responder and an escalation agent; humans approve every action that changes data.
Business problem
Helpdesks drown in tickets. Automating replies is only acceptable if they are grounded, safe, auditable and reviewable.
You build
Supervisor + specialist agents, tools exposed through your own GateKeeper MCP server (permissions + audit), human-in-the-loop approval, agent evaluation, full hardening (tracing, guardrails, PII redaction, cost per ticket).
Proof it works
Classification accuracy, deflection rate, draft-reply quality, tool-call accuracy, escalation precision, cost per ticket.
Ships as
Deployed agent + trace/eval console. Stretch: Hand-off to a billing agent; multilingual replies.
Why it matters
An enterprise agent the way enterprises actually deploy them — permissions, audit trail, human approval, measured deflection.
B3

DomainCopilot

Fine-tuned vertical copilot (fintech / health / legal)
Fine-tuning + RAG + cost/quality analysis
What it is
An industry-specific assistant built on a small open model that you fine-tune, ground with RAG, and benchmark head-to-head against a frontier API on quality, speed and cost.
Business problem
For high-volume or sensitive domains, frontier APIs can be too expensive or too generic. Companies want to know if a customised small model can match them at a fraction of the cost.
You build
Domain dataset curation → QLoRA fine-tune → publish the adapter to a model hub → serve it (vLLM/Ollama) behind RAG → side-by-side evaluation → a model card with data provenance and PII handling.
Proof it works
Win-rate vs the base model (judge + human sample), faithfulness with RAG, latency, cost per 1,000 queries vs a frontier API.
Ships as
Adapter on the hub + app + eval report + trade-off note. Stretch: Preference tuning (DPO); distil to an even smaller model.
Why it matters
You can walk into a cost-vs-quality conversation with a CFO and show your own benchmark.
B4

VoiceMate

Real-time voice agent
Voice AI, latency engineering
What it is
A customer-support voice agent you can talk to: it listens, responds instantly, handles interruptions and can take actions like checking an order or making a booking.
Business problem
Voice is the next front for AI in customer service, but it is unforgiving: latency, interruptions and cost per minute decide whether it is usable.
You build
A LiveKit voice agent; a justified choice between a cascaded speech-to-text → LLM → text-to-speech pipeline and a realtime speech-to-speech model; tool use; barge-in and human review-and-edit patterns; a latency budget and cost tuning; voice safety guardrails.
Proof it works
End-to-end latency percentiles, task completion, interruption handling, transcription accuracy (WER), cost per minute.
Ships as
Deployed voice agent + latency/cost report. Stretch: Multilingual; call-summary hand-off to TriageOps.
Why it matters
This is the demo everyone remembers — and very few programs teach it.
B5

ShipIt

Productionise on AWS
Cloud deployment, CI/CD, monitoring, handover
What it is
Taking an earlier build (AskDocs or DomainCopilot) from 'works on my laptop' to a real, monitored service on AWS — using Amazon Bedrock/AgentCore or SageMaker.
Business problem
A prototype is not a product until it is deployed, quality-gated, monitored, costed and handed over to someone else to run.
You build
Containerisation, CI/CD with the eval suite as a deploy gate, observability (traces, metrics, alerts, cost alarms), a rollback plan, an incident fire-drill, a handover document and runbook.
Proof it works
Deploy-gate pass rate, p95 latency, error/retry rate, monthly cost vs budget, time-to-recover in the fire-drill.
Ships as
'Deployed on AWS' with dashboards, runbook and cost report. Stretch: An alternate-stack write-up (GCP Vertex or Azure).
Why it matters
You have deployed and operated an AI system on AWS with monitoring — the line hiring managers look for on a résumé.
B6

RepoAgent

Ship a feature into a large codebase with coding agents
Coding agents, agentic review, evals
What it is
You deliver a real feature in a large, unfamiliar open-source codebase using coding agents (Claude Code / Cursor) as the primary developer — and stay accountable for quality.
Business problem
Real engineering happens in big legacy codebases, and agents now do much of the typing. Teams need engineers who can direct agents safely and review their work rigorously.
You build
A spec; planning with the agent; project instruction files (AGENTS.md/CLAUDE.md), hooks and MCP; implementation with calibrated autonomy and safe permissions; agentic code review and an AI security audit; tests and an eval suite for the feature; a merge-quality pull request.
Proof it works
Tests passing, review findings closed, an eval suite for the feature, time-to-PR, tokens/cost used.
Ships as
A PR + eval suite + a retrospective on agent failure modes. Stretch: Parallel agents on a decomposed task.
Why it matters
Coding agents are taught as a discipline over three sessions and a real project — not a tips-and-tricks webinar.

Part 3 — optional self-builds.

Available from Sprint 5 or after the program. Each comes with a scaffold, a rubric and light mentor checkpoints, and produces the same delivery artefacts as the guided projects. Two are regulated-vertical builds (spec → build → deploy with compliance controls). Together they cover the four enterprise patterns most common in job descriptions: document-heavy decisioning, regulated co-pilots, speech-analytics pipelines, and agents over structured data.

O1

AutoClaims Assist

Insurance claims triage — regulated vertical
Regulated multi-agent decisioning
Scenario
A regional insurer wants faster first decisions on auto claims without losing control.
You build
The spec and success metrics; then a multi-agent + MCP + RAG system that reads claim files (reports, photos, repair estimates), surfaces high-confidence first decisions to adjusters, routes edge cases to human review, with audit logging and compliance literacy.
Proof it works
Decision precision, review-routing recall, audit completeness.
Why it matters
Insurance and BFSI are the biggest buyers of agentic AI in India — this is the build for engineers targeting them.
O2

MedAuth Assist

Healthcare prior-authorisation co-pilot — regulated vertical (educational)
Compliance-first co-pilot
Scenario
A hospital network is stuck at multi-day prior-authorisation turnaround after a compliance-blocked pilot.
You build
A spec with compliance controls; a co-pilot that reads the chart note, retrieves the payer's policy, drafts the request with citations and routes ambiguous cases to a reviewer — with PII redaction, audit logs and SSO.
Proof it works
Citation faithfulness, reviewer agreement, turnaround time.
Why it matters
Shows you can design for compliance from day one — the reason most healthcare AI pilots fail.
O3

CallReview

Call-centre intelligence pipeline
Speech-analytics pipeline
Scenario
QA teams can review under 2% of calls; compliance misses are costly.
You build
Diarised transcription (who said what) → summary → a five-dimension QA scorecard → compliance flags → a downloadable report; batch and streaming modes; cost per call tracked.
Proof it works
Scorecard agreement with human QA, flag precision/recall, cost per call.
Why it matters
Directly relevant to BPO/contact-centre and GCC employers — a complete speech-analytics pipeline.
O4

QueryPilot

Reliable text-to-SQL over a large schema
Agents over structured data
Scenario
Business users want answers from a 200-table data warehouse without writing SQL — and without wrong numbers.
You build
A semantic layer + schema retrieval (so the agent only sees relevant tables) → SQL generation → sandboxed read-only execution → a verification loop (self-check, assertions) → a charted answer; optional hand-off to a reporting agent.
Proof it works
Execution accuracy on a golden query set, hallucinated-column rate, latency.
Why it matters
The canonical enterprise agent, and one of the most common AI system-design interview questions — you've built it.

Optional modules — included.

Self-paced, on the platform with guided session recordings. Take them alongside the sprints or after the program.

Data Structures & Algorithms

300+ problems on the platform with guided session recordings

  • DSA-101 · Beginner DSA — 4 weeks
  • DSA-102 · Problem-solving foundations — 4 weeks
  • DSA-201 · Intermediate DSA — 4 weeks
  • DSA-202 · Trees, graphs & recursion — 4 weeks
  • DSA-203 · Advanced DSA & DP — 4 weeks

System Design

Low-level and high-level design with hands-on scenarios

  • LLD-201 · Low Level Design — Foundations
  • LLD-202 · Low Level Design — Advanced
  • LLD-203 · Machine coding & interview practice
  • HLD-301 · Architecture & high-level design choices
  • HLD-302 · Distributed-system scenarios
  • HLD-303 · Building for scale on the cloud

Pre-work & prerequisites.

You need to be a working programmer. You don't need ML, deep-learning or LLM experience — the refreshers are built in.

Prerequisites
  • Python proficiency (functions, classes, typing, packaging)
  • Git & GitHub — branching, PRs, basic CI
  • HTTP/REST & JSON — calling and building a simple API
  • SQL basics — joins, aggregates, relational schemas
  • Command line & Docker basics
  • About 10 hours a week for 6 months
Pre-work · ≈ 8–10 hours, self-paced
  • Lab-stack setup — Docker, Python, Node; bring up the standard lab stack; API keys via the program gateway
  • Python-for-production-AI refresher (typing/Pydantic, async, packaging)
  • ML concepts primer (bias/variance, metrics, model families)

Provisioned before Day 1: an AWS sandbox with budget alarms, LLM API access behind a gateway, the lab stack and a lab kit for all 17 builds. We use free tiers and resources wherever sufficient.

Questions about the projects

Every build ships with a lab kit: starter + golden repo, eval harness + golden set, CI auto-grading, rubric, spec & demo templates.

Not sure you're a fit?

Request a callback — a program advisor will tell you honestly whether to start now or prep first. No payment, no commitment.

Crio.Do
20, 100 Feet Rd, Bengaluru 560095 · support@criodo.com · 080424 53955
#LearnByDoing