How to Write Step-by-Step Instructions (That People Actually Follow)

To write step-by-step instructions people can actually follow: define the task and its end state, break the work into single actions, start every step with a verb, tell readers where to act before what to do, show the expected result after key steps, and add a screenshot for anything that happens on screen. Then test the draft on one real person before you publish.

That is the whole method in one paragraph. The rest of this guide unpacks each part, shows a real before-and-after rewrite, and gives you a template you can copy today.

Why most step-by-step instructions fail

Nobody reads instructions for fun. People open them mid-task, already slightly frustrated, looking for the one thing that unblocks them. That reading context explains almost every failure:

• Steps assume knowledge the reader does not have. The writer knows where the Settings menu is, so they skip it. The reader does not, so they stall on step 2.
• Multiple actions hide inside one step. "Configure your workspace and invite your team" is a project, not a step.
• There is no way to tell if you did it right. Without an expected result ("the status turns green"), a reader who made a mistake keeps going and fails four steps later, with no idea where things went wrong.
• The instructions describe the old version of the product. The button moved, the label changed, and now the reader trusts nothing else on the page.

Every rule below exists to prevent one of these failures.

Before you write a single step

Good instructions are mostly decided before the writing starts. Three things to lock down first:

Define the task and the end state. One task per document. "Set up two-factor authentication" is a task. "Manage your account security" is a topic, and topics belong in a how-to guide with a different structure. Write down what the reader will have when they finish: "Your account requires a code from your phone at every login."

Know your least experienced reader. Write for the person with the least context who will realistically do this task. If new hires will follow these instructions in week one, "SSH into the staging box" is not a step, it is a wall.

Do the task yourself, and record it. This is the single highest-leverage habit in instruction writing. Walk through the real workflow with a screen recording running. The recording catches everything memory smooths over: the confirmation dialog you dismiss without thinking, the loading state, the exact label on the button. Teams that work from a recording instead of memory produce instructions with far fewer missing steps, and the recording becomes raw material you can turn directly into a written guide with screenshots instead of a thing you watch once and delete.

8 rules for steps people can follow

1. One action per step

If a step contains "and" or "then," it is usually two steps. Splitting them costs you nothing and gives the reader a natural checkpoint after every action.

Instead of: "Open Settings, then go to the Members tab and click Invite." Write:

1. Open Settings.
2. Select the Members tab.
3. Click Invite.

2. Start every step with a verb

Imperative mood, present tense: click, select, paste, upload. It keeps steps short, scannable, and unambiguous about who does what. "The file should be uploaded" leaves the reader wondering by whom. "Upload the file" does not.

3. Say where before what

State the location first, then the action: "In the left sidebar, click Projects." Readers parse this in the order they need it. The reversed version ("Click Projects in the left sidebar") makes them hunt for a button before they know where to look.

4. Show the expected result

After any step where the screen changes meaningfully, tell the reader what they should see: "A confirmation banner appears at the top of the page." Expected results are how readers self-correct. Without them, a mistake at step 3 surfaces as a confusing failure at step 7.

5. Put warnings before the action, not after

If clicking Delete is irreversible, the warning has to come before the instruction to click it. A caution placed after the step is read after the damage. The convention technical writers use: Warning (safety or data loss) and Note (helpful context), always ahead of the step they apply to.

6. Keep it under about 12 steps, or split the task

Long procedures exhaust readers and hide their own structure. If your draft runs past roughly 12 steps, split it into stages with their own subheadings ("Part 1: Create the project," "Part 2: Configure access"). Each stage gets its own mini end-state, and readers get places to safely pause.

7. Name things exactly as the interface does

If the button says Sign up free, do not write "click Register." Match the label, the capitalization, and the wording. Any mismatch forces the reader to guess whether they are looking at the right thing, and guessing is where people abandon instructions.

8. Add a visual to every on-screen step

A screenshot with the relevant button highlighted answers "where is it?" instantly, in a way no sentence can. Instructions with visuals consistently outperform text-only versions on completion rate. The classic objection is that screenshots take too long to capture and crop, which is fair when you do it by hand. It stops being true when the screenshots are generated automatically from a recording of the task, which is how modern documentation teams keep visuals in every step without the production tax. For steps that benefit from motion, like a drag-and-drop, an annotated clip with automatic zoom-ins beats a static image.

A worked example: before and after

Here is a real instruction block the way it is usually written:

Adding your team Go to settings and find the members section where you can invite people. Enter their emails and they'll get an invite. Make sure they have the right permissions since admins can delete projects.

Four sentences, five hidden actions, a buried warning, no way to verify success. Here is the same task rewritten with the rules above:

Invite a teammate

You need an Admin role to invite members. When you finish, your teammate will receive an email invitation.

1. In the top-right corner, click Settings.
2. Select the Members tab.
3. Click Invite member. An invite form opens.
4. Enter your teammate's email address.
5. Warning: Admins can delete projects. Choose Member unless this person needs full control.
6. Select a role from the Role dropdown.
7. Click Send invite. The new member appears in the list with a "Pending" badge.

Your teammate now has an invitation email. It expires in 7 days.

Same information. One is a paragraph the reader has to decode; the other is a checklist they can execute.

A template you can copy

Every solid instruction document has the same skeleton. Steal this one:

# [Verb] + [the task]  (e.g., "Export your project as MP4")

**Who this is for:** [role or experience level]
**What you'll have at the end:** [the end state, one sentence]
**Before you start:** [prerequisites: access, tools, permissions]

## Steps

1. [Where], [action]. [Expected result if the screen changes.]
2. ...

## If something goes wrong

- [Most common error]: [fix]

**Done?** [How to confirm the end state, one line.]

If the procedure you are documenting is a recurring internal process rather than a one-off task, wrap this same skeleton in an SOP: our SOP-from-video playbook covers the extra fields (owner, review date, version) that make it audit-ready.

The fast way: record once, let AI write the first draft

Everything above describes the craft. Here is the shortcut that preserves it.

The slowest parts of instruction writing are not the thinking; they are the transcription and the screenshots. Doing the task while writing it down, capturing images, cropping them, and pasting them in order can turn a 4-minute task into a 90-minute documentation job.

The modern workflow inverts this. You record your screen once while doing the task, and AI turns the recording into numbered, step-by-step instructions with a screenshot already attached to each step. Vidocu does exactly this with any uploaded video: no browser extension, and it works on recordings you already have sitting in Loom or a shared drive. You then spend your time on the part that actually needs a human: checking labels, tightening verbs, adding warnings, and cutting steps your reader does not need. We walk through the full process in how to turn a screen recording into a step-by-step guide.

The same recording also produces subtitles, an AI voiceover, and translations, so one capture can cover the written instructions, the video tutorial, and the localized versions for teams that need both formats.

Test it on one person before you publish

The cheapest quality check in documentation: hand your draft to one person who has never done the task, and watch them follow it. Do not help. Every place they pause, scroll back, or ask a question is a defect in the instructions, not in the reader.

You are watching for four things:

1. Stalls: they cannot find what a step points to. Fix the location phrase or add a screenshot.
2. Backtracking: they realize a prerequisite too late. Move it to "Before you start."
3. Wrong turns: they do something the step did not intend. The step has two readings; rewrite it.
4. Doubt: they ask "did that work?" Add an expected result.

One test reader catches the large majority of follow-ability problems. Two catches nearly all of them.

Keep instructions alive

Instructions rot at the speed of your product's release cycle. A screenshot showing last quarter's UI quietly tells readers "this page is stale, trust nothing here." Three habits prevent that:

• Assign an owner and a review date to every document, the same way SOPs get owners.
• Re-verify after every release that touches a documented flow. Release notes are your trigger list.
• Make regeneration cheap. This is the practical argument for the record-once workflow: when a flow changes, you re-record two minutes of screen and regenerate the steps and screenshots, rather than rebuilding a document by hand. Technical writing teams use this to keep entire libraries current without a maintenance backlog.

FAQ

How many steps should step-by-step instructions have?

Keep a single procedure under about 12 steps. Past that point, readers lose their place and skip ahead. If the task genuinely needs more, split it into named parts of 5 to 10 steps each, with a short end-state line after each part so readers know they are still on track.

What tense and voice should instructions be written in?

Imperative mood, present tense, active voice: "Click Save," not "The Save button should be clicked." Start each step with the verb where possible. This is the convention used by the Microsoft Style Guide and virtually every professional documentation team, because it is the shortest unambiguous form.

What is the difference between step-by-step instructions, an SOP, and a how-to guide?

Step-by-step instructions are the numbered actions for completing one task. An SOP wraps instructions in process metadata (owner, version, review date, compliance context) for a recurring internal procedure. A how-to guide is a broader article that may explain concepts and cover variations around the task. The instructions are the core; the other two are packaging for different audiences.

What is the fastest way to add screenshots to instructions?

Record your screen once while performing the task, then use an AI documentation tool to generate the steps with screenshots automatically extracted from the recording. Vidocu does this from any uploaded video, with no browser extension, and lets you edit the generated steps before publishing. Capturing and cropping screenshots by hand is the slowest option and the first thing teams drop under deadline pressure.

Should instructions use numbered lists or bullet points?

Use numbers whenever order matters, which is almost always true for instructions. Numbers let readers keep their place, let testers report "I got stuck on step 4," and signal that skipping ahead has consequences. Save bullets for unordered content like prerequisites, options, or troubleshooting lists.

Write less, show more

The instructions people actually follow are rarely the most detailed ones. They are the ones where every step is a single verifiable action, every claim matches the interface, and every on-screen moment has a picture. Lock the task down before you write, follow the 8 rules, test on one person, and let a recording do the heavy lifting on screenshots and first drafts.

Ready to try the record-once workflow? Try Vidocu for free and turn your next screen recording into finished step-by-step instructions in about five minutes.