AI curriculum

Course outline for Platform Engineering for AI Teams

Build a small supported path that helps a developer start, test, and release an ordinary service. Begin with user needs, ownership, and support boundaries. Operate Terraform on safe local files and run a real local delivery workflow. Complete a self-service request, route an exception, and measure developer waiting and support work before proposing an improvement. Compare an AI-team extension through Kubeflow and KServe after the general developer path works.

Platform Engineering for AI Teams Course Objectives

  • Define platform users, supported capabilities, ownership, and a versioned service contract.
  • Write and run local-safe Terraform plan, apply, state inspection, and destroy.
  • Reproduce an environment and execute meaningful build/test/package/release gates.
  • Operate act locally and explain its difference from a hosted CI service.
  • Distinguish sourced GitOps reconciliation examples from the running delivery path.
  • Complete a self-service request and handle repeat, changed, and unsupported requests.
  • Measure actual developer waiting, failures, and support touches during a bounded trial.
  • Explain Kubeflow lifecycle and KServe serving roles through sourced declarations and a responsibility map.

Pre-requisites

  • Build and run a small application with files, configuration, and a terminal.
  • Use Git commits and explain basic test, build, and release steps.
  • Cloud Foundations for AI Engineers or equivalent cloud-resource and operating-responsibility concepts.
  • No Terraform, GitOps, hosted CI, Kubernetes, or AI-platform experience is required.

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

  • Build and run a small application with files, configuration, and a terminal.
  • Use Git commits and explain basic test, build, and release steps.
  • Cloud Foundations for AI Engineers or equivalent cloud-resource and operating-responsibility concepts.
  • No Terraform, GitOps, hosted CI, Kubernetes, or AI-platform experience is required.

Build and run a small application with files, configuration, and a terminal.

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.

Git, compatible stable Terraform/local provider, act with Docker and supported runner image, ordinary service/test runtime, dedicated disposable directories, local request CLI, partial workflow/template, developer trial cases, and cleanup inventory. Licensing, architecture, runner host-access boundaries, actual plan/apply/destroy, tests, package release, recovery, and resource limits require verification. Version-bound Kubeflow/KServe examples and responsibility worksheet support comparison; no cloud account or Kubernetes cluster is required.

Detailed Course Outline

Module 1: Start with the developer's job (2 hours)

  • Developer needs and ownership: Developer users, repeated needs, current friction, and product ownership.
  • Platform product boundaries: Platform capability versus portal, tool collection, or operations ticket queue.
  • Supported service contract: Supported service contract, inputs, outputs, lifecycle, and ownership.
  • Credential responsibilities: Developer/platform responsibilities and credential-delivery boundaries.
  • Versioned declarations and previews: Versioned declarations, repeatability, infrastructure state, and change previews.
  • Golden path and simpler template: Golden-path hypothesis, success measures, and a simpler documented template.
  • 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: Define a small developer capability with supported inputs, named owners, and measurable user outcomes.

Module 2: Operate Terraform on a safe local target (2 hours)

  • Terraform foundations: Terraform basics, configuration blocks, providers, resources, and variables.
  • Safe local provider: Local provider file resource inside a dedicated disposable directory.
  • Plan and actual apply: Init, format, validate, plan, saved-plan review, and actual apply.
  • Outputs and state: Outputs, state list/show, managed identity, and state ownership.
  • Drift and repair: Changed input, actual file drift, refreshed plan, and checked repair.
  • Destroy and sensitive-state limits: Destroy preview, actual destroy, leftovers, and sensitive-state precautions.
  • 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: Author a local resource, apply it, inspect actual state, repair drift, and destroy it safely.

Module 3: Run a delivery workflow rather than read its records (2 hours)

  • Delivery workflow foundations: CI/CD basics, jobs, steps, dependencies, exit status, and artifacts.
  • act runner operation: act introduction, Docker-backed runner execution, and workflow YAML basics.
  • Reproducible setup: Reproducible dependency/runtime inputs and clean developer setup.
  • Actual tests and build: Learner-authored tests and real build/package steps for the ordinary service.
  • Failed promotion gate: Failed test blocking promotion and inspected runner output.
  • Corrected release smoke check: Corrected commit, rerun, versioned artifact, and local release smoke check.
  • 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: Execute a learner-extended local workflow that rejects a broken change and releases a checked artifact.

Module 4: Separate delivery from reconciliation (2 hours)

  • Promotion ownership: Environment configuration, package identity, promotion, and deployment ownership.
  • Input-bound approval: Release approval bound to exact inputs and changed-preview invalidation.
  • Repeat release and rollback: Actual repeat release and rollback to a prior checked local package.
  • GitOps reconciliation: GitOps desired state, observed state, drift, and reconciliation loops.
  • Argo CD comparison: Argo CD sourced Application/sync/health examples and a labeled state replay.
  • Delivery and health evidence: Pipeline success versus deployed health and reconciliation evidence limits.
  • 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 local promotion/rollback and explain a separate GitOps drift replay without claiming a live reconciler.

Module 5: Offer a usable self-service golden path (2 hours)

  • Supported service template: Supported application template, setup, tests, release, and operating guidance.
  • Local request interface: Local request CLI, schema validation, environment key, and inventory.
  • Actual operation wiring: Wiring requests to actual Terraform and act workflow operations.
  • Preview consent and repeats: Preview-bound consent, repeat request, and changed-input handling.
  • Failure and teardown: Invalid request rejection, partial failure, recovery, and safe teardown.
  • Independent developer request: Independent new-developer request with no hidden maintainer steps.
  • 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: Complete a new request through real local resources and delivery checks, then verify repeat/recovery behavior.

Module 6: Support exceptions and improve the product (2 hours)

  • Exceptions and escalation: Unsupported requests, named exception owner, escalation, and response expectations.
  • Paired developer trial: Paired developer trial with request/start/ready timestamps.
  • Waiting and effort: Developer waiting versus elapsed provisioning/runtime and active developer effort.
  • Completion and support measures: Failed requests, support touches, completion denominator, and small-sample limits.
  • Path improvement trial: One reviewed path improvement and a comparable repeat trial.
  • Optional specialization and cleanup: Optional AI-provider specialization, separate credential delivery, and cleanup.
  • 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: Route an exception and use measured waiting/support evidence to propose and check one bounded improvement.

Module 7: Extend the path only where AI teams need it (2 hours)

  • Kubernetes controller bridge: Kubernetes desired state, custom resources/controllers, Pods, runtimes, and Service endpoints.
  • Training and inference bridge: Training jobs produce model weights; inference consumes weights through endpoints.
  • Kubeflow lifecycle: Kubeflow lifecycle roles, pipeline parameters/components, artifacts, and provenance.
  • KServe and vLLM roles: KServe InferenceService deployment control versus vLLM execution and application policy.
  • Model resource and credential ownership: Model versions, storage access, resource requests, quotas, and credential ownership.
  • AI platform request and alternatives: Supported platform request, exception route, and simpler standalone serving alternative.
  • 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: Trace a sourced lifecycle and serving example, then extend the platform contract for an unseen model-service request.

Practical exercise

  • Create a small ordinary-service golden path for a developer who currently needs maintainer help. Planned supplied assets are a service/test starter, pinned runtime environment, a local request/inventory skeleton, act runner setup, partial workflow, fault hooks, and an exception form. Learners author the user contract, Terraform file resource, meaningful tests/workflow changes, request validation and operation wiring, plus one independent acceptance check. The supplied skeleton must not already solve the supported request end to end.
  • Write actual Terraform using the local provider to manage an environment configuration file under a dedicated disposable root. Run init/validate/plan, inspect a saved plan, apply it, inspect state via supported commands, and compare the actual file. Change a parameter, introduce file drift, plan again, and repair. Destroy the resource and check its absence. Do not edit state JSON directly, commit state, put secrets into it, or call a managed local file a cloud resource. State removal is not destruction and a plan is not an applied environment.
  • Use act as the selected actual local CI runner. Teach workflow syntax, job/step dependency, exit codes, and runner output before relying on it. Execute tests, build a versioned local package, and promote it into a disposable release directory. Start the released ordinary service and run a real smoke request. Break a learner test, observe blocked promotion, repair it, and rerun. Recreate the developer setup in a clean directory and compare the required outputs. Roll back to the previous checked package. Local execution does not certify full GitHub-hosted runner parity.
  • Connect a local self-service CLI to validated requests, Terraform-managed local configuration, and the actual workflow. Approve the exact preview. Repeating the same environment key must not create another environment. A changed parameter needs a fresh preview. Reject an invalid request before apply. Interrupt between configuration and release, inspect inventory/state, recover, and verify one working environment rather than trusting a recorded success flag. The release directory and Terraform resource have separate cleanup owners in the contract.
  • Use sourced Argo CD examples and a deterministic desired/live-state replay to explain drift detection, sync, and health. This is comparison-only GitOps evidence, not an installed reconciler, cluster deployment, or continuous convergence claim. GitOps understanding is checked on a new replay state, not by relabeling CI logs.
  • Have a peer follow the supported path without hidden manual assistance. Capture actual request, start, ready, wait, failure, and support-touch observations. Escalate an unsupported request with an owner and expected response. Propose one change and compare a repeat trial, retaining differences and small-sample limits. Preserve a new unsupported/failure case for independent work before feedback. AI model/data policy is an optional later specialization, not the platform's starting point. Destroy owned local resources and verify retained artifacts.
  • Retain the entire ordinary-service Terraform, act, self-service, recovery, and peer trial exercise. First draw the Kubernetes desired-state/controller, Pod/runtime, and Service/endpoint bridge. Trace training-produced weights into a separately declared inference input. This is document-based explanation, not a running training job or verified automatic handoff. Use a sourced Kubeflow Pipelines example to follow a parameter through components into an artifact and its provenance. Contrast this lifecycle with the actual CI workflow rather than calling any DAG a Kubeflow pipeline. Follow a sourced KServe InferenceService through controller, runtime selection, model storage, resource requirements, and request route. Trace how a vLLM backend executes inference without making vLLM the platform controller. KServe's documented OpenAI routes can carry an `openai` prefix; direct vLLM paths are not interchangeable.
  • Extend the supported request schema with model revision, resource requirements, data class, endpoint owner, and storage/credential owner. Decide whether the request fits the path or requires escalation. Work a new unsupported-resource case before feedback. Kubeflow and KServe are sourced comparison-only, not required installs. Optional inspection of an already prepared authorized cluster can supplement the same module, not add a compulsory GPU or full Kubeflow deployment. If provided, label observed cluster state separately from documentation and replay. No Kubernetes entry prerequisite is silently added to the running general platform path.

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 a bounded self-service delivery path and distinguish platform lifecycle responsibilities from AI training and serving.

How the work is checked

  • A developer need and supported contract justify the path and name its owners.
  • Actual Terraform plan/apply/state/drift/destroy observations are independently checked.
  • act executes learner-authored checks and a real local release/smoke path.
  • A failed check blocks promotion and a clean rerun/rollback verifies recovery.
  • GitOps replay is explained separately and never presented as live reconciliation.
  • New, repeated, changed, invalid, interrupted, and unsupported requests have checked outcomes.
  • Actual developer waiting and support records support only bounded improvement conclusions.
  • The independent task precedes feedback and both resource/release cleanup are verified.
  • Kubeflow/KServe comparison distinguishes lifecycle artifacts, deployment control, runtime execution, and platform ownership.
  • A new request separates training output from inference input and controller reconciliation from pipeline orchestration.

14 guided hours. General platform product and developer needs come first. Terraform with the local provider and act are required actual operation. The supported path provisions local configuration and releases a local service. Argo CD is sourced comparison/replay, not a live reconciler. Kubernetes/controller and training-versus-inference bridges support a bounded Kubeflow/KServe comparison. No cluster, full ML lifecycle installation, training, GPU provisioning, secure multi-tenancy, or live reconciliation guarantee is claimed. A documented template can be sufficient.

When another approach is better

  • A documented deployment template may suffice before there is enough repeated demand for a platform.
  • Do not force unusual workloads through a golden path that lacks an owned exception route.

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