Choose when a workflow timer starts and what can reset it
Prepared with AI assistance by Alactic Editorial. Examples identified as hypothetical are illustrative, not customer results.
A colleague corrects a contact name, and a follow-up timer starts again. Another colleague adds an internal note, and the deadline moves once more. The workflow is active, but the action it was meant to trigger keeps slipping.
A workflow timer should reset only when a named business event makes the previous waiting period no longer relevant. Routine record edits should not reset it. Start the timer at creation only when the obligation genuinely begins at creation; otherwise, anchor it to eligibility or a specific meaningful transition. Define pauses separately: a pause preserves elapsed time, while a reset discards it.
The practical goal is a clock contract that two colleagues can apply to the same event history and reach the same deadline. The filled fictional worksheet below shows how to write that contract and explain every decision.
1. Choose the question the timer answers
Before choosing a timestamp, complete this sentence: If this condition remains true for this long, we should consider this action. The condition determines which events matter.
Three common timer questions lead to different anchors:
- Age: How long has this record existed? Anchor at creation. Ordinary progress does not make the record younger.
- Eligible waiting time: How long has this item been ready for the next step? Anchor when all required conditions first become true.
- Quiet time: How long has it been since the last qualifying change? Anchor at the latest event in a narrowly defined set.
Hypothetical examples: A review of unprocessed intake records might measure age from creation. An internal reminder to assess a completed request might measure time from eligibility. A check for stalled negotiation might measure time since a substantive proposal change.
Do not use one timer to answer all three questions. Resetting an age timer destroys its meaning. Never resetting a quiet-time timer also destroys its meaning. If the team needs both total age and time since a meaningful change, define separate clocks with separate purposes.
2. Write a clock contract before configuring the workflow
A useful contract is short enough to review but explicit enough to settle disputes. Record the following decisions:
- Purpose and expiry action: What condition is being monitored, and what should become eligible for action when time runs out?
- Anchor event: Which observable transition starts the first clock?
- Duration: How much active elapsed time is required?
- Reset events: Which exact changes discard accumulated time?
- Pause and resume events: Which conditions stop accumulation, and which restore it?
- Cancellation events: What makes the timer permanently irrelevant?
- Ignored activity: Which common updates must leave the clock untouched?
- Expiry guard: What must still be true before any resulting action is authorised?
Use transitions, not broad descriptions. “Record is eligible” describes a state that may be encountered repeatedly. “Record changes from ineligible to eligible” identifies an event. Similarly, “scope changed” is clearer when it means an agreed substantive revision, not any write to a description field.
Decide what happens if a record is already eligible when the workflow first evaluates it. You might start from a trustworthy recorded eligibility event, or start from the first evaluation if that history is unavailable. These choices measure different things. Record the choice rather than silently treating evaluation time as the original eligibility time.
3. Filled fictional worksheet: one timer through edits, reset, and pause
Fictional worked example: An operations team wants an internal review task to become due after a ready request has waited for four active elapsed hours. All names, events, durations, and times below are hypothetical. This is a recommended design, not evidence of a particular product control.
The team chooses eligibility rather than creation because incomplete intake records are not ready to review. It permits one reset: an accepted substantive scope revision that replaces the basis of the review. A documented temporary hold pauses the timer. Completion or withdrawal cancels it.
FILLED CLOCK CONTRACT — HYPOTHETICAL
Record: Request R-217
Purpose: Identify a ready request still awaiting internal review
Duration: 4 active elapsed hours
Initial anchor: First transition into Ready for review
Reset: Accepted substantive scope revision while still eligible
Pause: Documented temporary hold begins
Resume: Hold is explicitly released and request remains eligible
Cancel: Request completed, withdrawn, or no longer requires review
Ignore: Contact corrections, tags, internal notes, reassignment
Expiry: Mark review task due, subject to current-state checks
EVENT TIMELINE — HYPOTHETICAL
08:00 Record created, required information incomplete
Clock: not started
Reason: Creation does not establish review eligibility
09:00 Required information accepted; enters Ready for review
Clock: running; elapsed 0h; remaining 4h
Expected expiry: 13:00
Reason: The agreed anchor transition occurred
09:30 Contact name corrected
Clock: running; elapsed 0h 30m; remaining 3h 30m
Expected expiry: 13:00, unchanged
Reason: Administrative correction is ignored
10:00 Substantive scope revision accepted; still ready
Clock: reset; elapsed 0h; remaining 4h
Expected expiry: 14:00
Reason: Earlier waiting time concerned a superseded scope
10:40 Internal note added
Clock: running; elapsed 0h 40m; remaining 3h 20m
Expected expiry: 14:00, unchanged
Reason: Commentary does not change the review basis
11:00 Documented temporary hold begins
Clock: paused; elapsed 1h; remaining 3h
Expected expiry: unset while hold remains open
Reason: Active waiting time stops, but is not erased
12:00 Tag updated while request is on hold
Clock: paused; elapsed 1h; remaining 3h
Expected expiry: still unset
Reason: Unrelated activity neither resumes nor resets it
13:00 Hold released; request remains ready
Clock: running; elapsed 1h; remaining 3h
Expected expiry: 16:00
Reason: Resume preserves the hour already accumulated
14:00 Owner reassigned
Clock: running; elapsed 2h; remaining 2h
Expected expiry: 16:00, unchanged
Reason: Changing ownership does not renew the waiting period
16:00 Four active elapsed hours reached since the reset
Clock: expired, pending current-state checks
Reason: 10:00–11:00 plus 13:00–16:00 equals 4h
Next step: Authorised internal task action, if still applicableThe reset at 10:00 discards the first hour accumulated after eligibility. The pause at 11:00 does not discard the next hour. These are deliberately different decisions. If the team had treated resumption as a fresh start, expiry would move to 17:00 without a business reason.
At 13:00, the original expected expiry is no longer relevant. Nor should an obsolete 14:00 expiry from before the pause cause an action. The current clock state governs the decision, not an earlier scheduled expectation.
4. Permit resets sparingly and explain their cost
Every permitted reset creates a way for the wait to lengthen. That may be correct, but it should be intentional. Ask of each candidate event: Does this make the accumulated waiting time irrelevant, or does it merely show that someone touched the record?
A substantive scope revision can justify restarting a review timer because the reviewer now faces a different request. A spelling correction cannot. An ownership change usually transfers responsibility for the existing wait; it does not erase that wait.
Avoid relying solely on a generic last-modified timestamp. It combines business events with housekeeping, imports, and routine edits. If the workflow cannot distinguish those updates, a narrower eligibility-based timer may be more dependable than an attempted meaningful-change timer.
Frequent legitimate revisions create a separate trade-off: a resettable timer may never expire. Keep the timer's meaning intact, but consider a separate non-resetting age flag or a human review of repeated resets. Do not silently cap resets unless the team agrees what should happen after the cap.
For auditability, retain the reset reason and the event that caused it. “Scope revision accepted” explains a decision; “record updated” does not.
5. Separate pause, reset, cancellation, and re-entry
Pause means the obligation still exists, but the chosen condition temporarily excludes time from accumulation. Reset means the obligation continues on a new basis. Cancellation means this timer instance no longer applies.
Do not pause merely because progress is inconvenient. If the timer is intended to expose time spent waiting for missing information, pausing whenever information is missing would hide the very delay being measured. A pause must fit the timer's purpose.
For temporary holds, specify who may apply them, the required reason, and who reviews holds that remain open. An indefinite pause with no owner can be as damaging as repeated accidental resets.
Also define what happens when eligibility is lost. A temporary, explicitly recognised hold may preserve elapsed time. A withdrawn request should normally cancel the instance. If that request later returns, decide whether it starts a new eligibility episode rather than reviving an old clock by accident.
Events during a pause need rules too. In the fictional worksheet, tags do nothing. If a qualifying scope revision were accepted during the hold, a defensible extension would reset accumulated time to zero while leaving the clock paused. It would resume with the full duration remaining only when the hold is released. Document that choice; do not let event arrival order decide it implicitly.
6. Protect expiry from stale events and repeated processing
A correct clock definition still needs a safe expiry decision. Before taking the resulting action, recheck that the request remains eligible, is not paused or cancelled, has reached the current deadline, and has not already had that action recorded for this timer instance.
These are recommended workflow requirements, not claims that any particular workspace implements them. Check available controls before relying on them.
- Repeated event: Receiving the same scope-revision event twice should not restart the timer twice. Identify the underlying business event rather than treating each notification as new.
- Late event: Choose whether elapsed time follows the recorded business-event time or processing time. If a reliable event arrives late, recompute and review the result rather than hiding the discrepancy.
- Old expiry: A previously scheduled expiry must not act after a reset, pause, or cancellation has superseded it.
- Simultaneous events: Define a tie-break rule. For example, process a cancellation before considering an expiry action at the same recorded time.
Timer expiry is not blanket authorisation for everything downstream. An internal task and an external message have different prerequisites. If the next step requires separate approval, expiry should make it ready for that approval, not bypass it.
7. Recover from a wrong deadline without rewriting history
If routine edits have already reset timers, do not simply change every deadline to the current time plus the full duration. That starts another waiting period and conceals the original problem.
- Identify affected active timer instances and temporarily hold their downstream actions where appropriate.
- Reconstruct each clock from the agreed anchor, qualifying resets, and pause intervals.
- Compare the reconstructed state with the stored state and record the correction reason.
- Review already-expired cases before releasing actions, especially if correction would produce a burst of overdue work.
- Preserve any actions already taken so the correction does not create duplicates.
If the history is insufficient, label the deadline uncertain and route the item for a human decision. An explicitly uncertain clock is more useful than a precise-looking deadline built from invented events.
8. Test the contract against observable outcomes
Before enabling a revised workflow, replay the fictional worksheet in a safe test process. After every event, compare the actual clock state, accumulated time, and expected expiry with the worksheet. Check the workspace and current plan for the controls needed to represent these rules.
Add cases for a duplicate reset event, a cancellation immediately before expiry, a qualifying change during a pause, and a request that becomes eligible again after cancellation. Each case should have a written expected outcome before testing begins.
Your next action is to select one disputed timer and fill in its clock contract with its process owner. Review a small, explicitly chosen sample of recent event histories against it. Count unexplained deadline changes, resets caused by unrelated edits, and pauses with no recorded release decision. Those observations show where the contract or its implementation needs correction.
The acceptance criterion is concrete: given the same history, two reviewers should identify the same anchor, accumulated time, current state, and next permitted action.
Put the next conversation to work.
Explore Alactic Communications for WhatsApp conversations, campaigns and AI-assisted workflows. Choose the product and plan that fit your team.
Explore Communications