MicrosoftMulti-model, one plane
Foundry became a multi-model control plane
OpenAI, Anthropic, Mistral, DeepSeek and MAI models sit behind one platform, which turns model choice into a routing and cost decision rather than a lock-in one.
Program 18 · Tech stack specialisation
SCIKIQ Certified Data and AI EngineerOpenAI + Azure Tech Stack
Microsoft’s stack is where most large enterprises will run their agents, because that is where their identity, data and compliance posture already live. The skill that matters is not calling the API — it is deploying into an estate with Entra, Purview and a security team that will ask hard questions.
- 60 hrstaught
- 20hands-on AI labs
- 4assessment tests
- +20 hrs2 E2E capstones
Multi-modelFoundry hosts OpenAI, Anthropic, Mistral, DeepSeek and MAI on one control planeMicrosoft
GAFoundry Agent Service on a Responses-API runtime with MCP and A2AMicrosoft
2026Open trust stack introduced: ACS and the ASSERT eval frameworkMicrosoft Build
1Control plane for runtime, grounding, memory, evaluation and governanceMicrosoft
01
Part 1 · The business
The value chain, the people, the trends
Part 1 is the delivery lifecycle: the sequence a SCDAI engineer works through on any engagement, and what each stage looks like specifically on the Microsoft stack.
The agent delivery lifecycle on Azure
Six stages. Select one to see what it means on this stack.
01
Scope & land
Find the workflow, confirm data access and choose the model tier before writing code.
Decisions made here
- Which workflow?
- Which model tier?
- Which region and tenancy?
Where it breaks today
- Model choice made on benchmarks rather than cost per task
- Data residency discovered late
- Quota not requested until it blocks
What is measured
- Time to first working slice
- Cost per task
Where AI landsFoundry model catalogue and router make tier selection an empirical decision, not a guess.
Time to first working sliceCost per task
02
Ground & retrieve
Build retrieval over enterprise content with the security trimming the estate already enforces.
Decisions made here
- Which index?
- How do we trim by permission?
- Hybrid or vector only?
Where it breaks today
- Retrieval that ignores per-user permissions
- Chunking chosen once and never evaluated
- Freshness nobody owns
What is measured
- Recall@k
- Permission-trim correctness
Where AI landsAzure AI Search with hybrid retrieval, semantic ranking and security trimming; Foundry IQ as the knowledge layer.
Recall@kPermission-trim correctness
03
Build & orchestrate
Assemble the agent, its tools and its multi-agent structure on the platform runtime.
Decisions made here
- Workflow or agent?
- Which orchestration framework?
- Where do humans approve?
Where it breaks today
- Autonomy assumed rather than earned
- Tool sprawl without an identity model
- State handled ad hoc
What is measured
- Task success rate
- Tool-choice accuracy
Where AI landsFoundry Agent Service on the Responses API, Microsoft Agent Framework, MCP tools and A2A for multi-agent.
Task success rateTool-choice accuracy
04
Evaluate & prove
Build the eval set, establish a baseline and gate every change against it.
Decisions made here
- What does good look like?
- Which metrics gate release?
- How do we detect regression?
Where it breaks today
- Evaluation by demo
- Judges that drift uncorrected
- No baseline to regress against
What is measured
- Groundedness
- Task success
- Regression rate
Where AI landsFoundry evaluations plus ASSERT-style spec-driven scoring and regression testing in CI.
GroundednessTask successRegression rate
05
Secure & govern
Identity, network isolation, data governance and content safety across the agent estate.
Decisions made here
- What identity does the agent use?
- What can it reach?
- How is data classified?
Where it breaks today
- Agents running with more privilege than the user
- Public endpoints where private ones were assumed
- No agent inventory
What is measured
- Least-privilege coverage
- Policy violations
Where AI landsEntra managed identity, private endpoints, Purview classification, Content Safety and the Agent Control Specification.
Least-privilege coveragePolicy violations
06
Deploy & operate
Deploy, trace, monitor cost and hand over an operable system.
Decisions made here
- Provisioned or pay-as-you-go?
- What do we trace?
- Who owns it on Monday?
Where it breaks today
- Cost discovered at the first invoice
- No tracing when quality drops
- Handover that is a slide deck
What is measured
- Cost per task
- Latency p95
- Availability
Where AI landsFoundry observability, Azure Monitor, OTel GenAI traces and provisioned throughput for predictable cost.
Cost per taskLatency p95Availability
Who you work with on this stack
On Microsoft engagements the platform and security teams are stakeholders from day one. Select one to light the stages they own.
What is changing on this stack
The 2026 read on the Microsoft agent platform.
MicrosoftResponses API + MCP + A2A
Agent Service is the runtime
Foundry Agent Service reached GA on a Responses-API runtime with MCP and A2A support and connected multi-agent orchestration.
MicrosoftACS + ASSERT
An open trust stack appeared
The Agent Control Specification and the ASSERT eval and regression framework put governance and evaluation into the platform rather than beside it.
MicrosoftGrounding as a service
Knowledge became a first-class layer
Foundry IQ as a knowledge layer plus Agent Framework as the operational foundation shifts the work from plumbing to grounding quality.
IndustryCost per task
Cost governance is the differentiator
On enterprise deployments the difference between a pilot and a programme is usually cost per task under provisioned throughput, not model quality.
IndustryOn-behalf-of identity
Identity is the hard part
Agents acting on behalf of users need delegated, least-privilege identity. This is where most Azure agent deployments stall.
Where these numbers come from — 2 sources
Consulted when this program was written, in July 2026. Each entry names the claim on this page that it backs, so the pairing stays checkable if the copy is later edited.
- IndustryMicrosoft Foundry at Build 2026: from demos to production systemsMulti-model control plane; ACS and ASSERT
- IndustryBuild 2026 for Azure Architects: the new AI application stackFoundry Agent Service, Foundry IQ, Agent Framework
02
Part 2 · Data and meaning
The platform building blocks
Part 2 is the concrete stack: what each layer is on Azure, and where the enterprise controls bite.
The platform landscape
Six building blocks you will use on almost every engagement.
Models & routing
GPT-family, o-series and partner models with a router for cost/quality trade-offs.
Foundry Models, model routerAgent runtime
Managed agent execution on the Responses API with tool and multi-agent support.
Foundry Agent Service, Agent FrameworkRetrieval
Hybrid search with semantic ranking and per-user security trimming.
Azure AI Search, Foundry IQData estate
Where the enterprise content actually lives, with classification attached.
Fabric, OneLake, SharePoint, PurviewIdentity & network
Managed identity, on-behalf-of flows, private endpoints and network isolation.
Entra ID, Private Link, VNetAssurance
Evaluation, content safety, tracing and cost telemetry.
Foundry evaluations, Content Safety, Azure Monitor
03
Part 2 · The architecture
How it is actually built
The layers a deployment needs, what each one holds, and what the engineer owns there.
The reference architecture
Six layers. Click one to see the components and what the engineer owns.
01/06
Data & knowledge
Enterprise content in the data estate, classified and permissioned before retrieval touches it.
Takes in
Enterprise content and data in place, with its existing labels and permissions.
Hands on
A classified, permissioned, freshness-bounded corpus for retrieval to index.
SystemWhat it doesKey business entities
Microsoft Fabric / OneLake
One logical lake over the analytical estate, so retrieval indexes a governed copy rather than a private extract nobody maintains.
Lakehouse tableShortcutDomain
SharePoint and Microsoft Graph
Where the enterprise’s documents actually are, with the per-item permissions that must survive into the index.
SiteDocumentPermission
Microsoft Purview
Sensitivity labels, classification and DLP policy applied at source and inherited downstream rather than reapplied by hand.
LabelClassificationPolicy
Freshness pipelines
Scheduled and event-driven refresh with an explicit staleness budget per collection, so "how old is this answer" has an answer.
Refresh runWatermarkStaleness
What the engineer owns here
Ensuring the index inherits source permissions rather than flattening them.
Where this layer fails
Flattening permissions at index time. The index becomes a single over-shared copy of the estate, and no amount of prompt engineering puts that back.
02/06
Retrieval
Hybrid vector and keyword retrieval with semantic ranking and security trimming per user.
Takes in
A classified, permissioned corpus from the data layer.
Hands on
Ranked, trimmed, citable passages scoped to the calling user.
SystemWhat it doesKey business entities
Azure AI Search
The index itself: vector, keyword and hybrid retrieval in one service, with semantic ranking over the candidate set.
IndexFieldVector profile
Integrated vectorisation
Chunking, embedding and enrichment as part of the indexer, so the pipeline is operable rather than a notebook someone runs.
SkillsetChunkEmbedding
Security trimming
Filters on the caller’s Entra group and ACL claims inside the query, so trimming is part of retrieval and not a post-filter.
PrincipalACLFilter
Citation service
Returns the chunk and document reference behind each answer span, which is what makes the output checkable.
CitationChunk idDocument url
What the engineer owns here
Measured recall and provable permission trimming — both, not one.
Where this layer fails
Tuning relevance without measuring recall. The demo questions get better and the long tail silently gets worse.
03/06
Models & routing
Model selection, routing between tiers and structured output contracts.
Takes in
Ranked, trimmed, citable passages from retrieval.
Hands on
Structured, contract-shaped model output at a measured cost per task.
SystemWhat it doesKey business entities
Azure AI Foundry Models
The model catalogue and deployments, including the frontier and small tiers you route between.
DeploymentModel versionQuota
Model router
Sends each task to the cheapest tier that passes its eval, which is where most of the unit-cost reduction actually comes from.
RouteTierPolicy
Structured outputs
Schema-constrained responses, so downstream code parses a contract instead of regex-ing prose.
SchemaResponse contract
Prompt caching and batch
Reuses the stable prefix and moves non-interactive work off the interactive path.
Cache prefixBatch jobToken cost
What the engineer owns here
Choosing tiers on measured cost per task rather than leaderboard position.
Where this layer fails
Choosing a tier from a leaderboard. The only number that matters is cost per task at your accepted quality bar, on your own evals.
04/06
Agents & tools
Agent runtime, MCP tool servers, multi-agent coordination and approval gates.
Takes in
Structured model output and the tool surface it is permitted to use.
Hands on
Completed or proposed actions, with a run trace behind every step.
SystemWhat it doesKey business entities
Foundry Agent Service
Managed agent runtime with threads, tool calls and run state, so the loop is operated rather than hand-rolled.
AgentThreadRunStep
MCP tool servers
Typed tools behind the Model Context Protocol, each with a declared schema and its own permission scope.
ToolSchemaScope
Connected agents / A2A
Delegation between specialised agents, with the boundary and budget of each delegation declared up front.
DelegationBudgetBoundary
Approval workflow
Human gates on the actions that warrant one, carrying the evidence the approver needs.
ApprovalThresholdDecision
What the engineer owns here
Autonomy boundaries and the identity each tool call runs under.
Where this layer fails
An unbounded step budget. The loop that works on ten cases quietly costs a hundred times more on the eleventh.
05/06
Governance & safety
Identity, network isolation, content safety, policy and the agent inventory.
Takes in
Proposed actions and drafted responses from the agent layer.
Hands on
Permitted, isolated, screened output attributable to a named identity.
SystemWhat it doesKey business entities
Entra ID and managed identity
On-behalf-of flows so an agent acts as the user, never above them, and the audit log names a person.
IdentityTokenOn-behalf-of
Private endpoints and network isolation
Keeps model and search traffic off the public path, which is usually a hard precondition rather than a preference.
EndpointVNetRule
Azure AI Content Safety
Input and output screening including prompt-injection and groundedness detection.
CategorySeverityVerdict
Agent inventory and policy
A register of which agents exist, what they may do and who owns them — the thing that is missing when an estate has forty of them.
Agent recordOwnerPermitted action
What the engineer owns here
On-behalf-of identity so an agent can never exceed the user it acts for.
Where this layer fails
A service principal with standing broad rights. It is the shortest path to a working demo and the one finding an assessor will always write up.
06/06
Evaluation & operations
Evals in CI, tracing, cost management and capacity planning.
Takes in
Permitted, screened output from the governance layer.
Hands on
Measured quality, latency and cost per task, and a gate that can block a release.
SystemWhat it doesKey business entities
Foundry evaluations
Graded runs on held-out sets, in CI, producing a number a release decision can be made on.
EvaluatorRunScore
OpenTelemetry GenAI traces
Spans across retrieval, model and tool calls under the GenAI semantic conventions, so traces are portable rather than bespoke.
TraceSpanAttribute
Azure Monitor
Latency, error and cost telemetry with alerting on the thresholds that matter to users.
MetricAlertDashboard
Provisioned throughput
Reserved capacity for predictable latency, and the capacity model that justifies it.
PTUQuotaUtilisation
What the engineer owns here
The regression gate and the cost model that make it operable at scale.
Where this layer fails
Traces without evals. You can see exactly how the wrong answer was produced and still have no idea whether last week’s change made things better or worse.
What you will actually use
Models
- GPT-family and o-series reasoning models
- Partner models via Foundry
- Model router for tiering
Agents
- Foundry Agent Service
- Microsoft Agent Framework
- MCP tool servers
- A2A multi-agent
Grounding
- Azure AI Search hybrid + semantic rank
- Foundry IQ knowledge layer
- Security trimming
Data
- Microsoft Fabric / OneLake
- Microsoft Graph
- Purview classification
Governance
- Entra ID managed identity
- Private Link isolation
- Azure AI Content Safety
Operations
- Foundry evaluations
- Azure Monitor + OTel
- Provisioned throughput
Constraints that shape the design
Landing zone discipline
Enterprises expect deployment inside an existing landing zone with policy, identity and networking already defined. Plan for it rather than around it.
Permission-trimmed retrieval
If the index does not respect source permissions per user, the deployment is a data-leak incident waiting to be found.
Quota and capacity
Quota is regional and finite. Request early and design for provisioned throughput where latency and cost must be predictable.
Region and residency
Model availability differs by region and residency rules may forbid the obvious one. Confirm before designing.
04
Part 3 · Getting it done
Where the business and the technology meet
Part 3 puts the lifecycle and the platform together: the patterns you will build repeatedly, then the modules, labs and capstones that prove you can.
Patterns, mapped to the lifecycle and the architecture
Filter by lifecycle stage or by earned autonomy. Selecting a use case jumps the value chain and the architecture to the stage and layer it depends on.
Value chain stage
Autonomy earned
12 use cases
No use cases match that combination.
The delivery playbook
How an Azure engagement actually runs.
01
Day 1 — land in the landing zone
Get the subscription, managed identity, quota and private networking sorted before writing code. These are the long-lead items.
02
Week 1 — grounding before agents
Build permission-trimmed retrieval and measure recall. Almost every quality problem later traces back to this.
03
Week 2-3 — thin slice with evals
Ship one workflow end to end with an eval set and a baseline from day one.
04
Week 4-5 — identity and safety review
Take on-behalf-of identity, content safety and network isolation to the security architect early.
05
Week 6 — cost model and handover
Model cost per task, choose the pricing mode, and hand over runbook, evals and agent inventory.
The curriculum
4 modules, 60 taught hours, 20 hands-on labs and 4 assessments — every lab provisioned and graded by the SCIKIQ Agentic AI Playground. Open a module to see its labs.
01Foundry foundations and enterprise landingThe platform, the landing zone and the model decisions that determine everything downstream.15 hrs · 5 labs
Foundry architectureModel catalogue and routingLanding zone and quotaRegions and residencyStructured outputsCost per task
01
First agentDeploy a Foundry agent inside a landing zone with managed identity.
02
Model routingRoute between tiers on measured difficulty and quantify the saving.
03
Structured outputsEnforce schema-valid outputs and handle validation failure.
04
Quota planningModel capacity for a workload and choose a pricing mode.
05
Cost baselineMeasure cost per task and establish a baseline to improve against.
Assessment 01 — Platform foundations
02Grounding with Azure AI SearchEnterprise retrieval done properly — hybrid, ranked and permission-trimmed.15 hrs · 5 labs
Hybrid retrievalSemantic rankingSecurity trimmingChunking strategyFreshnessRetrieval evaluation
01
Hybrid indexBuild a hybrid index and measure recall against a labelled set.
02
Security trimmingEnforce per-user permissions at query time and prove it.
03
Chunking studyCompare chunking strategies empirically rather than by preference.
04
Freshness pipelineKeep the index current and detect staleness.
05
Retrieval evalsGate builds on recall@k and citation correctness.
Assessment 02 — Retrieval & grounding
03Agents, tools and multi-agent orchestrationAgent Service, MCP tools, connected agents and the identity model underneath them.15 hrs · 5 labs
Agent Service runtimeMCP tool designOn-behalf-of identityMulti-agent patternsApproval gatesContainment
01
MCP tool serverExpose a line-of-business system as a typed, scoped MCP tool.
02
On-behalf-ofFlow delegated user identity through a multi-step agent.
03
Multi-agentBuild a supervisor/worker workflow with connected agents.
04
Approval gateInsert a human approval that blocks the action, not just the reply.
05
ContainmentAdd budget, loop and blast-radius limits and test them.
Assessment 03 — Agents, tools & identity
04Evaluation, safety and production operationsProving it works, keeping it safe and running it at a cost that survives review.15 hrs · 5 labs
Eval sets and baselinesRegression gatingContent safetyNetwork isolationOTel tracingCost management
01
Eval harnessBuild an eval set with a baseline and wire it into CI.
02
Regression gateBlock a deployment on a groundedness regression.
03
Safety layerAdd layered content safety and defeat a jailbreak attempt.
04
Private deploymentDeploy with private endpoints and prove no public egress.
05
Trace and costInstrument OTel GenAI traces and halve cost per task.
Assessment 04 — Evaluation, safety & operations
Two capstones — 20 hours
End-to-end agent design, development, deployment and testing, 10 hours each. Reviewed by a Senior SCDAI Engineer against a published rubric.
Capstone A — Permission-trimmed enterprise agent
Build an agent grounded on enterprise content with provable per-user permission trimming, delegated identity, an eval baseline and a measured cost per task.
Capstone B — Multi-agent workflow with regression gating
Build a connected multi-agent workflow with MCP tools, human approval on consequential actions, CI-enforced eval gating and full OTel tracing.
What you deliver, and how it is marked
- A running agent, deployed on the program's target stack, reachable by a reviewer.
- An architecture note: boundaries, tools, autonomy level and the trade-offs you took.
- A versioned eval set with a baseline and your final scores.
- A trace walkthrough of one success and one deliberate failure.
- Cost per task, measured — not estimated.
- A runbook and rollback path a client team could operate on Monday.
Problem fit15%Is this a decision worth automating, scoped to a defensible boundary?
Architecture20%Right pattern for the constraints; autonomy earned, not assumed.
Grounding & accuracy20%Measured groundedness against the eval set, with the failures named.
Safety & compliance20%Domain controls actually enforced, and demonstrably so.
Operability15%Traces, runbook, rollback, cost — could someone else run this?
Communication10%Can a client executive follow the reasoning in ten minutes?
One lab, start to finish
Every lab in this program follows the shape below. This is lab 02 in full — the brief you are given, the environment that is provisioned for you, the code you start from and the assertions that decide whether you passed.
Module 02 · Grounding with Azure AI Search
Permission-trimmed retrieval
Prove retrieval respects each user’s permissions at query time.
The brief
Index a corpus where three user groups have overlapping but unequal access. Build retrieval that trims at query time, then attempt to extract a restricted document as each user.
Provisioned for you
- Azure AI Search index, 5k documents
- 3 user identities with distinct ACLs
- 60 labelled questions, 18 targeting restricted content
You start from this
def search(query, user_token):
"""Trim by the caller's permissions in the query filter -- not by
filtering results after they have already been retrieved."""
raise NotImplementedErrorWhat the grader asserts
- No restricted document appears in results for an unentitled user
- Restricted content never reaches the model context, not merely the response
- Recall for entitled users is unchanged by the trimming
- Permission changes take effect without a reindex
- Traces contain no restricted content
05
Assessment
Assessed, not attended
Every module ends with a timed, randomised assessment delivered through the SCIKIQ Agentic AI Playground. The certificate requires a pass on all of them plus two reviewed capstones.
Assessment blueprint
What each test covers, how long it runs, and how many items are currently in the versioned bank behind it.
| # | Assessment & coverage | Items | Time | In bank |
|---|---|---|---|---|
| 01 | Platform foundationsFoundry architectureModel selection and routingLanding zone and quotaCost per task | 30 | 45 min | 4 |
| 02 | Retrieval & groundingHybrid retrievalSecurity trimmingChunkingRetrieval metrics | 30 | 45 min | 4 |
| 03 | Agents, tools & identityAgent runtimeMCP tool designDelegated identityMulti-agent and containment | 30 | 45 min | 4 |
| 04 | Evaluation, safety & operationsEval design and gatingContent safetyNetwork and identity securityObservability and cost | 35 | 50 min | 4 |
Single best answerOne defensible option among plausible distractors drawn from real field mistakes.
Scenario judgementA client situation with constraints; you pick the action a Senior SCDAI Engineer would take.
Architecture selectionGiven non-functional requirements, choose the pattern and justify the trade-off.
Failure diagnosisA trace, an eval report or a cost curve — identify the root cause.
- Each module ends with a timed assessment; the program certificate requires a pass on every one.
- Items are drawn at random from a versioned bank, so no two learners sit an identical paper.
- Pass mark is 70%. Two retakes are included, each with a fresh draw.
- Scenario items carry double weight — they are the ones that predict field performance.
- Capstones are reviewed against a published rubric by a Senior SCDAI Engineer, not auto-graded.
Try four questions from the bank
Real items, drawn from 16 in this program's bank — weighted toward the scenario and diagnosis types, because those are the ones that predict field performance. Instant feedback, nothing saved.
Four sample items — one attempt each, then the reasoning is shown.
Q1A client insists on the largest model for every task. What do you do?
Tier selection should be empirical. Routing easy tasks to cheaper models is usually the largest single cost lever.
Q2Enterprise retrieval must respect per-user permissions. Where is this enforced correctly?
Post-filtering means the content was retrieved and may appear in traces or influence generation. Trim at query time.
Q3Why expose systems as MCP tools rather than embedding integration in each agent?
The tool estate is the durable asset. Per-agent integration multiplies both build cost and review burden.
Q4A content safety filter blocks legitimate clinical or financial terminology. What is the fix?
Default safety settings are tuned for consumer contexts. Enterprise domains need calibration, not bypass.
06
Career & outcomes
What this makes you, and where it goes next
The same ladder whichever specialisation you enter through — what changes is the domain you go deep in. Below: how the program is delivered, the skills it moves, the roles it leads to, and the specialisations closest to this one.
Available two ways
The same labs, assessments and capstones, delivered to an enterprise cohort or to individual professionals.
B2B
Direct to enterprise
Cohorts of 20 to 2,000+ on your own tenancy, with your data patterns and your cloud. Skill-gap baselining up front, per-team mastery reporting throughout, and capstones scoped against your real backlog so the output is deployable work.
- Private cohort on your tenancy
- Baseline skills assessment before kick-off
- Capstones scoped to your backlog
- Per-team mastery dashboards for L&D
- Optional Senior SCDAI Engineer architecture reviews
B2C
Direct to individual professionals
The same labs, assessments and capstones for individual engineers and analysts, run on shared infrastructure with a fixed cohort calendar. You leave with a graded portfolio, not a certificate of attendance.
- Fixed-date cohorts, self-paced within them
- Same graded labs and item bank
- Portfolio-ready capstones you own
- Certificate on a pass in every module
- Community and office-hours access
Skill matrix
Find your row and aim one column right. The Playground scores you against this after every module.
| Skill | Beginner | Intermediate | Advanced |
|---|---|---|---|
| Azure platform | Calls a model endpoint. | Deploys inside a landing zone with managed identity. | Designs an enterprise agent estate with policy and cost control. |
| Enterprise retrieval | Builds an index. | Enforces security trimming and measures recall. | Designs grounding for a permissioned estate at scale. |
| Delegated identity | Uses a service key. | Implements on-behalf-of flows. | Designs least-privilege identity across a tool estate. |
| Context engineering | Writes clear prompts. | Structures retrieval, tools and state deliberately. | Designs context strategy for reliability and cost at scale. |
| Retrieval & grounding | Builds basic vector search. | Tunes chunking, hybrid search and reranking. | Designs graph + vector grounding with measured recall. |
| Agent orchestration | Runs a single tool-calling agent. | Builds supervised multi-step and multi-agent flows. | Designs autonomy boundaries and failure containment. |
| Tool & system integration | Calls a documented API. | Writes an MCP server over a system of record. | Designs a least-privilege tool estate across systems. |
| Evaluation | Eyeballs outputs. | Builds labelled eval sets and regression gates. | Runs online evals with drift and judge calibration. |
| Observability & cost | Reads logs. | Traces runs, tracks tokens and latency. | Owns cost per task and capacity planning in production. |
| Security & guardrails | Adds output filters. | Mitigates the OWASP LLM Top 10 in a build. | Threat-models an agent estate and proves controls. |
| Client delivery | Takes notes in a workshop. | Runs discovery and scopes a thin slice. | Owns the account technically, from scope to handover. |
Where it takes you
The SCDAI ladder is the same whichever specialisation you enter through — what changes is the domain you go deep in.
01
Data and AI EngineerEntry
Python, LLM APIs, first RAG build, prompt and context basics.
02
Associate Data and AI EngineerPractitioner
Client-facing discovery, tool integration, agent build under supervision.
03
SCIKIQ Certified Data and AI EngineerSpecialist
Owns a deployment end to end — scoping, build, evals, handover.
04
Senior Data and AI Engineer / Domain LeadSenior
Multi-agent architecture, regulated deployments, reference patterns for the practice.
05
AI Architect / Practice LeadLeadership
Portfolio of accounts, delivery standards, hiring and capability strategy.
Terms worth knowing
- Foundry
- Microsoft’s platform for building, deploying, governing and monitoring agents.
- Agent Service
- The managed agent runtime on the Responses API with MCP and A2A support.
- Security trimming
- Filtering retrieval results by the calling user’s permissions at query time.
- On-behalf-of
- An identity flow where a service acts with a user’s delegated permissions.
- Provisioned throughput
- Reserved model capacity giving predictable latency and cost.
- Private endpoint
- A private network path to a service, keeping traffic off the public internet.
- ACS
- Agent Control Specification — a specification for governing agent behaviour.
- Purview
- Microsoft’s data governance and classification service.
- SCDAI
- SCIKIQ Certified Data and AI Engineer — the credential this program awards.
- SCDAI engineer
- An engineer embedded with the customer who turns their constraints into a working system.
- Thin slice
- The narrowest end-to-end path through a workflow that still produces business value.
- Agentic RAG
- Retrieval where the agent decides when, what and how often to retrieve.
- MCP
- Model Context Protocol — open standard connecting an agent to tools and data.
- A2A
- Agent2Agent — protocol for agent-to-agent delegation across vendors.
- Eval set
- A labelled, versioned set of cases an agent must pass before release.
- LLM-as-judge
- Using a model to score outputs, calibrated periodically against human ratings.
- Guardrail
- An enforced constraint on an input, output or action — not a prompt request.
- Human-in-the-loop
- A required human approval step before a consequential action executes.
- Cost per task
- Total token, tool and compute cost of one completed unit of work — the engineer's unit economic.
- Golden path
- The reference architecture a practice standardises on so deployments stay reviewable.
- Handover
- The point at which the client can operate, evaluate and change the system without the engineer.
Related programs
Skill a team, or join a cohort
B2B cohorts run on your tenancy with capstones scoped to your backlog. B2C cohorts run on a fixed calendar.
07
Enrolling
What you need, what you get, and what it costs
Stated plainly enough to rule yourself in or out without a sales call: the prerequisites, how the program runs, exactly what the credential is worth, and the questions everyone asks.
Before you start
Stated plainly so you can rule yourself in or out without a sales call. Nothing here is a formal qualification — it is what the first lab assumes you can already do.
Technical
You should already be able to do these
- Comfortable in Python: functions, typing, virtual environments, reading a stack trace
- Have called an LLM API and handled a structured response
- Git, the command line, and reading someone else’s code without panic
Domain
What we assume, and what we teach
- An Azure subscription you can deploy into, or your employer’s sandbox
- Basic cloud literacy: identity, networking, resource groups
Time and access
What the program asks of your week
- A machine that can run a browser and a terminal — labs run in the Playground, not locally
- Roughly 8 hours a week for the taught weeks, plus 20 hours for the two capstones
How it runs
Cohort dates and pricing are confirmed on enquiry rather than printed here, because both move with the intake.
- Format
- Self-paced within a fixed cohort window, delivered in the SCIKIQ Agentic AI Playground
- Taught hours
- 60 hours across 4 modules
- Capstones
- 20 hours — two end-to-end builds, reviewed not auto-graded
- Typical duration
- 10–12 weeks at around 8 hours a week
- Level
- Intermediate → Advanced
- Built for
- Engineers deploying agents on Microsoft Foundry and Azure
- Next cohorts
- — confirmed on enquiry
- Pricing
- — confirmed on enquiry
The credential
The credential is awarded per specialisation, so it names the domain or stack you were assessed in rather than claiming general competence. On this program the badge reads SCDAI — OpenAI + Azure Tech Stack.
How it is earned
- A pass at 70% or above on every module assessment — not an average across them
- Both capstones reviewed against the published rubric by a Senior SCDAI Engineer
- All labs submitted and machine-graded green
- Awarded as
- A verifiable digital badge with a public credential record
- Valid for
- Two years from award
- Recertification
- One current-year assessment plus a refreshed capstone
- Retakes
- Two included per assessment, each with a fresh item draw
- Named specialisation
- The badge states the domain or stack, e.g. SCDAI — Healthcare
- Verification
- Third parties confirm a holder from the credential record, no login required
A certificate that cannot be checked is decoration. Every award resolves to a record showing the specialisation, the award date and the assessments passed.
The certificate you leave with
This is the credential the program awards, shown exactly as it is issued — with the specialisation named, the assessment record attached and a verification link anyone can check without an account.
SCIKIQ Data Academy
Certificate of Professional Certification
This is to certify that
Your name
has been assessed and certified as
SCIKIQ Certified Data and AI Engineer
OpenAI + Azure Tech Stack
- Specialisation
- OpenAI + Azure Tech Stack
- Assessments passed
- 4 of 4, each at 70% or above
- Labs graded
- 20 of 20 machine-graded green
- Capstones reviewed
- 2, against the published rubric
- Taught hours
- 60 across 4 modules, plus 20 capstone hours
AwardedOn completion
Valid untilTwo years from award
Credential IDSCDAI-OPENAI-AZURE-<issued>
Senior SCDAI Engineer, Certification Board
- 01The specialisation is on the certificate
Not “Data and AI Engineer” but the domain or stack you were actually assessed in. A general claim would be a weaker one.
- 02The assessment record travels with it
Modules passed, labs graded and both capstones reviewed — so the credential states what was measured rather than that you attended.
- 03Anyone can verify it, without a login
The credential ID resolves to a public record showing the specialisation, the award date and the assessments passed.
Share it on LinkedIn
Add it to your LinkedIn profile in one step. The link pre-fills the certification fields from the credential record, so the entry on your profile matches the record a reader can check.
Add to LinkedIn profile The button is live on your real certificate; here it opens LinkedIn pre-filled with this specialisation so you can see exactly what the profile entry will say.A certificate that cannot be checked is decoration. Every award resolves to a record showing the specialisation, the award date and the assessments passed.
Questions we get asked
The objections that come up in every conversation about this program, answered without the brochure voice.
Is this a course or a certification?
Both, and the second is the point. Eight timed assessments and two reviewed capstones stand between you and the credential, so a pass means someone measured the skill rather than recorded your attendance.
How is it self-paced without falling apart?
Every lab is provisioned, graded and unblocked by the Playground rather than by an instructor. That is what lets a cohort of 2,000 cost the same faculty time as a cohort of 20 — and why you are never waiting on someone to mark your work.
What if I fail an assessment?
Two retakes are included per assessment, each drawing a fresh item set from the bank, so a retake is a genuinely new paper rather than the same questions again.
Do I need my own cloud account?
For the domain specialisations, no — labs run in provisioned sandboxes. For the four tech-stack programs you will want access to that platform, since deploying into a real subscription is much of the point.
Can we run this privately for our team?
Yes. B2B cohorts run on your own tenancy with your data patterns, a skills baseline before kick-off, per-team mastery reporting, and capstones scoped against your actual backlog so the output is deployable work rather than an exercise.
Which specialisation should I take?
Take the domain you deploy into. If you move across industries, take a tech-stack program instead and pick up domain context on the engagement. The chooser on the programs page will narrow it.
How current is the material?
The trends, platform capabilities and regulatory positions are reviewed each quarter, and every external claim on these pages links to its source so you can check the date yourself.
What do I actually leave with?
A graded portfolio: forty machine-graded labs, two reviewed end-to-end agent builds with measured evaluation and cost per task, and a verifiable credential naming your specialisation.
Still deciding?
Tell us the systems you deploy into and we will say plainly whether this specialisation is the right one — or which of the 21 is.