AI curriculum

Course outline for AWS Engineering for AI Applications

Make authorized model requests on Amazon Bedrock and read actual source objects from Amazon S3. Connect a small local retrieval step to the model response. Inspect identity and network paths, handle errors with bounded retries, and remove lab resources. Compare managed model access with SageMaker AI and Knowledge Bases without claiming to deploy those additional services.

AWS Engineering for AI Applications Course Objectives

  • Configure Boto3 sessions and execute an actual authorized Bedrock model exchange.
  • Explain separate identity, policy, endpoint, and network responsibilities.
  • Upload, read, retrieve, and delete synthetic S3 source objects.
  • Compare Bedrock, SageMaker AI, and Knowledge Bases by workload and ownership.
  • Diagnose live access/connectivity failures separately from locally injected errors.
  • Record request, latency, usage, retries, cost assumptions, and cleanup evidence.

Pre-requisites

  • Cloud Foundations for AI Engineers or equivalent compute, storage, identity, networking, cost, and recovery concepts.
  • Python, JSON, dependency environments, and a basic SDK/model request.
  • An authorized training AWS account and approved spending allowance are mandatory.
  • Region, chosen model access, short-lived identity, quotas, and S3 access pass preflight.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Readiness checks

  • Cloud Foundations for AI Engineers or equivalent compute, storage, identity, networking, cost, and recovery concepts.
  • Python, JSON, dependency environments, and a basic SDK/model request.
  • An authorized training AWS account and approved spending allowance are mandatory.
  • Region, chosen model access, short-lived identity, quotas, and S3 access pass preflight.

Cloud Foundations for AI Engineers or equivalent compute, storage, identity, networking, cost, and recovery concepts.

Find your place in the learning map

Lab Setup

Delivery requirements: the environment, access, and exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

Authorized nonproduction AWS account, least-privilege short-lived role, supported region/model access, owned S3 prefix, Python/Boto3, synthetic sources, bounded request starters, failure hooks, and cleanup inventory. Approved spending allowance, quotas, pricing and retention terms, SDK compatibility, real allowed/denied requests, and resource removal require verification. Missing access blocks delivery; emulator-only evidence cannot substitute.

Detailed Course Outline

Module 1: Establish a bounded AWS execution path (2 hours)

  • AWS execution identities: AWS account, region, service endpoint, and resource identity basics.
  • Boto3 sessions: Boto3 session/client creation and short-lived credential resolution.
  • IAM action and resource scope: IAM principal, role, action, resource, and explicit policy scope.
  • Model and data permissions: Separate Bedrock model access and S3 data permissions.
  • Endpoint connectivity: DNS/TLS/HTTPS path, local egress, and public endpoint boundaries.
  • Approved limits and stop conditions: Approved model, request limits, spending allowance, and stop conditions.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Verify the active training identity, region, endpoint reachability, and allowed resource scope without printing credentials.

Module 2: Complete and inspect a Bedrock exchange (2 hours)

  • Bedrock Converse foundations: Bedrock runtime client, supported model identity, and Converse basics.
  • Messages and inference settings: Message roles, content blocks, inference settings, and output limits.
  • Actual exchange and usage: Actual request submission, response parsing, usage, and stop reason.
  • Request evidence and errors: Request identifiers, client timing, sanitized errors, and response variability.
  • Access denial and authorization: Model access denial versus response filtering and application authorization.
  • Independent request checks: Learner request modification and independently checked response structure.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Run an authorized SDK request, change it, and record actual responses and operation metadata.

Module 3: Retrieve actual source objects before generation (2 hours)

  • S3 object foundations: S3 bucket, key, prefix, object, region, and persistence basics.
  • Actual object lifecycle: Actual synthetic-object upload, list/read, integrity check, and deletion.
  • Source versions and authority: Source identity/version metadata and authoritative application state.
  • Keyword selection over fetched text: Local keyword selection over S3-fetched text with checked identifiers.
  • Source-backed Bedrock requests: Sending selected source text to Bedrock with provenance labels.
  • Missing and excluded sources: Missing, deleted, excluded, and irrelevant sources with no-answer behavior.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Run the real S3-to-local-retrieval-to-Bedrock path and verify which source identifiers entered the request.

Module 4: Choose additional services only when needed (2 hours)

  • Bedrock and SageMaker roles: Bedrock foundation-model access versus SageMaker AI development and hosting.
  • Training and hosting ownership: Training, deployment, compute capacity, scaling, and operating ownership.
  • Knowledge Bases roles: Knowledge Bases source ingestion, retrieval store, and synchronization roles.
  • Retrieval and transaction boundaries: Retrieval copies versus authoritative transactions and access policies.
  • Sourced service comparisons: Concrete sourced service/API examples and workload-based comparisons.
  • Independent service choice: Independent service choice with cost, lifecycle, and deletion considerations.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Explain a new workload's service choice and mark services the implemented lab does not deploy.

Module 5: Fail safely, retry narrowly, and clean up (2 hours)

  • Live IAM denial: Actual restricted-prefix IAM denial and authorized-access recovery.
  • Bounded connectivity failure: Bounded endpoint/connectivity failure without touching shared network settings.
  • Labeled synthetic faults: Local retry/timeout/throttling fault injection and labeled evidence limits.
  • Bounded retry and spending: Attempt limits, backoff, token bounds, concurrency, and estimated spending.
  • Sanitized operation records: Sanitized request/error/usage records and independently checked success.
  • Allowlisted cleanup: Automated allowlisted cleanup, leftover inventory, and owner escalation.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Diagnose live and injected failures, recover within limits, and verify removal of learner-owned objects/resources.

Practical exercise

  • Use the authorized training role and dedicated bucket/prefix after access setup. Planned supplied materials include IAM policies, a credential-safe starter, synthetic documents, bounded local retrieval, an error-injection adapter, and cleanup inventory checks. Learners complete session/request parsing, S3 read/write calls, source selection and evidence capture, plus one independent failure test. Required AWS operations must actually run under authorized credentials. Fixtures supplement failure teaching; they cannot replace successful AWS requests or live IAM evidence.
  • Use Boto3 with temporary credentials and an explicitly approved region/model. Record identity without credentials, perform a capped Converse exchange, and modify a message. Parse actual response content, stop reason, token usage, request identifier, and latency. Set a small declared maximum request count, input size, output-token bound, retry count, and concurrency before running. Estimate charges from current region/model pricing and obtain the owner's allowance first. Budget alerts are not immediate hard caps. Stop on uncertainty or allowance exhaustion.
  • Upload synthetic text to an owned prefix, list/read it, and check bytes or a hash. Select relevant passages locally from actual fetched content. Submit those passages to Bedrock and inspect the source identifiers in the assembled request. Test deleted/missing sources and an excluded source. Source selection is real local keyword retrieval, not a deployed Bedrock Knowledge Base or vector service. No authoritative business transaction is stored in a retrieval index.
  • Observe a live denied read on a designated forbidden prefix under the prepared role, then verify allowed access still succeeds. Test a bounded client connectivity failure and restore the known endpoint. Record DNS/TLS/endpoint observations separately from IAM results. This does not deploy a VPC endpoint, prove private routing, or test every network boundary. Locally inject throttling/timeout errors to test bounded retries without deliberately exhausting a real service quota. Label them synthetic; do not call them live AWS throttling observations.
  • Execute cleanup only against the allowlisted lab inventory. Delete learner-owned objects, enumerate any versions/delete markers if versioning exists, and verify remaining entries. Delete a learner-created bucket only when explicitly owned and empty. Shared training buckets/roles remain administrator-owned and are reported, not deleted by the learner. Remove local downloaded sources and sanitized logs according to the lab retention rule. Do not claim to erase provider-managed logs. Diagnose a new source/access failure independently before opening feedback.

Delivery and timing

  • Guided hours include teaching, demonstrations, learner practice, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, account approval, and prerequisite setup are additional. Allocations need a timed learner pilot before delivery; they are not measured completion times.

What you will produce

Operate bounded Bedrock and S3 requests with temporary credentials, source checks, failure handling, and allowlisted cleanup.

How the work is checked

  • Actual authorized Bedrock and S3 operations have sanitized request/result evidence.
  • The learner can explain identity and network paths without conflating their checks.
  • Retrieved identifiers and integrity checks trace real S3 data into the model input.
  • Live allowed/denied access tests differ clearly from injected retry cases.
  • Service choices distinguish implementation from SageMaker/Knowledge Bases comparison.
  • Requests/retries remain bounded by the declared allowance procedure.
  • Cleanup verifies the owned inventory and reports retained shared resources.
  • Independent failure diagnosis precedes explanatory feedback.

10 guided hours. Actual Boto3, Bedrock Converse, and S3 operations are required. The application runs locally against real AWS services. SageMaker AI and Knowledge Bases are sourced comparisons. Synthetic timeout and throttling tests do not replace successful AWS requests or live IAM evidence. No hosted application deployment, training endpoint, VPC construction, vector backend, Guardrails deployment, or comprehensive security certification is included.

When another approach is better

  • Use a simpler hosted API when AWS-specific integration and operating requirements do not justify the extra service setup.
  • Do not choose SageMaker AI model training/deployment when managed foundation-model access meets the need.
  • Do not grant model or retrieval identities unrestricted tool mutations, or treat Guardrails as application authorization.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals