Industry7 leading families
The open-weight field consolidated around a few families
Qwen3, DeepSeek, Llama 4, GLM, Mistral, Kimi and gpt-oss are the families that matter in 2026, with a size ladder from sub-billion to very large MoE.
Program 21 · Tech stack specialisation
SCIKIQ Certified Data and AI EngineerOpen Source & Open-Weight LLMs / SLMs
Self-hosting is chosen for three reasons: sovereignty, unit economics at volume, and control over a model that will not change under you. All three are legitimate — and all three are frequently invoked when a managed API would be cheaper and better. Knowing which situation you are in is the core skill this program teaches.
- 60 hrstaught
- 20hands-on AI labs
- 4assessment tests
- +20 hrs2 E2E capstones
~256MMonthly tokens near the crossover where self-hosting beats a premium API
60-70%Sustained GPU utilisation that crossover assumes
Apache 2.0Licence on gpt-oss-20b and gpt-oss-120b, both 128K contextOpenAI
Qwen3, DeepSeek, Llama 4, Mistral, GLM, Kimi, gpt-ossLeading open-weight families in 2026
01
Part 1 · The business
The value chain, the people, the trends
Part 1 is the delivery lifecycle for self-hosted models, where the first stage — deciding whether to self-host at all — matters more than anywhere else.
The self-hosted delivery lifecycle
Six stages. Select one to see what it means when you own the infrastructure.
01
Scope & decide
Establish whether self-hosting is genuinely justified, and by which of the three reasons.
Decisions made here
- Sovereignty, economics or control?
- What is the real token volume?
- What utilisation can we sustain?
Where it breaks today
- Self-hosting chosen for prestige rather than need
- Volume estimates that ignore retries and evals
- Utilisation assumptions nobody validates
What is measured
- Cost per million tokens
- GPU utilisation
- Break-even volume
Where AI landsAn honest crossover model: below roughly 256M tokens a month at 60-70% utilisation, managed APIs usually win.
Cost per million tokensGPU utilisationBreak-even volume
02
Ground & retrieve
Build retrieval, including self-hosted embeddings and reranking.
Decisions made here
- Which embedding model?
- Self-host the reranker too?
- What is the freshness path?
Where it breaks today
- Embedding model chosen without evaluation
- Reranking skipped because it is another service
- Index drift
What is measured
- Recall@k
- Embedding throughput
Where AI landsSelf-hosted embedding and reranking models alongside the generator, all on the same serving stack.
Recall@kEmbedding throughput
03
Serve & build
Stand up high-throughput serving and build the agent against an OpenAI-compatible endpoint.
Decisions made here
- vLLM or SGLang?
- Which quantisation?
- What batching strategy?
Where it breaks today
- Naive serving with terrible throughput
- Quantisation applied without measuring quality loss
- No load testing
What is measured
- Tokens per second
- Throughput per GPU
- p95 latency
Where AI landsvLLM or SGLang with continuous batching, speculative decoding and an OpenAI-compatible API.
Tokens per secondThroughput per GPUp95 latency
04
Evaluate & tune
Evaluate against the managed baseline, then fine-tune only if evaluation says you should.
Decisions made here
- Does the open model hold quality?
- Fine-tune or prompt better?
- LoRA or full fine-tune?
Where it breaks today
- Fine-tuning reached for before prompting is exhausted
- No held-out set
- Catastrophic forgetting undetected
What is measured
- Task accuracy vs baseline
- Regression on general capability
Where AI landsHonest benchmarking against a managed baseline, then LoRA fine-tuning where the data justifies it.
Task accuracy vs baselineRegression on general capability
05
Secure & govern
Sovereignty controls, licence compliance, isolation and model provenance.
Decisions made here
- Does the licence permit this use?
- Where do weights live?
- What is the data boundary?
Where it breaks today
- Licence terms unread until legal asks
- Model weights of unverified provenance
- No isolation between tenants
What is measured
- Licence compliance
- Isolation coverage
Where AI landsLicence review, weight provenance verification, air-gapped or sovereign deployment where required.
Licence complianceIsolation coverage
06
Deploy & operate
Run GPU infrastructure with the reliability and economics of a real service.
Decisions made here
- How do we scale?
- What happens on GPU failure?
- What is the actual unit cost?
Where it breaks today
- Idle GPUs destroying the economics
- No autoscaling for spiky load
- Single point of failure
What is measured
- Utilisation
- Cost per million tokens
- Availability
Where AI landsKubernetes GPU scheduling, autoscaling, and utilisation management as the primary cost lever.
UtilisationCost per million tokensAvailability
Who you work with on this stack
Self-hosting turns AI into an infrastructure problem, so infrastructure people become central. Select one to light the stages they own.
What is changing on this stack
Open weights closed much of the capability gap; the economics gap is subtler.
OpenAIApache 2.0, 128K
Apache-licensed reasoning models arrived
gpt-oss-20b and gpt-oss-120b are Apache 2.0 open-weight reasoning models with 128K context, which removed a major licensing objection.
IndustryContinuous batching
vLLM and SGLang are the serving default
Continuous batching and speculative decoding in vLLM or SGLang, behind an OpenAI-compatible endpoint, is the standard production pattern.
Industry~256M tokens/month
The crossover is higher than people assume
Against a premium API near $5 per million tokens, self-hosting typically breaks even around 256M tokens a month — and only at 60-70% sustained utilisation.
IndustrySLMs carry the volume
Small models do most of the volume
Classification, extraction and routing dominate token volume in most deployments, and small models handle them at a fraction of the cost.
IndustryOne recipe, many sizes
Prototype small, scale the recipe
Model families with a wide size ladder let you prototype a fine-tune on a small variant and scale the same recipe up.
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.
- IndustrySelf-Hosting Open-Weight LLMs: 2026 Decision Guide~256M tokens/month crossover at 60-70% utilisation
- IndustryThe Best Open-Source LLMs in 2026Leading open-weight families and serving stacks
02
Part 2 · Data and meaning
The platform building blocks
Part 2 is the self-hosted stack: serving, quantisation, fine-tuning and the GPU economics that determine whether any of it was a good idea.
The platform landscape
Six building blocks, and utilisation is the one that decides the business case.
Models
Open-weight families across a size ladder, from sub-billion to large MoE.
Qwen3, Llama 4, DeepSeek, Mistral, Gemma, gpt-ossServing
High-throughput inference with continuous batching behind a standard API.
vLLM, SGLang, TensorRT-LLMFine-tuning
Parameter-efficient adaptation and the data pipelines behind it.
LoRA/QLoRA, Axolotl, TRL, UnslothRetrieval
Self-hosted embeddings, vector store and reranking.
bge/e5 embeddings, pgvector, Qdrant, rerankersOrchestration
GPU scheduling, autoscaling and multi-tenancy.
Kubernetes, KServe, Ray, GPU operatorsAssurance
Evaluation, tracing and cost accounting per token.
Eval harnesses, OTel, Prometheus/Grafana
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 components and SCDAI engineer responsibilities.
01/06
Data & corpora
Source content and, where fine-tuning is justified, curated training data with provenance.
Takes in
Enterprise data and documents, inside your own network boundary.
Hands on
A versioned, redacted, reproducible corpus for indexing.
SystemWhat it doesKey business entities
Object store and lakehouse
The corpus and its metadata, held inside your own boundary — which is usually why this stack was chosen at all.
ObjectTablePartition
Document parsing pipeline
Self-hosted layout parsing and chunking, with the page references citations depend on.
DocumentLayoutChunk
Classification and redaction
Sensitive-data detection and de-identification before embedding, because the embeddings are yours to keep and yours to leak.
EntityLabelRedaction
Dataset versioning
Immutable, versioned corpora so an eval result can be reproduced months later.
Dataset versionHashManifest
What the engineer owns here
Training-data quality and the guarantee it never leaves the boundary.
Where this layer fails
An unversioned corpus. Without it, a quality regression is unattributable — you cannot tell whether the model, the prompt or the data moved.
02/06
Retrieval
Self-hosted embedding and reranking models with a vector store you operate.
Takes in
A versioned, redacted corpus from the data layer.
Hands on
Ranked, filtered, citable passages from infrastructure you operate.
SystemWhat it doesKey business entities
Self-hosted vector store
Qdrant, Weaviate, Milvus or pgvector, chosen on filtering, memory profile and who will operate it at 3am.
CollectionVectorPayload filter
Lexical index
BM25 alongside vectors, because identifiers and codes are where dense retrieval is weakest.
TermPostingScore
Embedding service
Open embedding models served in your boundary, with the versioning that makes a re-embed a planned event rather than a surprise.
Embedding modelDimensionVersion
Reranker
A cross-encoder over the candidate set — usually the cheapest large quality gain available on this stack.
CandidateRankScore
What the engineer owns here
Choosing embeddings on measured recall rather than reputation.
Where this layer fails
Changing the embedding model without re-embedding the corpus. Old and new vectors are not comparable, and retrieval degrades in a way that looks like a model problem.
03/06
Models & serving
Model selection, quantisation, and high-throughput serving behind an OpenAI-compatible API.
Takes in
Ranked, citable passages from retrieval.
Hands on
Model output at a cost and latency you control end to end.
SystemWhat it doesKey business entities
Serving runtime
vLLM, TGI or SGLang — continuous batching and paged attention are what make self-hosting economic rather than merely possible.
EngineBatchKV cache
Open-weight model families
Llama, Mistral, Qwen, Gemma and the rest, selected per task rather than one model for everything.
CheckpointParameter countLicence
Quantisation and compilation
AWQ, GPTQ or FP8 to fit the model on the accelerator you actually have, at a measured quality cost.
PrecisionKernelThroughput
Fine-tuning and adapters
LoRA adapters for the narrow tasks where prompting has genuinely run out of room.
AdapterTraining runCheckpoint
What the engineer owns here
Throughput per GPU — the number the entire business case rests on.
Where this layer fails
Quantising without re-running the evals. The throughput number improves immediately and the quality cost shows up in the tail, where nobody is looking.
04/06
Agents & tools
Agent logic written against a standard endpoint so models remain swappable.
Takes in
Model output and the tool surface it is permitted to use.
Hands on
Resumable actions with a trace, on infrastructure you own.
SystemWhat it doesKey business entities
Agent framework
The loop, the tool contract and the state machine — explicit, because no managed runtime is supplying them here.
TaskStepTool call
MCP tool servers
Typed tools with declared schemas and scopes, the same contract the managed stacks use.
ToolSchemaScope
Durable state
Checkpointed task state in your own store, so a restart resumes rather than repeats.
CheckpointRunResume token
Structured output enforcement
Grammar or schema-constrained decoding, since open models need the constraint applied rather than requested.
GrammarSchemaValidation
What the engineer owns here
Portability — keeping the agent independent of any one model.
Where this layer fails
Assuming tool-calling reliability from a managed API. On open weights it varies by model and by prompt, and constrained decoding is not optional.
05/06
Sovereignty & governance
Licence compliance, weight provenance, isolation and residency controls.
Takes in
Proposed actions and drafted responses from the agent layer.
Hands on
Permitted, screened, logged output inside your own boundary.
SystemWhat it doesKey business entities
Identity and authorisation
Your own identity provider carried through to every tool call, with per-tool scopes.
PrincipalScopeToken
Open guardrail models
Llama Guard, Prompt Guard or equivalents for input and output screening, served alongside the main model.
CategoryVerdictThreshold
Network and tenancy isolation
Boundary controls around GPU nodes and stores — on this stack you own the isolation as well as the inference.
SegmentNamespacePolicy
Audit log
Immutable record of prompts, retrievals, tool calls and outputs, retained to your own schedule.
Audit entryActorEvidence
What the engineer owns here
Being able to answer, precisely, what the licence permits and where the weights came from.
Where this layer fails
Self-hosting the model and outsourcing the guardrail. The data-residency argument that justified the stack does not survive the first screening call leaving the boundary.
06/06
Evaluation & operations
Benchmarking against baseline, GPU operations, autoscaling and unit cost accounting.
Takes in
Permitted, screened output from the governance layer.
Hands on
Measured quality, throughput and true unit cost, on hardware you are paying for anyway.
SystemWhat it doesKey business entities
Evaluation harness
Your own held-out sets and graders, run on every model, adapter and prompt change.
Eval setGraderBaseline
GPU observability
Utilisation, memory, queue depth and tokens per second — the numbers that decide whether the cluster is sized right.
UtilisationQueue depthThroughput
Tracing
OpenTelemetry spans across retrieval, inference and tools, in your own backend.
TraceSpanAttribute
Capacity and unit cost
Cost per task derived from GPU-hours and utilisation, which is the only fair comparison against a managed API.
GPU hourUtilisationCost per task
What the engineer owns here
Utilisation management, because idle GPUs are how the economics collapse.
Where this layer fails
Comparing self-hosted cost per token against an API price. The honest comparison is cost per completed task at your real utilisation, and idle GPUs are the whole argument.
What you will actually use
Models
- Qwen3 and Llama 4 families
- gpt-oss (Apache 2.0)
- Mistral, DeepSeek, Gemma
- Small models for narrow tasks
Serving
- vLLM or SGLang
- Continuous batching
- Speculative decoding
- OpenAI-compatible endpoint
Tuning
- LoRA / QLoRA
- Instruction data curation
- Held-out evaluation
Grounding
- Self-hosted embeddings
- pgvector or Qdrant
- Self-hosted reranker
Infrastructure
- Kubernetes GPU scheduling
- Autoscaling
- Multi-tenancy isolation
Assurance
- Baseline benchmarking
- OTel tracing
- Cost per million tokens
Constraints that shape the design
Utilisation is the business case
The crossover assumes 60-70% sustained utilisation. Spiky, low-volume workloads self-host at a loss almost every time.
Licences differ materially
Apache 2.0, community licences with usage caps, and research-only terms are not interchangeable. Read them before selecting.
Quantisation costs quality
Quantisation is usually worth it, but the loss must be measured on your task rather than assumed to be negligible.
Fine-tune last
Exhaust prompting, retrieval and model selection first. Most fine-tuning projects were retrieval problems.
04
Part 3 · Getting it done
Where the business and the technology meet
Part 3 is the patterns that make self-hosting work, then the modules, labs and capstones that prove you can run open models in production without the economics quietly failing.
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 a self-hosted deployment actually runs.
01
Week 1 — do the crossover honestly
Model volume, utilisation and fully-loaded cost. Be willing to conclude that a managed API wins, and say so.
02
Week 2 — benchmark against baseline
Prove the open model holds quality on the customer’s own labelled tasks before committing to infrastructure.
03
Week 3-4 — serve properly
Stand up vLLM or SGLang, tune batching, measure throughput per GPU and load-test at target concurrency.
04
Week 5 — tune only if evaluation demands it
Exhaust prompting and retrieval first. If you fine-tune, hold out data and test for regression beyond the target task.
05
Week 6 — operationalise and hand over
Autoscaling, failure handling, licence register and cost accounting, then hand over the runbook.
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.
01Open-weight foundations and economicsModel families, licences, and the crossover analysis that should come first.15 hrs · 5 labs
Open-weight familiesLicence typesSize ladders and SLMsCrossover analysisUtilisationCost per million tokens
01
Model surveyEvaluate three open-weight families on one task and report honestly.
02
Licence reviewProduce a licence register for a candidate model set.
03
Crossover modelBuild a break-even model for a real workload including idle cost.
04
SLM routingRoute high-volume narrow tasks to a small model and measure parity.
05
Cost baselineEstablish fully-loaded cost per million tokens.
Assessment 01 — Open-weight foundations & economics
02Serving, quantisation and throughputGetting real throughput out of the hardware you are paying for.15 hrs · 5 labs
vLLM and SGLangContinuous batchingSpeculative decodingQuantisationKV cache and memoryLoad testing
01
vLLM deploymentServe a model with continuous batching and an OpenAI-compatible API.
02
Throughput tuningTune batching and memory settings and quantify tokens per second.
03
Quantisation studyQuantise and measure quality loss on your own task.
04
Speculative decodingAdd speculative decoding and measure the latency gain.
05
Load testLoad-test at target concurrency and find the breaking point.
Assessment 02 — Serving & throughput
03Retrieval, fine-tuning and evaluationSelf-hosted grounding, LoRA where it is justified, and honest benchmarking.15 hrs · 5 labs
Self-hosted embeddingsVector storesRerankingLoRA/QLoRAData curationBaseline benchmarking
01
Embedding selectionChoose an embedding model on measured recall, not reputation.
02
Self-hosted rerankerAdd reranking on your own infrastructure and quantify the gain.
03
LoRA fine-tuneFine-tune on curated data and validate against a held-out set.
04
Regression testingDetect capability loss outside the fine-tuned task.
05
Baseline benchmarkCompare against a managed baseline on customer tasks.
Assessment 03 — Retrieval, tuning & evaluation
04Sovereignty, operations and scaleRunning GPUs like a service, with the compliance answers ready.15 hrs · 5 labs
Air-gapped deploymentLicence complianceGPU schedulingAutoscalingObservabilityFailure handling
01
Air-gapped buildDeploy with no external dependency and vendor every artefact.
02
GPU schedulingSchedule multi-model workloads on shared GPUs.
03
AutoscalingScale with demand while keeping utilisation in the target band.
04
Failure handlingHandle GPU node failure without losing in-flight work.
05
Cost accountingAccount fully-loaded cost per million tokens including idle time.
Assessment 04 — Sovereignty, operations & scale
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 — Self-hosted agent with proven economics
Serve an open-weight model with vLLM, build an agent on it, benchmark against a managed baseline and present a defensible fully-loaded cost per million tokens.
Capstone B — Sovereign, air-gapped deployment
Build a fully air-gapped retrieval agent with self-hosted embeddings, reranking and generation, with a licence and provenance register for every artefact.
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 01 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 01 · Open-weight foundations and economics
The honest crossover
Decide whether self-hosting is justified, and be willing to conclude that it is not.
The brief
You are given a real workload trace. Build the fully-loaded cost model for self-hosting against a managed API baseline, including idle capacity, retries and failed runs. Two of the four scenarios should come out against self-hosting.
Provisioned for you
- 90-day workload trace with bursts
- GPU pricing and load-time measurements
- Managed API price list
- Benchmark harness on 4 open-weight models
You start from this
def crossover(trace, gpu, api_price, utilisation_target=0.65):
"""Fully loaded. Idle GPU time is the line item that decides this,
and the one most often left out."""
raise NotImplementedErrorWhat the grader asserts
- Idle capacity cost is included, not just active inference
- Retries and failed runs counted in token volume
- Burst handling modelled, not averaged away
- Two of four scenarios correctly recommend the managed API
- Quality parity is evidenced per task before any cost claim is made
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 | Open-weight foundations & economicsModel families and licencesModel right-sizingCrossover analysisUnit economics | 30 | 45 min | 4 |
| 02 | Serving & throughputServing frameworksBatching and decodingQuantisation trade-offsLoad testing | 30 | 45 min | 4 |
| 03 | Retrieval, tuning & evaluationSelf-hosted retrievalFine-tuning methodsRegression detectionBenchmarking | 30 | 45 min | 4 |
| 04 | Sovereignty, operations & scaleAir-gapped and sovereign deploymentLicence complianceGPU operationsCost accounting | 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 wants to self-host because "it will be cheaper". What do you check first?
Below roughly 256M tokens a month at 60-70% utilisation, a managed API is usually cheaper and far less work.
Q2How should quantisation be evaluated?
General benchmarks routinely mislead here. The only meaningful measurement is on the workload you are deploying.
Q3When is fine-tuning the right answer?
Most fine-tuning projects were retrieval problems. Exhausting the cheaper options first is the discipline.
Q4What makes an air-gapped deployment genuinely air-gapped?
A single package or weight download at startup breaks the guarantee. Vendoring everything is the requirement.
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 |
|---|---|---|---|
| Self-hosting judgement | Can deploy a model. | Builds an honest crossover analysis. | Advises against self-hosting when it is wrong. |
| Inference engineering | Runs a model server. | Tunes batching and quantisation for throughput. | Designs GPU capacity for a target unit cost. |
| Model adaptation | Writes prompts. | Runs LoRA fine-tunes with held-out validation. | Decides when fine-tuning is the wrong answer. |
| 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
- Open-weight
- A model whose weights are published, which is not the same as open-source training data.
- vLLM
- A high-throughput inference server using continuous batching and paged attention.
- Continuous batching
- Adding new requests to an in-flight batch, greatly increasing throughput.
- Speculative decoding
- Using a small draft model to propose tokens a larger model verifies.
- Quantisation
- Reducing weight precision to cut memory and increase throughput, at some quality cost.
- LoRA / QLoRA
- Parameter-efficient fine-tuning that adapts a model without retraining all weights.
- Crossover
- The volume at which self-hosting becomes cheaper than a managed API.
- SLM
- Small Language Model — sufficient for most classification, extraction and routing work.
- 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
- Access to at least one GPU for the serving labs, cloud or local
- Linux comfort: containers, drivers, and diagnosing why a process died
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 self-hosted open-weight models and agents
- 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 — Open Source & Open-Weight LLMs / SLMs.
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
Open Source & Open-Weight LLMs / SLMs
- Specialisation
- Open Source & Open-Weight LLMs / SLMs
- 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-OPEN-WEIGHT--<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.