VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

How Procedures Fail | Why Correct Instructions Still Break in Real Work

Three secondary students review open books and notes together in a classroom.

How procedures fail is a systems question. A procedure can be correct on paper and still break when people use it under real conditions.

The gap appears when the written route and the operating environment drift apart: steps assume knowledge the user does not have, sequence ignores dependency, exceptions are hidden, interruptions erase state, tools change, versions multiply, or nobody knows what to do when the normal route no longer fits.

A procedure is therefore more than documentation. It is an interface between intention and repeatable action.

The strongest procedures reduce ambiguity without pretending judgment can be eliminated. They show the user what to do, in what order, under which conditions, with what evidence, and what happens when reality does not match the normal path.

This master guide is supported by three pillar explainers: How Procedure Steps Work, How Procedure Exceptions Work and How Procedure Version Control Works.


The Core Idea: A Procedure Is Executable Knowledge

A policy can state what should be true. A textbook can explain why something works. A checklist can protect a few critical omissions. A procedure has a narrower operational job: carry a person from a defined starting state to a defined next state through a usable sequence of actions.

That makes procedure quality observable. Can the intended user actually perform the task from the document, using the available tools, under ordinary conditions?

A useful procedure is not judged by how complete it looks. It is judged by whether it produces reliable action.


Failure Mode 1: The Procedure Describes the Ideal World

Real work contains interruptions, missing information, unavailable people, slow systems, unfamiliar cases and time pressure.

If the document only describes the perfect path, users must invent the rest. The result is shadow practice: the unofficial method that actually keeps the work moving.

The important question is not whether people deviate. It is why the deviation became necessary.


Failure Mode 2: The Starting State Is Undefined

A procedure can begin too late. Step 1 may silently assume the correct file, account, worksheet, instrument, prerequisite skill or approval is already available.

Good procedures make preconditions visible.

  • Required inputs are available.
  • The correct version is open.
  • The user has the necessary access.
  • Prerequisites are satisfied.
  • The task belongs to this procedure.
  • The environment is suitable for the work.

Without a clear starting state, failure may begin before the first written step.


Failure Mode 3: One Step Contains Several Hidden Decisions

A short sentence can compress expert judgment.

‘Review the answer and make any necessary corrections’ sounds clear but hides several decisions: what to inspect, what counts as an error, which errors matter, how to repair them and how to know the repair worked.

This is why novice users can fail to follow instructions that experts find obvious. The expert sees the hidden decision tree. The learner sees one sentence.


Failure Mode 4: Steps Are Not Observable

Words such as handle, manage, ensure, review and process often describe intention rather than action.

A stronger step exposes what the user actually does. Instead of ‘ensure the file is correct’, specify what must be compared. Instead of ‘check the calculation’, specify the independent test. Instead of ‘confirm understanding’, specify what the learner must explain or solve without support.

Observable steps make training, supervision and repair possible.


Failure Mode 5: Sequence Does Not Match Dependency

A procedure is a sequence because some actions must happen before others.

You cannot verify the final version before deciding which version is final. You cannot test transfer before a learner has a method to transfer. You cannot publish safely before unresolved source uncertainty is cleared.

The order should follow the dependency structure of the task, not the author’s memory of how the task usually feels.


Failure Mode 6: Decision Points Are Hidden

Many tasks branch. The result of one step determines whether the user should continue, repeat, stop, seek help or switch methods.

When the branch is hidden, people improvise.

Useful branches depend on observable conditions: if the value is within range, continue; if not, retry once; if it remains outside range, escalate.


Failure Mode 7: Exceptions Are Treated as User Error

A non-standard case is not always a mistake. Sometimes the world legitimately falls outside the normal path.

A rigid procedure forces users either to violate the document or to produce the wrong result.

A reliable procedure therefore includes an exception route. That mechanism is developed in How Procedure Exceptions Work.


Failure Mode 8: The Procedure Is Too Long for the Moment

A procedure can contain useful information and still be unusable because the user cannot navigate it at the speed the task requires.

Separate the execution path from reference detail. The procedure carries the workflow. Reference material explains background. A checklist protects a small number of critical omissions.

Trying to make one document do all three jobs often produces a document that does none of them well.


Failure Mode 9: The Procedure Is Too Short for the Skill

Brevity can hide judgment. If the task depends on recognising quality, interpreting evidence or choosing among methods, a short list can become a collection of labels rather than a usable route.

The answer may be examples, non-examples, decision tables, guided practice or training rather than more compressed prose.

A procedure should not be expected to create expertise from nothing.


Failure Mode 10: The Procedure Is Written for the Author

Experts write with expert memory. They skip transitions that feel obvious and use vocabulary that is already connected inside their own mental model.

The intended user may not share that model.

A strong procedure is tested from the performer’s side.


Failure Mode 11: Interruption Is Ignored

People are interrupted. They change rooms, answer questions, lose connectivity, move between students or pause for the night.

A good procedure makes state visible so the user can resume without repeating the wrong action or skipping the next one.

Resumption is part of reliability.


Failure Mode 12: There Is No Stop Rule

A procedure that explains how to continue but not when to stop can create over-processing.

Students revise a stable topic for too long. Editors polish low-value details. Teams keep investigating after enough evidence exists to decide.

A stop rule defines done.


Failure Mode 13: There Is No Escalation Rule

What happens when the user cannot complete the next step?

A mature procedure defines when to seek help, when to stop, when to switch to a specialist and when a different procedure is required.

This connects directly with How Warning Escalation Works.


Failure Mode 14: The Procedure Becomes a Substitute for Competence

Procedures can support competence. They cannot replace every form of it.

A student may follow a fixed solution routine successfully on familiar questions but still fail to select the method when the surface changes.

The procedure should therefore expose important decisions and gradually transfer them to the learner.


Failure Mode 15: The Method Is Never Tested With a Cold User

Authors are poor detectors of their own hidden assumptions because they already know what each line means.

Give the procedure to an intended user who did not help write it. Observe where they hesitate, ask questions or make reasonable but wrong interpretations.

Those moments are design evidence.


Failure Mode 16: The Procedure Does Not Fit the Available Time

A logically correct method can be operationally impossible.

If a procedure needs thirty minutes inside a ten-minute window, users will compress it. The compression may remove exactly the step that protected quality.

eduKate Sengkang’s Implementation-Feasibility Gate applies this principle to teaching routines: test the method under ordinary time, materials and learner variation before blaming non-use on the performer.


Failure Mode 17: Tools Change but the Procedure Does Not

Procedures are coupled to interfaces, forms, systems, equipment and rules.

When those change, the method can become stale while still looking official.

A procedure therefore needs an owner, a review point and a way to retire obsolete instructions.


Failure Mode 18: Multiple Versions Circulate

Two people can follow a procedure correctly and still disagree because they are using different versions.

Downloaded files, screenshots, printed copies, duplicated folders and old bookmarks all create version drift.

The system needs a source of truth, visible version identity and a retirement rule. This is the focus of How Procedure Version Control Works.


Failure Mode 19: Compliance Is Mistaken for Outcome

A procedure can be followed perfectly and still fail to produce the intended result.

If the system audits only whether the steps were followed, a broken method can survive indefinitely.

The outcome must return as evidence. Did the procedure reliably produce the state it was designed to produce?


The Three Pillars of a Reliable Procedure

1. Executable Steps — expose the action, object, condition and completion state.

2. Exception Handling — define what happens when reality falls outside the normal route.

3. Version Control — keep the current method identifiable, traceable and usable.


A Practical eduKateSG Procedure Test

  • What outcome is this procedure meant to produce?
  • When should it be used and when should it not?
  • What must already be true before Step 1?
  • Are the actions observable?
  • Does sequence follow dependency?
  • Are branches tied to visible conditions?
  • What happens when the normal route does not fit?
  • What proves each critical state?
  • Who owns each action?
  • What happens when local action is insufficient?
  • How does the user resume after interruption?
  • What defines done?
  • How does the user know the procedure is current?
  • How do failures update the method?

Example: Mathematics Error Repair

  • Reattempt the question without the worked solution.
  • Mark the first line where the new attempt diverges from a correct route.
  • Classify the first meaningful cause.
  • Repair that cause only.
  • Solve one near variant without support.
  • Return later to a changed question.
  • If the same failure repeats, escalate the diagnosis instead of adding more identical practice.

Bukit Timah Tutor’s How Checking Works in PSLE Mathematics develops the subject-specific idea that useful checking seeks independent evidence rather than simply looking again.


Example: English Editing

  • Check task completion.
  • Check organisation.
  • Check sentence boundaries.
  • Check tense, agreement and reference.
  • Check high-risk vocabulary and spelling.
  • Make only corrections you can justify.
  • Read each changed sentence again in context.

Singapore English Tuition Centre’s English Editing Performance applies this as a constrained search for high-value correctable errors.


Example: Learning Routine

A learning procedure should produce evidence of capability rather than merely time spent.

eduKate Sengkang’s How Independent Learning Works, eduKate Punggol’s Mathematics Study Routine and eduKate Yishun’s Recovery Atlas show how action, evidence, repair and independence connect across the wider ecosystem.


Across the eduKate Ecosystem

eduKateSG owns the general procedure mechanism. eduKateSingapore Project Atlas maps ownership and routes readers to specialist estates. eduKate Sengkang develops the learning process. eduKate Punggol shows family-facing implementation. Bukit Timah Tutor carries Mathematics verification. SETC carries English examination independence. eduKate Yishun carries diagnosis, recovery and rebuild decisions.


Sources and Further Reading

UK Health and Safety Executive — Procedures and Human Factors

NASA / FAA — Human Factors Design Standard

Federal Aviation Administration — The Use and Design of Flightcrew Checklists and Manuals


Continue the Series

How Procedure Steps Work | Turn Intent Into Observable Action

How Procedure Exceptions Work | Handle Non-Standard Cases Without Breaking the Standard

How Procedure Version Control Works | Keep the Current Method Current, Traceable and Usable

eduKateSG