Revyl provides multiple step types to build comprehensive test flows. Each step type serves a specific purpose and can be combined to create complex test scenarios.
💡 Quick Reference: Click the Help button (?) in the test editor to see the Block Types Guide:
Step Categories
Steps are organized into three main categories:
- AI-Powered Steps - Natural language instructions powered by AI
- Control Flow Steps - Conditional logic and loops
- Manual Steps - Direct control actions
AI-Powered Steps
⚡ Instruction
Natural language actions that AI executes automatically.
The Instruction step is the most powerful and flexible step type. Write what you want to do in plain English, and the AI will determine and execute the necessary actions.
When to use:
- Complex multi-step interactions
- Form filling
- Navigation flows
- Any action you can describe in natural language
Example instructions:
Tap on the "Add Note" button
Log in with email: [email protected] and password: test123
Navigate to Settings and enable Dark Mode
Fill out the contact form with name: John Doe, email: [email protected]
- Be specific about what to do
- Include exact text for buttons or fields when possible
- Break very complex actions into multiple instruction steps
- Use variables for dynamic data:
Enter {{username}} in the username field
✅ Validation
Verify conditions and assert expected behavior.
Validation steps check that your app is in the correct state. They fail if the condition isn’t met, helping you catch bugs.
When to use:
- Verify text is visible
- Check element states (enabled, disabled, visible)
- Confirm navigation occurred correctly
- Assert expected data is displayed
Example validations:
Check that "Note Editor" screen is visible
Verify that the submit button is disabled
Confirm the success message "Order placed" appears
Ensure the total price shows "$99.99"
- One check per validation step
- Be explicit about what you’re verifying
- Use specific text or values when possible
- Keep validations simple and focused
Extract data from the screen and save it to variables.
Extraction steps pull information from your app and store it in variables for use in later steps.
When to use:
- Capture dynamic data (order numbers, prices, etc.)
- Store values for later verification
- Get data to use in subsequent actions
Configuration:
- What to extract: Describe the data you want to capture
- Variable name: Where to store it (use in later steps with
{{variableName}})
Example extractions:
Extract: "Get the order number from the confirmation screen"
Variable: orderNumber
Extract: "Get the product price from the details page"
Variable: productPrice
Instruction: "Search for order {{orderNumber}}"
Validation: "Verify the cart shows price {{productPrice}}"
- Use descriptive variable names
- Extract one value at a time
- Be specific about where the data is located
Control Flow Steps
🔀 If / Else (Conditional)
Execute different steps based on a condition.
The If step creates branching logic. Based on whether a condition is true or false, different steps execute.
Structure:
- Condition: Natural language check
- Then branch: Steps to run if condition is true
- Else branch: Steps to run if condition is false
When to use:
- Handle optional UI elements
- Different flows for different user states
- Gracefully handle variations
Example:
Condition: "Check if the user is logged in"
Then: Navigate to dashboard
Else: Log in with test credentials
- Keep conditions simple and clear
- Nest conditionals sparingly (prefer multiple top-level ifs)
- Always handle both branches
🔁 While Loop
Repeat steps while a condition is true.
The While step continues executing its inner steps as long as a condition remains true.
Structure:
- Condition: Natural language check evaluated each iteration
- Body: Steps to repeat
When to use:
- Scroll through lists
- Wait for dynamic content
- Process multiple items
- Retry until success
Example:
Condition: "More items are visible to load"
Body:
- Scroll down
- Wait 1 second
- Always ensure the condition will eventually become false
- Include safeguards to prevent infinite loops (if they run for long enough they will timeout, but will still waste time)
Best practices:
- Keep loop bodies simple
- Ensure the loop will terminate
- Use for repetitive actions, not one-time checks
💻 Code Execution
Run custom scripts in a secure sandbox during test execution.
The Code Execution step allows you to run Python, JavaScript, TypeScript, or Bash scripts in a secure remote sandbox. Use it to:
- Hit your backend APIs - Make HTTP requests to verify data, trigger actions, or set up test state
- Generate dynamic data - Create random emails, unique IDs, timestamps, or any test data you need
- Save values to variables - Store results for use in later test steps
- Complex data manipulation - Parse JSON, validate responses, perform calculations
Configuration:
- Select or create a script - Choose from your saved scripts or create a new one
- Variable name (optional) - Store the script output in a variable for use in later steps
Supported Runtimes:
| Runtime | Use Case |
|---|
| Python | API calls with requests library, data processing |
| JavaScript | Node.js scripts, fetch API calls |
| TypeScript | Type-safe scripts |
| Bash | Shell commands, simple operations |
- Keep scripts focused - one task per script
- Use print or console.log for the final output you want to save
- Handle errors gracefully - failed scripts will fail the test step
- Store reusable scripts for common operations
Scripts run in an isolated sandbox with network access. They cannot interact with the mobile device directly - use them for backend operations and data generation.
Manual Steps
👋 Wait
Pause test execution for a specified duration.
When to use:
- Allow animations to complete
- Wait for slow network requests
- Give time for UI updates
Configuration:
Example:
⚠️ Note: Prefer validations over fixed waits when possible. AI steps have built-in smart waiting.
🔄 Open App
Launch or relaunch the installed app OR open a system app.
When you add an Open App step, a dropdown appears next to it allowing you to choose:
- Installed App (default) - Opens your test app (the build attached to the test)
- System Apps - Pre-installed apps like Settings, Photos, Contacts, Safari, etc.
Available System Apps:
| iOS | Android |
|---|
| Settings | Settings |
| Safari | Chrome |
| Photos | Photos |
| Contacts | Contacts |
| Messages | Messages |
| Maps | Maps |
| Calendar | Calendar |
| Files | Files |
| Reminders | Clock |
| - | Phone |
| - | Camera |
- Open system apps to test integrations (e.g., share to Photos, check Contacts)
- Reset app state by relaunching the installed app
- Test cross-app workflows
Your installed app is automatically opened at test start. You only need
this step if you want to relaunch the app mid-test or switch to a system app.
❌ Kill Installed App
Terminate the installed application completely.
This force-closes the app process. The app will cold-start when reopened.
When to use:
- Test app behavior after force-close
- Reset app state completely
- Clear app memory
- Test state persistence after termination
🏠 Go Home
Return to the device home screen.
This navigates to the home screen while keeping the app running in the background.
When to use:
- Test background/foreground transitions
- Multitasking scenarios
- Simulate user leaving the app temporarily
Kill App vs Go Home:
- Kill App: Fully terminates the app. Cold-start on reopen.
- Go Home: App stays in background. Resumes where you left off.
📍 Set Location
Set the device’s GPS location to specific coordinates.
Configuration:
- Latitude: GPS latitude coordinate (e.g.,
37.7749)
- Longitude: GPS longitude coordinate (e.g.,
-122.4194)
When to use:
- Test location-based features
- Simulate user being at a specific place
- Test geofencing or location permissions
Example locations:
| Location | Latitude | Longitude |
|---|
| San Francisco | 37.7749 | -122.4194 |
| New York | 40.7128 | -74.0060 |
| London | 51.5074 | -0.1278 |
| Tokyo | 35.6762 | 139.6503 |
Location can also be set at the workflow or test level as an initial starting location.
Step-level set_location overrides these defaults.
🧭 Navigate (Deep Link)
Open a deep link URL in your mobile app.
When to use:
- Navigate directly to a specific screen
- Test deep link handling
- Skip navigation steps to reach a particular state
Configuration:
- Deep link URL (e.g.,
myapp://settings/profile)
Example:
Navigate to: myapp://checkout/cart
Deep links must be configured in your app. Consult your app’s documentation
for available deep link schemes.
AI-Powered Device Actions
The Instruction step can also trigger device-level actions when you describe them naturally. The AI will recognize these and execute the appropriate action:
| Instruction | Action Triggered |
|---|
| ”Open the Photos app” | Opens the Photos system app |
| ”Open the Settings app” | Opens the Settings system app |
| ”Go to the home screen” | Returns to home screen (GO_HOME) |
| “Close the app” or “Kill the app” | Terminates the app (KILL_APP) |
| “Go to https://example.com” | Opens the URL (NAVIGATE) |
| “Zoom in on the map” | Pinch zoom in (PINCH) |
| “Zoom out of the image” | Pinch zoom out (PINCH) |
Instruction: "Open the Contacts app and find John Smith"
Instruction: "Go to the home screen"
Instruction: "Navigate to myapp://profile/settings"
Instruction: "Zoom in on the map to see more detail"
Adding Steps to Your Test
Quick Add
Click any step type button at the bottom of the editor to add it to your test immediately.
Drag & Drop
Reorder steps by clicking the drag handle (⋮⋮) on the left side and dragging to a new position. You can also drag from the bottom toolbar.
Best Practices
Choosing the Right Step Type
- Start with AI steps - Instruction, Validation, Extraction handle 90% of testing needs
- Add control flow sparingly - Only when you need branching or loops
- Avoid manual steps - Use only when necessary (fixed waits, app lifecycle)
Writing Effective Steps
✅ Good:
Instruction: "Tap on the 'Add to Cart' button"
Validation: "Verify the cart count shows '1'"
Instruction: "Do something with the button"
Validation: "Check if it worked"
Step Ordering
- Setup - Open app, log in
- Actions - Instructions to perform the test
- Assertions - Validations to verify behavior
- Cleanup - Close app, log out (optional)
Related Pages
Need help? Contact [email protected] 
