The Workflow Prompt Pack for Ops

I am going to describe a manual process my business runs. Your job is to turn my description into a numbered step-by-step list. Do not add steps I have not mentioned. Do not assume best practice. Just map what I describe, exactly as I describe it.

Here is the process: [PASTE YOUR BRAIN-DUMP OR VOICE NOTE TRANSCRIPT HERE]

Constraints:
- Number every step, including handoffs between people
- Where I am vague, flag the step with [NEEDS CLARIFICATION] rather than guessing
- Keep each step to one action only
- Do not group steps together
- Output as a plain numbered list, no headers yet

Here is a numbered list of steps in a process. For each step, identify who performs it based on the context I give you.

Process steps: [PASTE NUMBERED LIST FROM PREVIOUS PROMPT]

People or roles involved: [e.g. VA, me (founder), client, HubSpot, our copywriter]

Constraints:
- Add a [OWNER: name/role] tag at the end of each step
- Where the owner is unclear, tag it [OWNER: UNKNOWN]
- Where a tool or software does the work, tag it [OWNER: TOOL: tool name]
- Do not change the step wording
- Output the full numbered list with tags added

I am documenting a process so I can automate it. I need to identify the exact trigger that starts the process and the exact outcome that ends it.

Here is my process list: [PASTE NUMBERED LIST WITH OWNERS]

Context on what starts this process: [e.g. a new lead fills in a form / a client pays an invoice / someone sends an email with a specific subject line]

Context on what done looks like: [e.g. the client has received the welcome pack and their project is set up in our system]

Constraints:
- Write the trigger as a single sentence starting with 'This process starts when...'
- Write the end point as a single sentence starting with 'This process ends when...'
- Flag any steps that happen before the trigger or after the end point as [OUT OF SCOPE]
- Do not suggest improvements yet

Review this process list and identify every point where a human has to make a decision before moving to the next step. A decision is any moment where the next action depends on a condition being true or false.

Process list: [PASTE NUMBERED LIST]

Constraints:
- Mark each decision step with [DECISION]
- After each [DECISION] step, write the question that person is silently asking themselves, e.g. 'Is this lead in our target country?'
- Do not list steps that are just actions, only genuine forks in the road
- Output the full numbered list with [DECISION] tags and the hidden question shown

For each decision point in my process, I need a clear if/then rule so a system or a new team member can make the same call without asking me.

Decision points from my process: [PASTE ONLY THE [DECISION] STEPS AND THEIR HIDDEN QUESTIONS]

For each decision, here is the answer I usually give and why: [WRITE A SENTENCE OR TWO FOR EACH, e.g. 'If they filled in the budget field and it says under 1000, I move them to the low-budget sequence. If the field is blank, I treat them as unknown and send the discovery call invite.']

Constraints:
- Write each rule as: IF [condition] THEN [action]. ELSE IF [condition] THEN [action]. ELSE [default action].
- Rules must be specific enough for someone who does not know your business to follow
- Flag any rule where you cannot name the condition precisely with [RULE UNCLEAR: needs definition]
- No narrative, just the rules

Every process has situations where the normal rules do not apply. I need to document those so they do not break an automation.

My process: [PROCESS NAME, e.g. New Lead Onboarding]
My if/then rules: [PASTE RULES FROM PREVIOUS PROMPT]

Here are the exceptions I know about: [e.g. 'Enterprise leads always skip the nurture sequence and go straight to a call', 'Existing clients who buy again do not get the welcome email', 'Anyone who mentions a competitor by name gets flagged for me to call personally']

Constraints:
- List each exception as: EXCEPTION: [trigger condition] overrides rule [rule number] and instead does [alternative action]
- After each exception, note who currently spots this and handles it: [CURRENTLY SPOTTED BY: name/role]
- Flag exceptions that currently depend on one person's memory with [FRAGILE: depends on [name]]

A handoff is any point in the process where responsibility moves from one person, tool, or team to another. I need every handoff documented so nothing falls through.

My process list with owners: [PASTE NUMBERED LIST WITH OWNER TAGS]

Constraints:
- Identify every step where the owner tag changes from the step before
- Label these [HANDOFF: from [previous owner] to [new owner]]
- For each handoff, add one line: 'Currently communicated via: [e.g. Slack message, email, verbal, nothing formal]'
- Flag handoffs with no formal communication method as [AT RISK]
- Do not suggest fixes yet, just document what exists

I need to identify where this process loses the most time so I know which steps to prioritise for automation.

My process list: [PASTE NUMBERED LIST]

For each step, here is roughly how long it takes and how often it gets delayed: [e.g. 'Step 4 takes about 20 minutes but often waits a day because I forget', 'Step 7 takes 5 minutes but the VA has to wait for me to approve before she can do it']

Constraints:
- Add a time tag to each step: [TIME: X mins]
- Add a wait tag where there is a delay before the step starts: [WAIT: typical delay + reason]
- Calculate the total process time two ways: [ACTIVE TIME: sum of all step times] and [ELAPSED TIME: active time plus typical waits]
- Flag the three steps with the longest combined time and wait as [TOP BOTTLENECK 1], [TOP BOTTLENECK 2], [TOP BOTTLENECK 3]

I want to find every place where the same information is entered, checked, or communicated more than once across this process.

My full process: [PASTE NUMBERED LIST WITH OWNERS, TIMES, AND WAIT TAGS]

Data and information that moves through this process: [e.g. client name, email address, project brief, invoice amount, login credentials, delivery date]

Constraints:
- For each piece of data, list every step where it is touched (entered, copied, checked, sent, or reformatted)
- Flag any data touched more than once as [DUPLICATE TOUCH: data name, steps affected]
- Note which duplicate touches could be eliminated if a single source of truth were used
- Do not propose specific tools, just describe what the single source would need to contain

I have documented a messy manual process. Now I need a clean, optimised version that removes duplicate steps, tightens the handoffs, and is written clearly enough for a new team member or an automation platform to follow.

Original process: [PASTE FULL DOCUMENTED PROCESS WITH ALL TAGS]
If/then rules: [PASTE RULES]
Exceptions: [PASTE EXCEPTIONS]

Constraints:
- Renumber from step 1
- Each step must be one action: verb + object + context, e.g. 'Send the client the project brief template via email'
- Include the owner for each step in brackets: (Owner: [name/role/tool])
- Include the trigger and end point at the top
- Group consecutive steps by the same owner into a labelled block, e.g. '--- VA BLOCK ---'
- Keep exceptions as a separate numbered list at the bottom, not embedded in the main flow
- Do not add steps that were not in the original process
- Flag any step that is a candidate for full automation with [AUTO CANDIDATE]

Using my clean process flow, write a plain-English summary that a new team member could read in under two minutes and understand what this process does, who is involved, and what good looks like.

Clean process flow: [PASTE CLEAN NUMBERED FLOW]

Constraints:
- Maximum 200 words
- Structure: one sentence on what this process does, one sentence on who is involved, one sentence on the trigger, one sentence on the end point, one sentence on the most common failure point and how to avoid it
- Write in plain language, no jargon
- Do not use bullet points, write as a short paragraph
- End with: 'If anything goes wrong, the first person to contact is: [OWNER OF FIRST AT-RISK HANDOFF STEP]'

I want to automate parts of this process. Before I start, I need to know which steps are actually ready and which ones still need work.

Clean process flow: [PASTE CLEAN NUMBERED FLOW WITH [AUTO CANDIDATE] TAGS]

For each [AUTO CANDIDATE] step, evaluate it against these four criteria:
1. Is the trigger for this step a specific, detectable event (not a person's judgement)?
2. Is the data needed for this step available in a single, structured source?
3. Is the output of this step a specific, predictable artefact (email, record, file, message)?
4. Are the if/then rules for this step complete and unambiguous?

Constraints:
- Score each candidate step: [READY], [NEARLY READY: what is missing], or [NOT READY: what needs to be fixed first]
- For NEARLY READY and NOT READY steps, write one line on the single most important thing to fix
- Produce a priority order: which steps to automate first based on time saved and readiness score
- Do not recommend specific tools in this output

I need a brief I can hand to a developer, a Make or Zapier specialist, or an AI agent builder so they can build the automation without needing to ask me many questions.

Process name: [PROCESS NAME]
Steps to automate: [LIST THE [READY] STEPS FROM THE PREVIOUS PROMPT]
Trigger: [COPY TRIGGER SENTENCE]
End point: [COPY END POINT SENTENCE]
If/then rules: [PASTE RELEVANT RULES]
Exceptions: [PASTE RELEVANT EXCEPTIONS]
Data sources we currently use: [e.g. HubSpot, Airtable, Gmail, Stripe, Google Drive, Notion]

Constraints:
- Structure the brief as: Objective, Trigger, Steps to automate (numbered), Rules and logic, Exceptions, Data inputs and where they live, Expected output at each automated step, What a human still needs to do and when, Definition of success
- Write in plain English, no technical jargon
- Flag any step where the builder will need a login or API key with [CREDENTIALS NEEDED]
- Maximum 400 words

Every automation needs to know what to do when something goes wrong. I need to define the failure states for this process before the build starts.

Steps being automated: [PASTE THE [READY] STEPS FROM THE AUDIT]
Automation brief: [PASTE BRIEF FROM PREVIOUS PROMPT]

For each automated step, what could go wrong? Consider: missing data, wrong data format, a third-party tool being down, a rule condition not being met, the output not being created.

My best guess at failure scenarios: [e.g. 'The client does not fill in the budget field so the if/then rule cannot run', 'The email fails to send because the address has a typo', 'The Stripe webhook does not fire']

Constraints:
- For each failure scenario write: FAIL STATE: [what went wrong] triggers ACTION: [what the automation should do instead, e.g. pause and notify owner, use a default value, send to a holding queue]
- Every fail state must route to a named human owner if the automation cannot resolve it
- Include a fallback for the scenario where the automation platform itself goes offline
- End with a one-line definition of how a human will know the automation has silently failed

Using everything I have documented, write a complete standard operating procedure for this process.

Process name: [PROCESS NAME]
Trigger: [TRIGGER SENTENCE]
End point: [END POINT SENTENCE]
Clean flow: [PASTE CLEAN NUMBERED FLOW]
Rules: [PASTE IF/THEN RULES]
Exceptions: [PASTE EXCEPTIONS]
Failure states: [PASTE FAILURE STATES]

Constraints:
- Structure as: Title, Last Updated date [leave blank for me to fill], Owner [leave blank], Purpose (one sentence), Scope (one sentence on what this covers and what it does not), Prerequisites (what must be in place before step 1), Step-by-step instructions with owners, Decision rules, Exceptions, What to do if something goes wrong, Revision notes section at the bottom
- Each step must be written so someone with no previous context can follow it
- Include a 'Before you start' checklist of anything the person running this needs to have open or ready
- Plain language throughout
- Do not add steps or rules that are not in my source documents

I need a one-page quick-reference version of this SOP that a team member can keep open while they are doing the process without reading the full document.

Full SOP: [PASTE FULL SOP FROM PREVIOUS PROMPT]

Constraints:
- Maximum 150 words
- Include: trigger, step numbers and one-line action for each step, owner initials or role abbreviation in brackets, the three most common failure points and the immediate fix for each
- Format as a compact numbered list, no paragraphs
- End with: 'Stuck? Full SOP is at: [LINK PLACEHOLDER]' and 'Escalate to: [OWNER NAME PLACEHOLDER]'
- Remove any information that is not needed to run the process, not to understand it