How to Build Software Simulations – Show Me, Try Me, Test Me

New software goes live in three weeks, and two hundred people need to know how to use it on day one. The vendor's help pages are written for administrators, and the classroom option means pulling people off the floor for half a day, so the request comes to you: "Can we just make a simulation?" You can, but the real question is how to make one people actually learn from. How do you build software simulation training that gets people ready for the real system?

Effective software simulation training uses three modes for each task: Show Me, where learners watch the task performed with narration or captions; Try Me, where they perform it themselves with hints and feedback; and Test Me, where they do it alone and are scored. Build it by first breaking the job into real tasks, recording each task in a clean practice environment with realistic data, and then producing the three modes from that recording. Most authoring tools, including Storyline and Captivate, can generate these modes from a single screen capture. Keep each simulation short and focused on one task, so it's easy to learn from and easy to update when the software changes.

What Are Show Me, Try Me and Test Me?

They're a sequence that moves learners from watching to doing to demonstrating competence. The idea is old and sound, because you observe the task, practice it with support and then perform it independently.

Different tools use different names: Storyline calls them View, Try and Test modes, while Captivate calls them demonstration, training and assessment. The underlying concept is identical. If you're still choosing a tool for this work, my Storyline vs Captivate comparison looks at which one handles simulations better.

Step 1: Plan the Tasks Before You Record

Start with the job rather than the software, and ask what people actually do in the system during a typical week. You don't need every menu and button, only the genuine tasks, such as creating an order, updating a record, approving a request or running a report.

For each task, write down:

• The exact steps, in order, including the fields and values to enter.
• The common mistakes people make.
• The starting point (which screen the learner begins on) and the end point.
• Any decision points, such as "if the customer is a new account, do this."

Walk through each task with a subject matter expert (SME) who uses the system daily, because training environments and real workflows often differ, and you want to teach the real one.

Step 2: Set Up a Clean Recording Environment

A messy recording creates hours of cleanup, so complete these steps before you press record:

1. Use a training or test environment, not production, so you're not creating real records.
2. Use realistic but fake data. No real customer names, account numbers or personal details.
3. Close notifications, extra browser tabs and anything that could pop up.
4. Set the screen or browser window to a consistent size that fits your course.
5. Use a clean browser profile without personal bookmarks or extensions showing.
6. Practice the task a few times so your clicks are confident and direct.

Pick your recording size carefully. A huge monitor at full resolution makes everything tiny once it's scaled into a course. Recording just the application window, at a size close to your course's size, keeps text readable.

Step 3: Record Slowly and Deliberately

Click slowly, pausing briefly after each click so the screen settles, and type at a steady pace. Most tools capture each click as a separate step, so smooth, deliberate actions produce clean steps that are easy to edit.

Record each task separately, because a single long recording of five tasks is difficult to edit and harder to update. Short recordings give you short, focused simulations that learners can locate and repeat whenever they need them.

Step 4: Build the Show Me Mode

Show Me should feel like sitting beside a helpful coworker, so keep narration or captions brief and focused on the reason behind each step, not just the action. "Click Save" is obvious from the screen, while "Save now, because the next screen locks the order" is genuinely useful.

Highlight where the action happens with a subtle box or zoom. Keep the pace steady, and give learners controls to pause, replay and progress at their own speed.

Step 5: Build the Try Me Mode

Try Me is where most of the learning happens, because the learner clicks and types in the simulated screens. When they click the correct spot, the simulation advances, and when they click the wrong spot, they receive a hint.

Good Try Me design follows a few rules:

• Give a short instruction for each step, like "Enter the customer's postal code."
• Let learners try twice before showing the answer.
• Make hints specific: "The Customer tab is at the top of the window."
• Accept reasonable variations in typed text, such as upper or lower case, where the real system does.
• Don't punish exploration. Wrong clicks are part of learning here.

Step 6: Build the Test Me Mode

In Test Me, the instructions disappear or shrink to a task goal, such as "Create a new order for this customer." Learners complete it unaided. The simulation counts correct steps and attempts, then reports a score to your learning management system (LMS).

Decide in advance what counts as passing. Should one wrong click fail the entire task? Usually not, so a sensible approach allows a small number of attempts per step and requires the task to be completed correctly. Confirm with whoever owns the training records how they want results reported.

How Do You Keep Simulations Current When the Software Changes?

Software changes all the time, and screenshots go stale fast, so plan for maintenance from day one:

• Keep simulations short, so a change affects one small file instead of a giant one.
• Keep your task scripts and recording settings, so re-recording is quick.
• Ask the software team to tell you when screens or workflows change.
• Review each simulation on a schedule, like every quarter, and after every major release.

When only a few screens change, you can often replace just those steps rather than re-recording the whole task. Your authoring tool's guide, such as the Adobe Captivate user guide, will show how to swap individual captured slides.

Common Mistakes That Make Simulations Frustrating

Most complaints about software simulations come from a short list of recurring problems, so watch for these during your review:

• Click areas that are too small or slightly off, so a correct click counts as wrong.
• Only one accepted path when the real software allows several, such as a menu and a keyboard shortcut.
• Text that's too small to read because the recording was scaled down.
• Instructions that describe the screen instead of the task.
• Simulations that run for fifteen minutes without a break or a clear finish.

Have two or three real users test each simulation before launch, ideally people who haven't seen the new system, and observe where they hesitate. Every pause marks a spot where a hint, a clearer instruction or a larger click area would help.

Also check accessibility. Simulations rely heavily on precise mouse clicks, which can shut out keyboard and screen reader users. Provide an accessible alternative, such as a narrated demo with a detailed text walkthrough, for anyone who can't use the click-based version.

Should You Always Build All Three Modes?

No, because the effort should match the risk. For a simple, low-risk task that people perform once a year, a short Show Me with a printable job aid may be sufficient. For a complex, high-stakes task, such as processing payments or entering medical data, build all three modes and require Test Me for completion.

Sometimes a simple screen recording is the better choice. If learners just need to see a process once, a short narrated video can be faster to produce and easier to update. The same judgment applies to video in eLearning generally: use it where watching is enough, and save interaction for the tasks where practice earns its extra effort.

Software Simulation Training That Works on Day One

Strong software simulation training follows a simple path: show the task, let learners practice it with help, then let them prove they can do it alone. Plan around real tasks, record cleanly in a safe environment with fake data, and keep every simulation short and focused.

Choose the one task people will perform most often on day one. Build its Show Me, Try Me and Test Me, review it with a few real users, and correct whatever confuses them, because once that first simulation works, the rest of the library develops much faster.

← All articles