How do I write instructions for a task that different people perform in different roles?

Plan the instructions around the work, not around a long chronological list with role names tucked into sentences. First make a small inventory: the roles involved, the actions each role performs, the steps they share, and each point where work changes hands. Then use that inventory to create clear paths through the document.

A useful structure is:

1. Purpose and roles — name the task and briefly define each role.
2. Shared steps — include actions every role needs to follow.
3. Role-specific instructions — give each role its own labeled section.
4. Handoffs — state what is passed, who receives it, and what happens next.

Use role names consistently. If you call someone the “reviewer” in one section and the “approver” in another, readers may not know whether those labels mean the same person. Where a role has no action at a particular stage, omit that stage from its path rather than making the reader infer that it does not apply.

Usually, give shared actions one home and point each role to them. Repeating them can leave readers unsure whether they must do the action once or once per role, and later edits can make copies inconsistent. For example, put “Shared steps: record the request and save the working file” in one section. In a role path, write “Complete Shared step 1, then follow the Coordinator actions below.” Make sure the reference points to the exact shared step or steps that role needs.

Repeat a shared instruction only when readers genuinely need the full action right where they are working—for example, if they will use a short role-specific checklist separately. If you do repeat it, identify the single authoritative version or keep the wording identical as you revise. Avoid vague labels such as “everyone” when you mean specific roles; name the roles so readers can tell whether the instruction applies to them.

Write a handoff as a complete instruction, not just “send it to the next person.” Specify four things: who initiates the handoff, what item or information they pass, who receives it, and what event means the receiver should begin. Add the next action so the process does not trail off.

For instance, in a hypothetical document-review process: “When the draft is ready, the Writer sends the draft and its open-questions list to the Reviewer. The Reviewer checks the marked sections and returns comments to the Writer.” These role names and actions are examples to replace with your actual process. If timing matters, use a defined event or a placeholder such as “[agreed deadline]” instead of an unclear phrase like “soon.” If a handoff can be rejected or sent back, describe that route too, including who resumes the work.

Here is a copyable outline. Replace the bracketed text with your process details, and remove any section that does not apply.

Task: [name the task] Roles: [Role A: responsibility]; [Role B: responsibility]

Shared steps

1. [Action required of every listed role]
2. [Another shared action, if any]

Role A: [role name]

1. Complete Shared step [number].
2. [Role A action].
3. When [handoff trigger], send [item] to [Role B].

Role B: [role name]

1. Start when [trigger occurs or item is received].
2. [Role B action].
3. Send [result or next item] to [recipient].

If the work returns: [Who acts next, what changes, and where the process resumes.]

To test the outline, read only one role’s section at a time. Ask: Can that person tell what to do, what to use, when to act, and where to send the result? Then read the handoff from both sides: does the sender know what to pass, and does the receiver know when to begin? Ask someone familiar with the process to flag unclear role labels or missing transitions. This is a clarity check, not a guarantee that the instructions cover every exception.