AI curriculum

Course outline for Workflow Foundations for AI Automation

Model work before choosing automation. Follow cases through tasks, events, state, handoffs, decisions, and queues. Distinguish fixed rules, uncertain predictions, and stochastic generation. Choose among classical machine learning, specialized or general language models, explicit decision rules, and human judgment. Connect these choices in a BPMN workflow and test whole-process consequences.

Workflow Foundations for AI Automation Course Objectives

  • Define workflow cases, boundaries, inputs, outputs, states, and completion conditions.
  • Distinguish tasks, events, decisions, handoffs, and waiting work.
  • Distinguish deterministic execution, probabilistic prediction, and stochastic sampling within workflow stages.
  • Choose rules, classical ML, language models, or human judgment for a stage.
  • Compare model size and specialization using task evidence, cost, and operating constraints.
  • Separate prediction from decision policy and action authority.
  • Model sequence, choice, parallel work, decisions, and exceptions using BPMN.
  • Trace new cases and compare whole-process time, quality, and review capacity.

Pre-requisites

  • Describe a familiar workplace process and its completion condition.
  • Use a browser and spreadsheet formulas with counts and timestamps.
  • No programming, model subscription, BPMN, or machine-learning experience is required.
  • The course introduces prediction, generation, and decision models from concrete tasks.

Before this course

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

No prerequisite course is required. The entry skills above still apply.

Recommended preparation

Readiness checks

  • Describe a familiar workplace process and its completion condition.
  • Use a browser and spreadsheet formulas with counts and timestamps.
  • No programming, model subscription, BPMN, or machine-learning experience is required.
  • The course introduces prediction, generation, and decision models from concrete tasks.

Describe a familiar workplace process and its completion condition.

Find your place in the learning map

Lab Setup

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

Browser BPMN editor, spreadsheet, synthetic repair records, timed-work data, business policy, prediction scores, model comparison profiles, repeated-output examples, and a small token-distribution worksheet. Supply independently checked labels and hidden explanatory feedback. Teach the editor from a blank diagram. Teach a small decision table before linking it to BPMN. DMN is a conceptual notation reference, not a required engine or full executable-DMN course. No ML library, live model, fine-tuning job, cloud account, or production records are required. Verify stable editor compatibility and worksheet answers before delivery.

Detailed Course Outline

Module 1: Follow one case through the work (1.5 hours)

  • Inputs and completion: Inputs, activities, decisions, outputs, and useful completion.
  • Tasks and actors: Tasks, actors, required information, and observable results.
  • Case identity: Cases, stable case identity, shared resources, and concurrent requests.
  • Events and state: Events, current state, allowed changes, and incomplete cases.
  • Boundaries and exceptions: Workflow boundaries, handoffs, waiting conditions, and exception owners.
  • Repair-case trace: A repair request traced before any automation choice.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.5 hours for practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Trace one repair case and identify each task's input, output, owner, and completion condition.

Module 2: Distinguish stages and choose an approach (2 hours)

  • Deterministic stages: Deterministic calculations and rules under fixed inputs and conditions.
  • Probabilistic prediction and sampling: Probabilistic predictions versus randomness during execution or sampling.
  • Classical machine learning: Classical ML for classification, numeric prediction, and risk estimates.
  • Regression and trees: Logistic regression, decision trees, and their data requirements.
  • Language-model tasks: Language-model classification, extraction, drafting, and sampled generation.
  • Specialized and general models: Smaller specialized/fine-tuned models versus larger general-purpose models.
  • Size and specialization: Model size versus specialization as separate design choices.
  • Stage selection: Stage selection by task fit, evidence, errors, cost, privacy, and latency.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Classify stages on execution and output separately, then justify an approach and one rejected alternative.

Module 3: Connect decisions to the BPMN workflow (2 hours)

  • BPMN editor: BPMN editor basics, XML saving, reopening, and readable task models.
  • Events and participants: Start/end events, sequence flow, pools, lanes, and participant messages.
  • Choices and parallel work: Exclusive choices, parallel branches, joins, timers, and exception paths.
  • Decision-model inputs: Decision models: required inputs, rules, outcomes, and dependencies.
  • Decision tables and DMN: Decision tables and DMN as a companion to BPMN.
  • Thresholds and review capacity: Prediction scores, decision thresholds, error costs, and available review capacity.
  • Policy and authority: Prediction, policy, permission, execution, and escalation as separate responsibilities.
  • Missing and conflicting evidence: Missing evidence, conflicting rules, fallback routes, and abstention.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Draw a traceable BPMN model and a separate decision table that consumes a prediction without treating it as authority.

Module 4: Find where work waits (1.5 hours)

  • Queues and capacity: Queues, arrivals, service capacity, work in progress, and backlog.
  • Handling and waiting time: Handling time, waiting time, and whole-case completion time.
  • Bottlenecks and handoffs: Bottlenecks, batching, handoff quality, and resource constraints.
  • Review and correction: Prediction errors, generated-output review, correction, and repeated work.
  • Measurement assumptions: Feedback measures and explicitly labeled performance assumptions.
  • Capacity comparison: A spreadsheet comparison with changed capacity and review requirements.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.5 hours for practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Explain why a faster predictive or generative stage can increase waiting or leave throughput unchanged.

Module 5: Test a better process before automating it (1 hour)

  • Case-trace consolidation: Consolidation of case walkthroughs completed during the earlier modules.
  • Independent assignment defense: Independent defense of rule, model, and human assignments.
  • Candidate evidence: Model/profile evidence versus unmeasured capability and cost claims.
  • Non-model alternatives: Simplification, better information, and a no-model alternative.
  • Quality and stop criteria: Quality checks, review load, and scale, revise, or stop criteria.
  • Measurable pilot: A measurable pilot with explicit ownership and unresolved assumptions.
  • Guided-time allocation: 0.25 hours for consolidation, 0.5 hours for independent defense and comparison, and 0.25 hours for feedback, questions, and contingency.

Practical outcome: Defend a revised workflow and reject an option that merely moves the queue or conceals uncertainty.

Practical exercise

  • Model a repair desk from request receipt to returned equipment or a documented alternative outcome. Define case identity, states, inputs, outputs, owners, and exceptions. Use the same repair case to examine distinct stage purposes:
  • - Calculate a charge from agreed prices and quantities using fixed arithmetic. - Check stated warranty eligibility through a business-rule decision table. - Predict likely repair duration from historical structured records. - Classify free-text intake into a repair category. - Draft a customer update grounded in the recorded case facts. - Choose a route using predictions, policy, consequences, and human authority.
  • For each stage, record the required result, proposed mechanism, execution behavior, uncertainty, independent check, failure consequence, and fallback. Do not classify the business task itself as permanently deterministic or stochastic: the chosen implementation and conditions matter. A fixed trained classifier can repeat the same score while remaining uncertain about the real outcome. A deterministic charge calculation can still be wrong because its inputs or rules are wrong. Unpredictable human behavior or waiting time is not automatically an algorithm that samples random values.
  • Compare classical ML, a smaller specialized language model, a smaller fine-tuned language model, and a larger general-purpose language model for the intake task. Use supplied, explicitly labeled candidate profiles and outputs. A model can be specialized without being small, and a small model can remain general-purpose. Fine-tuning changes model parameters; a task prompt or retrieved passage alone does not. Compare data availability, quality evidence, latency, total cost, privacy, maintenance, and out-of-domain behavior. Do not infer superiority from parameter count or fine-tuning alone. No learner model training is required.
  • Use a small token-probability table to compare choosing the highest-scored token with sampling from the distribution. Inspect supplied repeated-output examples. Separate stochastic generation from uncertain correctness. Repeatable output is not proof of truth, and a token probability or self-reported confidence is not automatically a calibrated business-event probability. This is conceptual classification and worked comparison, not an implemented model benchmark.
  • Author a decision table using case facts and a supplied prediction. Define nonoverlapping conditions, a default or unresolved path, and the responsible decision owner. Apply it in a spreadsheet or manual trace. Change a threshold and compare false routing, missed urgent work, and review demand using supplied labeled cases and explicit error-cost assumptions. A learned decision tree is not the same thing as a manually authored business decision table. A business decision model can consume predictions without becoming probabilistic itself.
  • Build the BPMN diagram in a browser editor such as the bpmn-js demo. Save and reopen XML. Connect the decision task to explicit routes; the gateway routes on a result rather than performing model inference by itself. Include a safe parallel inspection/availability check. Trace ordinary, incomplete, delayed-part, and unavailable-owner cases with a peer. Test missing evidence and a new input outside a specialized model's stated scope. Keep independent learner judgments and route predictions hidden from the worked feedback until attempts are saved.
  • Calculate handling, waiting, throughput, backlog, review, and correction effort under a stated interval. Compare a simpler non-AI improvement with the selected model-assisted design. Vary review capacity and error assumptions. Scenario values and supplied model outputs are not measurements of implemented business benefits or independent evidence that one model family outperforms another.
  • Distribute the ordinary/incomplete traces into Module 1 and delayed-part/unavailable-owner traces into Modules 3 and 4. Module 5 consolidates these results, compares alternatives, and reserves an independent pilot defense; it does not introduce four new walkthroughs.

Delivery and timing

  • Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.

What you will produce

Model a workflow, justify stage and model choices, and test whole-process consequences before adding automation.

How the work is checked

  • Cases, state, handoffs, completion, and exception ownership remain explicit.
  • Stage classifications separate execution behavior from predictive uncertainty.
  • A repeatable-but-fallible classifier and sampled generation are explained correctly.
  • Rules, classical ML, and language-model choices have task-specific justifications.
  • Model size, specialization, and fine-tuning are not treated as interchangeable.
  • Prediction, decision policy, authorization, and action remain distinct.
  • A learner-authored decision table handles ordinary, missing, and conflicting inputs.
  • BPMN choices, joins, messages, and decision routes trace consistently.
  • New-case predictions precede feedback and include a justified fallback.
  • Whole-process comparisons include quality, review capacity, and simpler alternatives.

8 guided hours. Conceptual stage selection, a browser-authored BPMN diagram, a small decision table, and spreadsheet comparisons. Classical prediction precedes language models. Model size and specialization are separate choices; deterministic execution does not remove predictive uncertainty. Candidate profiles are supplied evidence, not a live benchmark. DMN is comparison-only; no training, fine-tuning, calibration study, or authorization engine is built.

When another approach is better

  • A short checklist can be enough for a single-owner process with no meaningful branching.
  • Do not automate a bottleneck before clarifying its policy and ownership.

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