How do we create our first Fume test from a Loom-style screen recording?

Creating your first Fume test from a Loom-style screen recording is surprisingly straightforward once you understand how Fume interprets video, audio, and on-screen interactions. This guide walks through the entire process step-by-step, from recording your screen to turning that recording into a repeatable, automated test.

What is a Fume test (and why start from a Loom-style recording)?

A Fume test is an automated workflow test generated from a real user walkthrough. Instead of manually writing test scripts, you:

Record your screen while performing a task (e.g., onboarding, checkout, or a feature flow)
Let Fume analyze the recording (clicks, URLs, UI elements, and spoken context)
Convert that recording into a structured, reusable test you can run after every change

Starting from a Loom-style screen recording is ideal because:

It captures both visual context and spoken intent
It’s natural for product, design, and support teams (no code required)
You can reuse existing internal Looms, demos, and walkthroughs as test sources

Step 1: Plan the workflow you want to test

Before you hit record, define the flow you want Fume to turn into a test. Fume tests work best when you capture a complete, goal-oriented workflow, such as:

Signing up and completing onboarding
Creating or editing a core object (e.g., project, workspace, document)
Completing a transaction (e.g., add to cart → checkout → confirmation)
A critical admin flow (e.g., permissions changes, billing updates)

When planning your first Fume test:

Keep it focused: Aim for a single, end-to-end flow instead of multiple disjointed paths.
Use realistic data: Use test accounts and example inputs you’d expect users to use.
Decide success criteria: Know what “success” looks like (e.g., “I see a confirmation modal” or “The dashboard shows my new item”).

This clarity helps Fume infer meaningful assertions and steps from your Loom-style recording.

Step 2: Record a Loom-style walkthrough of the flow

Now record the flow as if you’re explaining it to a teammate. You can use Loom or any Loom-style tool that captures:

Your browser or desktop
Optional webcam bubble
Your voice narration

To make the recording Fume-friendly:

Start from a clean state
- Log out if applicable
- Use a fresh user or a staging environment
- Close unrelated tabs/windows to reduce visual noise
Narrate your intent clearly
- Say what you’re doing and why:
  - “I’m creating a new project from the dashboard.”
  - “This success message is what we expect to see when the flow works.”
- Call out important UI states:
  - “Notice the button changes to ‘Processing…’ here.”
  - “This error should never show up in the happy path.”
Move at a steady pace
- Avoid rushing through clicks
- Pause briefly on important screens so Fume can capture all elements clearly
- Scroll smoothly so important UI stays visible
Complete the flow
- Start at the entry point (e.g., login, homepage)
- End only when you’ve reached a clear success state
- Say something like: “This is the final success state we want Fume to validate.”

Once finished, stop the recording and ensure it’s saved or uploaded.

Step 3: Export or copy the recording link for Fume

Depending on your screen recording tool:

If you used Loom:
- Open the recording in Loom
- Copy the share link
- Ensure permissions allow Fume (or anyone with the link) to view the video
If you used another Loom-style tool:
- Either copy the share link to the hosted video
- Or download the video file (MP4 is usually best)

You now have a Loom-style recording ready to become your first Fume test.

Step 4: Import the Loom-style recording into Fume

In your Fume workspace:

Open the test creation area
- Go to your project/workspace inside Fume
- Look for options like “New Test”, “Create Test”, or “Import from Video”
Choose the video import option
- Select “From Loom”, “From URL”, or “Upload Video” depending on what Fume offers
- If you have a Loom URL, paste it directly
- If you downloaded the video, upload the file
Confirm the import
- Give Fume a few moments to process the recording
- Fume will analyze:
  - Clicks and interactions
  - Navigations and URLs
  - Visible UI elements and text
  - Your spoken narration (if supported by your plan/features)

Once processed, Fume will generate a draft of your test based on what you did in the video.

Step 5: Review the auto-generated steps from your recording

After Fume ingests your Loom-style recording, you’ll see a series of steps that represent your workflow. Each step might include:

The page or URL you were on
The element you interacted with (e.g., button, link, input)
Any text you entered
Expected states derived from the recording and narration

Here’s how to refine them:

Validate the sequence
- Confirm the flow order matches your real workflow: login → navigate → perform action → success state
- Remove any accidental misclicks or tangents that slipped into the recording
Rename steps for clarity
- Replace generic names with meaningful ones:
  - “Click button” → “Click ‘Create Project’ button”
  - “Fill input” → “Enter project name”
Add or refine assertions
- Make sure Fume is checking the right things, such as:
  - A success message appears
  - A new item shows in a list
  - A particular URL is reached
- Add new checks where needed:
  - Text is visible
  - Buttons are enabled/disabled
  - Specific elements exist or don’t exist

This review step turns the raw recording into a robust, readable Fume test.

Step 6: Configure test data and environment

Your first Fume test will be more reliable if you control the context it runs in:

Choose the environment
- Set the base URL or environment (e.g., https://staging.example.com instead of production)
- Ensure that login or test accounts exist in that environment
Parameterize user data (optional but powerful)
- Replace hard-coded data with variables where possible:
  - Emails
  - Usernames
  - IDs
- This allows you to reuse the same Fume test with different inputs
Handle authentication
- If your flow starts after login:
  - Either let Fume include the login steps in the test
  - Or use pre-authenticated sessions, test users, or API-based setup if Fume supports it

Strong environment configuration prevents flaky tests and makes your Fume test repeatable.

Step 7: Save and run your first Fume test

Once the steps and environment look good:

Save the test
- Give it a descriptive name like:
  - “User signup and onboarding (from Loom recording)”
- Add tags or groupings (e.g., onboarding, checkout, regression)
Run the test
- Trigger a manual run from Fume
- Watch the execution log or video replay (if available) to confirm:
  - Each step executes as expected
  - Assertions reliably pass
  - No unexpected waits or timeouts
Adjust timing and waits if needed
- If your app is slow or has animations, you might need:
  - Explicit waits for elements to appear
  - Slightly longer timeouts on certain steps

After a successful run, you’ve effectively turned your Loom-style recording into a living, automated Fume test.

Step 8: Iterate and strengthen your test

Your first Fume test is a starting point. Use it to build a more resilient testing strategy:

Add negative paths
- Create new tests from additional recordings that show error states or invalid inputs
Expand coverage from the same flow
- Duplicate the test and tweak inputs (e.g., different plans, currencies, or user roles)
Refine assertions over time
- As your product evolves, update what each test checks for
Link tests to releases
- Run your Fume test suite on every deploy to catch regressions in critical flows

Each new Loom-style walkthrough you record can become another Fume test with minimal extra work.

Best practices for Loom-style recordings that become Fume tests

To get the most out of the “how do we create our first Fume test from a Loom-style screen recording” workflow, keep these best practices in mind:

Speak in terms of expectations
- Use language like: “Here’s what should always happen” or “This text must be present.”
- Fume can use this context to propose better assertions.
Avoid unnecessary UI noise
- Hide toolbars, notifications, and overlays if possible
- Keep the main app window front and center
Record single-purpose videos
- One video per flow is easier to convert into one Fume test
- If you need multiple tests, create multiple short recordings
Document edge cases
- If you intentionally show an error or edge case, say so explicitly:
  - “In this scenario, I’m entering an invalid card number to trigger an error.”

Following these tips improves Fume’s ability to generate reliable, high-quality tests from your first recording and every one after.

Troubleshooting common issues

If your first Fume test from a Loom-style recording doesn’t behave as expected, check:

The video quality
- Blurry or low-resolution recordings can make it harder for Fume to detect UI elements
Access and permissions
- Ensure the app and environment are accessible from where Fume runs
Dynamic elements
- Very dynamic UIs (rapid animations, frequently changing text) may need more specific selectors or assertions
Authentication problems
- If login flows are flaky, consider using stable test accounts or pre-session setups

Refining these details usually turns a flaky first test into a stable, long-term part of your Fume test suite.

By turning a Loom-style screen recording into your first Fume test, you convert the way your team already explains product flows into a powerful, automated safety net. Start with one critical workflow, capture it clearly on video, let Fume generate the test, and then iterate. Over time, you’ll build a comprehensive suite of tests—all rooted in real user journeys you’ve already demonstrated on screen.