AI curriculum

Course outline for Reliable Workflow Execution

A timeout does not tell a worker whether an external action succeeded. Execute a small report workflow with durable stage state, bounded retries, and version-checked ownership. Test recovery and compensation rather than assuming that rerunning a task is harmless.

About Reliable Workflow Execution

A timeout does not tell a worker whether an external action succeeded. Execute a small report workflow with durable stage state, bounded retries, and version-checked ownership. Test recovery and compensation rather than assuming that rerunning a task is harmless.

Reliable Workflow Execution Course Objectives

  • Model an acyclic execution plan and identify safe parallel stages.
  • Separate recomputation from side-effect retries.
  • Implement bounded retry and deduplication rules for a mock effect.
  • Reject stale worker updates using a state version.
  • Recover from interruption and document compensation limits.

Pre-requisites

  • Ability to implement and test small programs and model workflow state.
  • Basic concurrency and queue behavior, including duplicate delivery; a supplied bridge can refresh these concepts.

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

  • Basic concurrency and queue behavior
  • Programming and workflow-state modeling

Can model dependencies and implement tested operations; provide a short concurrency/queue bridge where necessary, and use event design as optional deeper preparation.

Find your place in the learning map

Lab Setup

  • Programming runtime, test runner, and local durable task storage such as SQLite.
  • Supplied runner starter, queue simulator, synthetic report tasks, mock action sink with atomic effect-key deduplication, and reproducible failure fixtures.
  • No distributed cloud account or real publication endpoint is required.

Detailed Course Outline

Module 1: Own execution dependencies

  • Coordination: Assign stage ownership and durable completion records so dependent work proceeds only after its required artifacts exist.
  • Scheduling: Order ready stages by dependency and execution constraints, separating eligibility to run from successful stage completion.
  • Parallelism: Identify independent report stages that can run together without conflicting writes or violating required artifact dependencies.
  • DAGs: Represent acyclic stage dependencies with typed artifacts, making prerequisite completion and safe parallel execution explicit.

Practical outcome: Define a report execution graph with typed stage artifacts, safe parallel work, and a durable completion record.

Module 2: Bound failure handling

  • Queues: Track pending execution attempts separately from durable stage state so repeated delivery does not imply repeated publication.
  • Idempotency: Use effect keys to recognize repeated publication attempts and verify one committed mock effect despite lost acknowledgements.
  • Retries: Bound attempts for transient failures and separate harmless recomputation from effects that require deduplication or reconciliation.
  • Timeouts: Treat an expired wait as uncertain effect status, investigating successful actions whose acknowledgements were lost before retrying.

Practical outcome: Implement retry limits and effect keys, then investigate a lost acknowledgement after a successful mock publication.

Module 3: Recover with explicit ownership

  • Compensation: Map failed execution steps to possible corrective actions, distinguishing reversible effects from irreversible outcomes requiring manual reconciliation.
  • Checkpointing: Persist completed stages and artifact references so interruption recovery resumes from recorded progress rather than restarting all work.
  • Recovery: Resume an interrupted approved run without repeating completed stages, checking pending effects and recording unresolved failures.
  • Distributed execution: Protect shared execution state with version-checked ownership, rejecting stale worker updates while acknowledging partial-failure risks.

Practical outcome: Resume from a checkpoint, reject a stale worker update, and define a compensation table for reversible and irreversible effects.

Practical exercise

  • Implement a local report runner with a state store, approval gate, mock publication sink, and failure-injection report.
  • Complete a valid approved run; reject an unapproved publication and a stale worker's state update.
  • Inject a transient failure, interruption, and lost acknowledgement; verify bounded attempts and one committed publication for the fixture's effect key.
  • Resume without repeating completed stages, and document which failed effects need compensation or manual reconciliation.

What you will produce

Recover a checkpointed workflow while testing duplicate effects and stale worker updates.

How the work is checked

  • Approval and dependency checks hold under all supplied failures.
  • Retries stop at configured limits and fixture effects are deduplicated by key.
  • Recovery preserves completed artifacts and rejects stale updates.
  • Compensation records distinguish undo, corrective action, and manual reconciliation.

Six-hour guided starter-extension lab. One mock publication depends on atomic sink-side effect-key deduplication; a non-idempotent endpoint with a lost acknowledgement needs reconciliation, not blind retry. Not universal exactly-once execution, distributed transaction mastery, or a production lease implementation.

When another approach is better

  • A simple sequential script may suffice when work is short and effects are reversible.
  • Do not use a DAG to hide business cycles or assume that compensation reverses every external effect.

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