Google4 languages, model-agnostic
ADK made agent building code-first and portable
ADK is open-source, model-agnostic and deployment-independent, with support for Python, Go, Java and TypeScript.
Program 20 · Tech stack specialisation
SCIKIQ Certified Data and AI EngineerGoogle (GCP, Gemini & Gemma, ADK)
Google’s stack is the most code-first of the three hyperscalers: ADK is an open-source, model-agnostic framework, Agent Engine is the managed runtime beneath it, and the data gravity of BigQuery is usually why the customer chose it. Play to that — grounding on governed data is where this stack wins.
- 60 hrstaught
- 20hands-on AI labs
- 4assessment tests
- +20 hrs2 E2E capstones
4Languages ADK supports: Python, Go, Java and TypeScriptGoogle
200+Foundation models in Model Garden including Gemini, Gemma, Claude and LlamaGoogle
Sub-secondAgent Engine cold starts with autoscaling and managed sessionsGoogle
A2AAgent2Agent donated to the Linux Foundation with broad industry backingLinux Foundation
01
Part 1 · The business
The value chain, the people, the trends
Part 1 is the delivery lifecycle and what each stage means on Google Cloud.
The agent delivery lifecycle on Google Cloud
Six stages. Select one to see what it means on this stack.
01
Scope & land
Choose the workflow, the model family and whether the work belongs in ADK code or Agent Studio.
Decisions made here
- Gemini or Gemma?
- Code-first or low-code?
- Which region?
Where it breaks today
- Choosing a frontier model where a small one would do
- Low-code prototypes that cannot be productionised
- Region and quota surprises
What is measured
- Time to first slice
- Cost per task
Where AI landsModel Garden for selection, ADK for code-first builds, Agent Studio for rapid low-code shaping.
Time to first sliceCost per task
02
Ground & retrieve
Ground agents on BigQuery, Vertex AI Search and enterprise content.
Decisions made here
- Structured or unstructured grounding?
- How do we govern the query path?
- What resolves a citation?
Where it breaks today
- Free-text SQL generation against ungoverned tables
- Grounding evaluated by eye
- No permission model on retrieval
What is measured
- Recall@k
- Query correctness
Where AI landsVertex AI Search for unstructured, BigQuery for governed structured grounding, with metric-layer discipline.
Recall@kQuery correctness
03
Build & orchestrate
Build agents in ADK, compose multi-agent systems and expose tools via MCP.
Decisions made here
- Which agent topology?
- Which tools?
- Where do humans approve?
Where it breaks today
- Multi-agent complexity adopted before it is needed
- Tools without schemas
- State handled implicitly
What is measured
- Task success
- Tool-choice accuracy
Where AI landsADK multi-agent primitives, MCP tools, A2A for cross-vendor delegation, Agent Garden templates.
Task successTool-choice accuracy
04
Evaluate & prove
Build eval sets, baseline them and gate releases in a normal CI pipeline.
Decisions made here
- What is good?
- What gates release?
- How do we catch regression?
Where it breaks today
- Evaluation deferred until after launch
- No baseline
- Judge drift
What is measured
- Groundedness
- Task success
- Regression rate
Where AI landsVertex AI evaluation services plus ADK’s local evaluation and debugging tooling.
GroundednessTask successRegression rate
05
Secure & govern
IAM, VPC Service Controls, safety settings and data governance across the agent estate.
Decisions made here
- What service account?
- What can it reach?
- What is the data boundary?
Where it breaks today
- Broad service accounts
- No perimeter around sensitive data
- Ungoverned SQL generation
What is measured
- Least-privilege coverage
- Policy violations
Where AI landsIAM conditions, VPC Service Controls perimeters, Gemini safety settings and BigQuery governance.
Least-privilege coveragePolicy violations
06
Deploy & operate
Deploy to Agent Engine or GKE, trace, monitor cost and hand over.
Decisions made here
- Agent Engine or GKE?
- What do we trace?
- What is the cost model?
Where it breaks today
- Self-managing infrastructure Agent Engine provides
- No tracing across a multi-agent call chain
- Cost discovered late
What is measured
- Cost per task
- Latency p95
- Availability
Where AI landsAgent Engine managed runtime, GKE for custom needs, Cloud Trace and OTel GenAI conventions.
Cost per taskLatency p95Availability
Who you work with on this stack
On Google engagements, the data team is usually the most important relationship. Select one to light the stages they own.
What is changing on this stack
The 2026 read on Google’s agent platform.
GoogleManaged runtime
Agent Engine removed the runtime problem
Managed autoscaling, sub-second cold starts, session management and long-running execution mean teams stop building runtime infrastructure.
Google200+ models
Model Garden made the model a choice, not a commitment
200+ models including Gemini, Gemma, Claude and Llama, with LiteLLM integration for the rest.
Linux FoundationVendor-neutral
A2A became neutral infrastructure
Agent2Agent was donated to the Linux Foundation with broad industry backing, making cross-vendor agent delegation a standards question rather than a vendor one.
GoogleOpen weights in-stack
Small models moved to the edge of the stack
Gemma gives a genuine open-weight option inside the same tooling, which changes the cost profile of high-volume, narrow tasks.
IndustryBigQuery gravity
Data gravity is the reason customers are here
Most Google agent deployments exist because the enterprise data already lives in BigQuery. Grounding quality on governed structured data is the differentiator.
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.
- IndustryAgent Development Kit — Gemini Enterprise Agent PlatformADK as an open-source, model-agnostic framework
- IndustryAgent Development Kit: making it easy to build multi-agent applicationsMulti-agent primitives; Agent Engine managed runtime
02
Part 2 · Data and meaning
The platform building blocks
Part 2 is the Google stack in concrete terms — and the governed-query discipline that separates a demo from a deployment here.
The platform landscape
Six building blocks you will use on almost every engagement.
Models
Gemini for frontier reasoning, Gemma for open-weight and edge, plus partner models.
Gemini, Gemma, Model GardenAgent framework
Code-first agent development with multi-agent primitives.
ADK (Python, Go, Java, TypeScript)Agent runtime
Managed deployment, scaling, sessions and memory.
Vertex AI Agent Engine, GKEGrounding
Unstructured search plus governed structured querying.
Vertex AI Search, BigQuerySecurity
IAM conditions, perimeters and safety configuration.
IAM, VPC Service Controls, safety settingsOperations
Evaluation, tracing, monitoring and cost management.
Vertex AI evaluation, Cloud Trace, Cloud Monitoring
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 & knowledge
BigQuery as the governed analytical estate plus unstructured enterprise content.
Takes in
Enterprise data and documents in place, with their existing governance.
Hands on
A governed, classified corpus with column and row policies retrieval must respect.
SystemWhat it doesKey business entities
BigQuery
The analytical estate, with column-level policy tags and row-access policies enforced in the engine rather than in your query.
TablePolicy tagRow access policy
Cloud Storage and Document AI
The document corpus, and layout-aware parsing that preserves the structure a citation later depends on.
DocumentPageEntity
Dataplex
Catalogue, lineage, quality and the data-governance surface across the estate.
AssetLineageQuality rule
Sensitive Data Protection
Discovery, classification and de-identification of sensitive fields before they are indexed or embedded.
InfoTypeFindingTransformation
What the engineer owns here
Working through governed tables and metrics rather than raw table access.
Where this layer fails
Embedding a column you were not permitted to read. Policy tags govern the query and not the vector, so de-identification has to happen before the embedding, not after.
02/06
Retrieval & querying
Vertex AI Search for documents, governed SQL for structured questions.
Takes in
A governed, classified corpus from the data layer.
Hands on
Grounded, attributed results whose access checks were enforced by the engine.
SystemWhat it doesKey business entities
Vertex AI Search
Managed retrieval over the corpus with grounding and source attribution.
Data storeDocumentSnippet
Vector Search
Low-latency approximate nearest neighbour at scale for the custom path.
IndexEmbeddingNamespace
Grounding with Google Search
A public-web grounding source for questions the enterprise corpus genuinely cannot answer, kept explicitly separate from it.
Grounding sourceCitation
Governed SQL retrieval
Text-to-SQL against BigQuery through the semantic layer, with policy tags doing the trimming.
QueryMetricPolicy tag
What the engineer owns here
Preventing free-text SQL from becoming the architecture by accident.
Where this layer fails
Mixing enterprise and web grounding in one answer without saying which sentence came from where. It is the fastest way to lose a reader’s trust permanently.
03/06
Models & context
Model selection across Gemini and Gemma, context caching and structured outputs.
Takes in
Grounded, attributed results from retrieval.
Hands on
Schema-conformant output from the tier that meets the task’s quality bar.
SystemWhat it doesKey business entities
Gemini on Vertex AI
The frontier tier, with long context and native multimodal input.
ModelContext windowModality
Gemma
Open-weight models for the workloads that must run in your own boundary or at your own unit cost.
CheckpointServing config
Context caching
Explicit caching of a large stable context, priced accordingly.
Cached contentTTLHit rate
Controlled generation
Response schemas enforced by the API so downstream code parses a contract.
Response schemaEnumContract
What the engineer owns here
Using small models where they are sufficient, measured rather than assumed.
Where this layer fails
Filling a long context because it is available. Recall degrades in the middle of a very long prompt, and retrieval quality beats context length nearly every time.
04/06
Agents & tools
ADK agents, multi-agent composition, MCP tools and A2A delegation.
Takes in
Schema-conformant model output and its permitted tool surface.
Hands on
Executed or proposed actions with session state and a trace.
SystemWhat it doesKey business entities
Agent Development Kit (ADK)
The framework for building, composing and testing agents as code.
AgentToolSession
Agent Engine
Managed runtime and scaling for deployed agents, with state and tracing.
DeploymentSessionTrace
A2A and MCP
Agent-to-agent delegation and typed tool servers, each with a declared scope.
DelegationToolSchema
Workflow integration
Write-back into the operational systems, under a service identity with its own trail.
Work itemActorAudit entry
What the engineer owns here
Keeping topology as simple as the problem allows.
Where this layer fails
Multi-agent designs adopted before a single agent has been measured. Each hop adds latency, cost and a new place for the task to be misunderstood.
05/06
Security & governance
Service account scoping, VPC Service Controls, safety settings and data governance.
Takes in
Proposed actions and drafted responses from the agent layer.
Hands on
Permitted, perimeter-contained, logged output attributable to a principal.
SystemWhat it doesKey business entities
IAM and VPC Service Controls
Least-privilege identity plus a service perimeter that stops data leaving it, however the request is shaped.
RolePerimeterPrincipal
Model Armor / safety filters
Prompt-injection and content screening on both directions of the exchange.
FilterCategoryVerdict
Responsible AI controls
Safety settings, citation checking and the model-governance record for each deployment.
SettingCitation checkRecord
Cloud Audit Logs
Admin and data-access logging across model, retrieval and tool calls.
Log entryPrincipalResource
What the engineer owns here
Keeping the agent and its data inside a defensible perimeter.
Where this layer fails
A perimeter around the data and not around the model endpoint. Exfiltration follows the path you left open, and inference is a path.
06/06
Evaluation & operations
Evaluation in CI, Agent Engine deployment, tracing and cost control.
Takes in
Permitted, logged output from the governance layer.
Hands on
Measured quality, latency and cost, and a gate that can block a release.
SystemWhat it doesKey business entities
Vertex AI evaluation
Automatic and model-based grading against held-out sets, wired into CI.
Eval taskMetricBaseline
Cloud Trace and OTel
End-to-end spans across retrieval, inference and tools.
TraceSpanLatency
Cloud Monitoring
Quality, latency and error dashboards with alerting on user-visible thresholds.
MetricAlertSLO
Cost and quota management
Cost per task against quota and provisioned throughput.
Cost per taskQuotaUtilisation
What the engineer owns here
Regression gating and cost per task on a platform that scales easily.
Where this layer fails
Model-based grading with no human-labelled anchor. The judge drifts with the model, and your quality metric drifts with it.
What you will actually use
Models
- Gemini frontier tiers
- Gemma open-weight models
- Model Garden partner models
Agents
- ADK
- Agent Engine managed runtime
- Agent Garden templates
- MCP and A2A
Grounding
- Vertex AI Search
- BigQuery governed queries
- Reranking
Data
- BigQuery
- Dataplex governance
- Cloud Storage corpora
Security
- IAM conditions
- VPC Service Controls
- Gemini safety settings
Operations
- Vertex AI evaluation
- Cloud Trace and Monitoring
- GKE where needed
Constraints that shape the design
Govern the query path
An agent generating free-text SQL against raw tables will eventually produce two different answers to the same question. Query through governed metrics.
Perimeter before deployment
VPC Service Controls perimeters are how enterprises prevent exfiltration here. Design inside them from the start.
Right-size the model
Gemma or a small Gemini tier is often sufficient for narrow, high-volume tasks. Measure before defaulting to frontier.
Topology discipline
ADK makes multi-agent easy, which makes premature multi-agent common. Start with one agent and split only when evidence demands it.
04
Part 3 · Getting it done
Where the business and the technology meet
Part 3 is the patterns you will build repeatedly on Google Cloud, then the modules, labs and capstones that prove you can run them.
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 Google Cloud engagement actually runs.
01
Day 1 — project, perimeter, service account
Land inside the perimeter with a scoped service account. Retrofitting a perimeter is painful.
02
Week 1 — governed grounding first
Agree the query path with the data team. Free-text SQL against raw tables is the mistake that ends these engagements.
03
Week 2-3 — one agent, in code
Build a single ADK agent with tests and evals. Resist multi-agent until the evidence demands it.
04
Week 4-5 — right-size and secure
Test whether Gemma or a smaller tier holds quality, and take IAM conditions and perimeter design to security.
05
Week 6 — Agent Engine and handover
Deploy to Agent Engine, wire tracing and cost telemetry, hand over runbook and eval suite.
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.
01Google Cloud AI foundationsModels, ADK, Agent Engine and the cost decisions that shape everything else.15 hrs · 5 labs
Model Garden and selectionGemini vs GemmaADK fundamentalsAgent EngineContext cachingCost per task
01
First ADK agentBuild and run an ADK agent locally with tools and tests.
02
Model comparisonCompare Gemini tiers and Gemma on one real task.
03
Context cachingCut cost with context caching and measure the saving.
04
Agent Engine deployDeploy the agent to the managed runtime with sessions.
05
Cost baselineEstablish cost per task and a target to beat.
Assessment 01 — Platform foundations
02Grounding on BigQuery and Vertex AI SearchThe governed-query discipline plus unstructured retrieval done properly.15 hrs · 5 labs
Vertex AI SearchBigQuery groundingGoverned query toolsChunking and rerankingCitationsRetrieval evaluation
01
Unstructured groundingBuild Vertex AI Search grounding and measure recall.
02
Governed query toolExpose validated, parameterised queries instead of free-text SQL.
03
Query safetyPrevent an agent from issuing an unbounded or unsafe query.
04
Citation contractGuarantee citations resolve to a source passage or row set.
05
Retrieval evalsGate builds on recall and query correctness.
Assessment 02 — Grounding & governed querying
03ADK agents, tools and multi-agent systemsCode-first agent composition, MCP tools and A2A delegation.15 hrs · 5 labs
ADK agent patternsTool designMulti-agent primitivesMCP integrationA2A delegationContainment
01
Tool designBuild typed tools with validation and clear failure semantics.
02
Multi-agentCompose a coordinator with specialised sub-agents and test it.
03
MCP integrationConsume an external MCP server from an ADK agent.
04
A2A delegationDelegate a task to another agent over A2A and handle failure.
05
ContainmentAdd budget and loop limits and prove they hold.
Assessment 03 — Agents, tools & multi-agent
04Evaluation, security and productionEvals in CI, perimeters, IAM conditions and running it at a defensible cost.15 hrs · 5 labs
Eval sets and baselinesRegression gatingIAM conditionsVPC Service ControlsTracingCost management
01
Eval harnessBuild an eval set with a baseline and wire it into CI.
02
Regression gateBlock deployment on a groundedness regression.
03
IAM conditionsScope a service account per dataset and tool, and test the boundary.
04
PerimeterDeploy inside a VPC Service Controls perimeter and prove containment.
05
Trace and costTrace a multi-agent chain and halve cost per task.
Assessment 04 — Evaluation, security & 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 — Governed analytics agent
Build an ADK agent that answers analytical questions through governed BigQuery queries with citations, deployed on Agent Engine inside a perimeter, with an eval baseline.
Capstone B — Multi-agent workflow with A2A
Build a coordinator and specialised sub-agents, delegate one task over A2A, and gate the whole system on CI-enforced evals with full tracing and a measured cost per task.
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 on BigQuery and Vertex AI Search
Governed query tools
Stop free-text SQL becoming the architecture by accident.
The brief
Expose BigQuery to an ADK agent through validated, parameterised query tools built on governed metrics. Then attempt to make it issue an unbounded or ungoverned query.
Provisioned for you
- BigQuery with governed metric views
- ADK agent scaffold
- 40 analytical questions, 12 adversarial
You start from this
@tool
def revenue_by(dimension: str, period: str, filters: dict) -> QueryResult:
"""Parameterised and validated. The agent chooses arguments,
never SQL text."""
raise NotImplementedErrorWhat the grader asserts
- No path allows the agent to submit arbitrary SQL text
- Scan and cost limits are enforced outside the agent
- The same question asked twice returns the same number
- Citations resolve to the query and the row set that produced the answer
- Adversarial prompts fail without leaking schema detail
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 foundationsModel selectionADK fundamentalsAgent EngineCost per task | 30 | 45 min | 4 |
| 02 | Grounding & governed queryingVertex AI SearchBigQuery groundingQuery governanceRetrieval metrics | 30 | 45 min | 4 |
| 03 | Agents, tools & multi-agentADK patternsTool designMulti-agent and A2AContainment | 30 | 45 min | 4 |
| 04 | Evaluation, security & operationsEval design and gatingIAM and perimetersTracingCost management | 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.
Q1When should you use Agent Studio rather than ADK?
Low-code prototypes that cannot be productionised are a common trap. Use them deliberately, for shaping.
Q2An agent generates free-text SQL against raw BigQuery tables. What is the problem?
Consistency is the issue. Governed, parameterised query tools are what keep the answer stable and the data team supportive.
Q3ADK makes multi-agent composition easy. What is the associated risk?
Ease of use invites unnecessary complexity. Start with one agent and split when evidence demands it.
Q4What is a VPC Service Controls perimeter for?
It is an exfiltration control, complementary to IAM. Together they answer the security question that blocks data-adjacent agents.
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 |
|---|---|---|---|
| Google Cloud platform | Calls Gemini. | Builds ADK agents on Agent Engine. | Designs an agent estate with perimeters and cost control. |
| Governed grounding | Generates SQL. | Uses validated, parameterised query tools. | Designs a governed query path the data team trusts. |
| Model right-sizing | Uses the frontier model. | Tests smaller models on the task. | Designs tiering that holds quality at a fraction of cost. |
| 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
- ADK
- Agent Development Kit — Google’s open-source, code-first agent framework.
- Agent Engine
- The managed Vertex AI runtime for deploying and scaling agents.
- Model Garden
- The catalogue of foundation models available on Vertex AI.
- Gemma
- Google’s family of open-weight models, usable in the same tooling as Gemini.
- A2A
- Agent2Agent — the vendor-neutral protocol for agent-to-agent delegation.
- VPC Service Controls
- A perimeter that prevents data exfiltration from Google Cloud services.
- IAM conditions
- Attribute-based constraints that narrow what a permission actually grants.
- Context caching
- Reusing large stable context across requests to cut cost and latency.
- 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
- A Google Cloud project you can deploy into, or your employer’s sandbox
- Some SQL, since governed querying on BigQuery is central here
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 Google Cloud
- 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 — Google (GCP, Gemini & Gemma, ADK).
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
Google (GCP, Gemini & Gemma, ADK)
- Specialisation
- Google (GCP, Gemini & Gemma, ADK)
- 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-GOOGLE-CLOUD-<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.