SCIKIQ Certified Data and AI Engineer - Anthropic + AWS Tech Stack

01

Part 1 · The business

The value chain, the people, the trends

Part 1 is the delivery lifecycle, and what each stage looks like specifically on Claude and AWS.

The agent delivery lifecycle on AWS

Six stages. Select one to see what it means on this stack.

Who you work with on this stack

AWS engagements live or die on the IAM conversation. Select one to light the stages they own.

What is changing on this stack

The 2026 read on Claude and AWS.

AWS7 managed services

AgentCore standardised agent operations

Generally available since April 2026, AgentCore provides runtime, memory, identity, gateway, code interpreter, browser and observability as managed services.

AWS8-hour runs

Long-running agents became practical

Agents can run autonomously for up to eight hours with automatic scaling, which changes what kinds of workflow are worth automating.

AnthropicNative API on AWS

Claude Platform on AWS closed the gap

The native Claude API — Managed Agents, skills, code execution, web search and fetch, batch and Console — became available billed through AWS in May 2026.

AWSAgentCore for net-new

Classic agents entered maintenance

Bedrock Agents Classic went into maintenance for new customers after July 2026, with net-new builds directed to AgentCore.

IndustryInfrastructure as code

Deployment moved to CDK pipelines

The AgentCore CLI and CDK-based deployment made agent delivery a normal software pipeline rather than a console exercise.

AnthropicSkills over prompts

Skills made procedure reusable

Packaging repeatable procedure as skills rather than prompt text is what keeps long-running agents consistent across runs.

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.

IndustryAWS Weekly Roundup: Amazon Bedrock AgentCore CLI (April 2026)AgentCore GA, CDK deployment pipeline
IndustryClaude by Anthropic — models in Amazon BedrockClaude tiers and managed agent services on AWS

02

Part 2 · Data and meaning

The platform building blocks

Part 2 is the AWS stack in concrete terms, and where the platform gives you something you would otherwise have had to build.

The platform landscape

Six building blocks you will use on almost every engagement.

Models

Claude model tiers through Bedrock or the native Claude API on AWS.

Claude via Bedrock, Claude Platform on AWS

Agent runtime

Managed execution, memory and identity for long-running agents.

Bedrock AgentCore Runtime / Memory / Identity

Tools & gateway

MCP tools, managed gateway, code interpreter and browser tooling.

AgentCore Gateway, Code Interpreter, Browser

Retrieval

Knowledge bases and vector stores with reranking.

Bedrock Knowledge Bases, OpenSearch, pgvector

Security

IAM, agent identity, guardrails and private networking.

IAM, AgentCore Identity, Bedrock Guardrails, PrivateLink

Operations

Deployment pipeline, tracing, metrics and cost telemetry.

AgentCore CLI/CDK, Observability, CloudWatch

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.

What you will actually use

Models

Claude tiers via Bedrock
Claude Platform on AWS native API
Prompt caching and batch

Agents

AgentCore Runtime and Memory
Managed Agents and skills
MCP tools via Gateway

Grounding

Bedrock Knowledge Bases
OpenSearch / pgvector
Reranking

Tools

Code Interpreter
Browser tool
Custom MCP servers

Security

IAM least privilege
AgentCore Identity
Bedrock Guardrails
PrivateLink

Operations

AgentCore CLI and CDK
AgentCore Observability
CloudWatch + OTel

Constraints that shape the design

Long runs need hard bounds

An eight-hour autonomous run without budget, loop and blast-radius limits is an incident generator. Bound it in code.

IAM is the security conversation

Agent permissions resolve to IAM. Scope roles per tool, not per agent, and expect the review to be thorough.

Code and browser tools are the risk

These are the highest-value and highest-risk tools. Sandboxing and egress control are mandatory, not optional.

Memory needs a scope and a lifetime

Unbounded agent memory grows cost and leaks context across sessions. Decide scope, retention and eviction up front.

04

Part 3 · Getting it done

Where the business and the technology meet

Part 3 is the set of patterns you will build repeatedly on this stack, then the modules, labs and capstones that prove you can run them in production.

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

The delivery playbook

How an AWS engagement actually runs.

01

Day 1 — choose the access path

Bedrock, Claude Platform on AWS, or both. Decide on workload characteristics, not preference, and confirm region availability.

02

Week 1 — grounding and citations

Build retrieval with resolvable citations and measure recall before any agent logic exists.

03

Week 2-3 — agent with hard bounds

Build on AgentCore with budget, loop and blast-radius limits from the first commit, not later.

04

Week 4-5 — IAM and trajectory evals

Take least-privilege scoping to security early, and build trajectory-level evaluation while the agent is still simple.

05

Week 6 — pipeline and handover

Move to CDK deployment, measure cost per completed task and hand over runbook, evals and rollback.

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.

01Claude and AWS foundationsAccess paths, model tiering, context strategy and the cost levers that matter.15 hrs · 5 labs

Bedrock vs Claude Platform on AWSModel tieringLong contextPrompt cachingStructured outputsCost per task

01

First agentDeploy a Claude agent through Bedrock with a scoped IAM role.

02

Tiering studyCompare tiers on a real task and choose on cost per task.

03

Prompt cachingCut cost with caching and measure the actual saving.

04

Structured outputsEnforce schema-valid outputs and handle failure paths.

05

Cost baselineEstablish cost per completed task including failures.

Assessment 01 — Platform foundations30 items · 45 min · pass 70%

02Grounding and retrieval on AWSKnowledge bases, vector stores, reranking and citations that hold up.15 hrs · 5 labs

Knowledge BasesOpenSearch and pgvectorChunkingRerankingCitation contractsRetrieval evaluation

01

Knowledge baseBuild a knowledge base and measure recall on a labelled set.

02

Custom retrievalBuild a custom retrieval path and compare it honestly.

03

RerankingAdd reranking and quantify the precision gain.

04

Citation resolutionGuarantee every citation resolves to a source passage.

05

Retrieval evalsGate builds on recall@k and citation correctness.

Assessment 02 — Retrieval & grounding30 items · 45 min · pass 70%

03AgentCore: runtime, memory, tools and identityLong-running agents built on managed services rather than bespoke infrastructure.15 hrs · 5 labs

AgentCore RuntimeMemory scopingGateway and MCPSkillsCode Interpreter and BrowserContainment

01

AgentCore runtimeRun a long-horizon agent with checkpointing and recovery.

02

Memory scopingScope memory with retention and eviction, and prove no cross-session leak.

03

MCP via GatewayExpose an enterprise system as a managed MCP tool.

04

Sandboxed codeEnable code execution with egress and resource containment.

05

ContainmentAdd budget, loop and blast-radius limits and test them under abuse.

Assessment 03 — AgentCore, tools & memory30 items · 45 min · pass 70%

04Evaluation, security and productionTrajectory evaluation, IAM, guardrails, deployment and the cost model.15 hrs · 5 labs

Trajectory evaluationRegression gatingIAM least privilegeGuardrailsCDK deploymentObservability and cost

01

Trajectory evalsEvaluate whole runs, not just final answers, and baseline them.

02

Regression gateBlock deployment on a task-success regression.

03

IAM scopingScope permissions per tool and prove the agent cannot exceed them.

04

GuardrailsAdd input and output guardrails and defeat an injection attempt.

05

Deploy and traceDeploy via CDK, trace a full run and halve cost per completed task.

Assessment 04 — Evaluation, security & operations35 items · 50 min · pass 70%

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 — Long-running workflow agent

Build an agent on AgentCore that completes a multi-hour workflow with scoped memory, checkpointed recovery, hard bounds and trajectory-level evaluation.

Capstone B — Tool-heavy analysis agent

Build an agent using sandboxed code execution and MCP tools over enterprise data, with least-privilege IAM, guardrails and a measured cost per completed 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 03 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 03 · AgentCore: runtime, memory, tools and identity

Long-run containment

Bound an eight-hour agent so failure is recoverable and cost is predictable.

The brief

Build an AgentCore agent for a multi-hour task, then break it deliberately: kill it mid-run, exhaust a tool, and feed it a loop-inducing input. It must recover, terminate and stay inside budget.

Provisioned for you

AgentCore runtime and memory
Fault injector for tool and node failure
Cost meter per run
Loop-inducing input set

You start from this

LIMITS = dict(max_tokens=..., max_tool_calls=..., max_wall_clock=..., blast_radius=...)

def run(task, checkpoint_store):
    """Checkpoint often enough that a kill at hour four costs minutes."""
    raise NotImplementedError

What the grader asserts

A kill at any point resumes without repeating completed side effects
Loop-inducing inputs terminate at the configured limit, every time
Cost per completed task stays within 15% of the projection
Every step is traceable after the fact from spans alone
Memory does not grow unbounded across the run

Pass barAll fault injections recovered, all loops terminated, cost within projection.

StretchAdd trajectory-level evaluation scoring tool choice, not just the final answer.

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 foundationsAccess pathsModel tieringContext and cachingCost per task	30	45 min	4
02	Retrieval & groundingKnowledge basesVector stores and rerankingCitationsRetrieval metrics	30	45 min	4
03	AgentCore, tools & memoryRuntime and long runsMemory scopingMCP and toolsContainment	30	45 min	4
04	Evaluation, security & operationsTrajectory evaluationIAM and guardrailsDeployment pipelineObservability 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.

Q1Why measure cost per completed task rather than per token?

Excluding failures flatters every comparison. The completed unit of work is what compares to the process being replaced.

Q2When would you build custom retrieval rather than using a managed knowledge base?

Custom retrieval is a maintenance commitment. It should be justified by a measured gap, not assumed superiority.

Q3An agent may run autonomously for up to eight hours. What must exist?

Long runs multiply the consequences of any error. Containment and recovery are prerequisites, not enhancements.

Q4Why is trajectory-level evaluation necessary for long-running agents?

Single-turn evaluation of a multi-hour agent measures the wrong thing. The trajectory is the behaviour.

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
AWS platform	Calls Bedrock.	Builds on AgentCore managed services.	Designs an agent estate with IAM and cost discipline.
Long-horizon agents	Runs a single-turn agent.	Builds multi-step agents with memory.	Designs hour-long runs with recovery and bounds.
Agent containment	Adds output filters.	Scopes IAM and sandboxes tools.	Threat-models a tool estate and proves containment.
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

AgentCore: Amazon Bedrock’s managed services for running agents in production.

Gateway: The AgentCore service that exposes tools, including MCP servers, to agents.

Skills: Packaged, reusable procedure a Claude agent can invoke, instead of prompt text.

Trajectory evaluation: Evaluating the whole sequence of an agent run, not only its final output.

Prompt caching: Reusing stable context across calls to reduce cost and latency.

Blast radius: The maximum damage an agent action can cause before a control stops it.

PrivateLink: Private network connectivity to AWS services without public internet transit.

Checkpointing: Persisting agent state so a long run can resume after failure.

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.

Talk to us

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 AWS account you can deploy into, or your employer’s sandbox
Basic IAM literacy — roles and policies, not mastery

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 Claude-based agents on AWS
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 — Anthropic + AWS 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

Anthropic + AWS Tech Stack

Specialisation: Anthropic + AWS 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-ANTHROPIC-AW-<issued>

Senior SCDAI Engineer, Certification Board

01
The 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.
02
The 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.
03
Anyone can verify it, without a login
The credential ID resolves to a public record showing the specialisation, the award date and the assessments passed.

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.

Talk to us

SCIKIQ Certified Data and AI EngineerAnthropic + AWS Tech Stack

The value chain, the people, the trends

The agent delivery lifecycle on AWS

Scope & land

Decisions made here

Where it breaks today

What is measured

Ground & retrieve

Decisions made here

Where it breaks today

What is measured

Build & orchestrate

Decisions made here

Where it breaks today

What is measured

Evaluate & prove

Decisions made here

Where it breaks today

What is measured

Secure & govern

Decisions made here

Where it breaks today

What is measured

Deploy & operate

Decisions made here

Where it breaks today

What is measured

Who you work with on this stack

What is changing on this stack

AgentCore standardised agent operations

Long-running agents became practical

Claude Platform on AWS closed the gap

Classic agents entered maintenance

Deployment moved to CDK pipelines

Skills made procedure reusable

The platform building blocks

The platform landscape

Models

Agent runtime

Tools & gateway

Retrieval

Security

Operations

How it is actually built

The reference architecture

Data & knowledge

Retrieval

Models & context

Agents, tools & memory

Security & guardrails

Evaluation & operations

What you will actually use

Models

Agents

Grounding

Tools

Security

Operations

Constraints that shape the design

Long runs need hard bounds

IAM is the security conversation

Code and browser tools are the risk

Memory needs a scope and a lifetime

Where the business and the technology meet

Patterns, mapped to the lifecycle and the architecture

Long-running workflow agent

MCP tool estate via Gateway

Skills for repeatable procedure

Sandboxed code execution

Knowledge base grounding with citations

Prompt caching for cost

Trajectory-level evaluation

Guardrails on input and output

Least-privilege agent identity

CDK deployment pipeline

Observability for multi-hour runs

Cost per completed task

The delivery playbook

Day 1 — choose the access path

Week 1 — grounding and citations