Reflect.io Getting Started Guide: No-Code Web Testing for Teams

Most E2E testing tools require engineers. You need someone who knows Playwright or Cypress to write and maintain tests. Reflect.io removes that requirement — anyone on your team can record web tests by interacting with the browser, then run those tests automatically in CI/CD.

This guide covers getting started with Reflect.io from account setup to your first automated test run.

What Is Reflect.io?

Reflect is a no-code web testing platform built for teams who want automated browser tests without writing code. You:

1. Record tests by clicking through your application in a Chrome extension
2. Enhance with AI — Reflect uses AI to suggest assertions and make tests more robust
3. Run tests in CI/CD or on a schedule
4. Maintain tests with Reflect's AI-assisted healing when the UI changes

Unlike screen recording tools, Reflect captures your interactions as logical test steps (click this button, fill this field, assert this text), not fragile pixel-based recordings. The tests understand what you're doing, not just where you clicked.

Who Is Reflect For?

Reflect's sweet spot:

• QA engineers who understand testing but don't code
• Product managers and designers who want to verify their flows work
• Developers who want fast test creation without framework boilerplate
• Small teams without dedicated SDET resources

If your team has senior engineers who want fine-grained control, Playwright or Cypress may be better. Reflect optimizes for speed and accessibility over maximum flexibility.

Getting Started

Create an Account

Sign up at reflect.run. Reflect offers a free tier for getting started.

Install the Chrome Extension

1. Go to the Chrome Web Store and search for "Reflect"
2. Install the Reflect Test Recorder extension
3. Sign in to the extension with your Reflect account

The extension is how you record tests. It observes your browser interactions and converts them into test steps.

Create a Project

In the Reflect dashboard:

1. Click New Project
2. Enter your project name (typically your application or product name)
3. Enter your application's base URL (e.g., https://yourapp.com)
4. Save

Recording Your First Test

Start Recording

1. Navigate to your application in Chrome
2. Click the Reflect extension icon
3. Click Start Recording
4. Perform the user flow you want to test (login, add to cart, submit a form, etc.)
5. Click Stop Recording

Reflect captures each interaction:

• Page navigations
• Clicks (with the element identified by text, role, or label)
• Form inputs
• Keyboard actions

Reviewing and Editing the Recording

After stopping, Reflect shows the captured steps:

1. Navigate to https://yourapp.com/login
2. Click "Email" input
3. Type "test@example.com"
4. Click "Password" input  
5. Type "••••••••••"
6. Click "Sign In" button
7. [AI suggestion] Assert "Welcome, Test User" is visible
8. [AI suggestion] Assert URL contains "/dashboard"

The AI automatically suggests assertions based on what it sees after your interactions. Accept or reject each suggestion.

Edit steps by clicking on them:

• Change the element selector if Reflect picked the wrong one
• Adjust input values
• Add or remove assertions
• Reorder steps

Adding Assertions Manually

Beyond AI suggestions, add assertions yourself:

1. In the test editor, click + Add Step
2. Choose Assertion
3. Select assertion type:
   • Text exists — verify text appears on the page
   • Element visible — element with certain attributes is visible
   • URL contains — current URL matches a pattern
   • Element count — N elements matching a selector exist
4. Configure and save

Using Variables

For tests that need to handle dynamic content (generated order IDs, timestamps):

1. Add a Extract Variable step
2. Specify the element to extract from
3. Use {{variableName}} in subsequent steps

Example: extract the order ID from a confirmation page, then use it to navigate to the order detail page.

Running Tests

Manual Run from Dashboard

1. Open any test in the Reflect dashboard
2. Click Run Test
3. Select the environment (base URL)
4. Reflect runs the test in its cloud browser
5. View results including video playback and step-by-step status

Tests run in headless Chrome in Reflect's cloud infrastructure.

Scheduled Runs

Set tests to run automatically:

1. Open a test (or test suite)
2. Click Scheduling
3. Set frequency: every 15 minutes, hourly, daily, etc.
4. Configure notifications (email or Slack on failure)

Scheduled runs are useful for monitoring critical flows continuously.

Organizing Tests with Suites

Group related tests into suites for organized execution:

1. Click New Suite
2. Name it (e.g., "Checkout Flow", "User Registration", "Smoke Tests")
3. Add tests to the suite
4. Run the suite to execute all tests sequentially

Suite runs create a single report with pass/fail for each test in the suite.

Configuring Suite Execution Order

Tests in a suite run sequentially by default. Use ordering when test state matters — log in once at the start of the suite, then run dependent tests.

Enable Shared Session in suite settings to maintain browser state between tests within the suite.

CI/CD Integration

GitHub Actions

name: E2E Tests with Reflect

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  e2e:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Reflect tests
        run: |
          curl -X POST https://api.reflect.run/v1/runs \
            -H "Authorization: Bearer ${{ secrets.REFLECT_API_KEY }}" \
            -H "Content-Type: application/json" \
            -d '{
              "suiteId": "${{ vars.REFLECT_SUITE_ID }}",
              "overrides": {
                "baseUrl": "${{ env.PREVIEW_URL }}"
              }
            }'

      - name: Wait for results
        run: |
          # Poll for completion and check results
          # See Reflect API documentation for details

Getting Your API Key

1. In Reflect dashboard: Settings → API
2. Generate an API key
3. Add as REFLECT_API_KEY secret in your repository

Setting Environment URLs

Pass different base URLs to run the same tests against staging and production:

{
  "suiteId": "your-suite-id",
  "overrides": {
    "baseUrl": "https://staging.yourapp.com"
  }
}

The tests recorded against production run against staging without modification.

Handling Authentication in Tests

Recording Authenticated Tests

For tests that require login:

Option 1: Include login in the test Start your recording from the login page and record the login flow as the first steps. Every test starts by logging in.

Option 2: Use saved sessions

1. Record a login test
2. Mark it as a Session Setup test in suite settings
3. Reflect reuses the logged-in session for subsequent tests in the suite

Option 2 is faster — you log in once, not before every test.

Sensitive Data (Passwords, API Keys)

Use Reflect's Environment Variables for sensitive data:

1. Settings → Environment Variables
2. Add TEST_PASSWORD=yourpassword
3. In your test steps, use {{TEST_PASSWORD}} instead of the actual value

Reflect masks these values in recordings and logs.

AI-Assisted Test Maintenance

When your UI changes, tests that reference changed elements will fail. Reflect's AI maintenance suggests fixes:

1. Run a test after a UI change
2. If it fails, Reflect analyzes the failure
3. Reflect suggests which element likely corresponds to the old one
4. Review and accept the suggestion

For minor UI changes (button text changed, element moved), the suggestion is usually correct. For major redesigns, you may need to re-record the affected steps.

Test Results and Reporting

Test Run Report

Each test run generates a report:

• Overall pass/fail status
• Duration
• Step-by-step results with screenshots
• Video playback of the full run
• Failure details for failed steps

Suite Reports

Suite runs show:

• Pass rate (X/Y tests passed)
• Individual test results
• Duration breakdown

Slack and Email Notifications

Configure notifications in Settings → Notifications:

• Run results on every run
• Alerts only on failures
• Daily/weekly summary emails

Limitations of No-Code Testing

Understanding what Reflect doesn't cover well sets expectations:

Complex assertions: Verifying calculated values, complex data structures, or business logic often requires custom code. Reflect's assertions cover visible text and element presence, not deep data validation.

API interactions: Reflect tests browser interactions. Testing API responses directly requires a different tool.

Non-browser interactions: Testing mobile apps, desktop applications, or non-HTTP protocols requires other tools.

High-volume data testing: Data-driven tests with hundreds of input combinations are better suited for code-based frameworks.

For a complete testing strategy, Reflect works alongside API testing tools (Postman, REST Assured) and potentially a code-based E2E framework for complex scenarios.

Reflect vs Competitors

Reflect and Octomind are the closest comparison. Reflect is more record-based (you interact, it captures); Octomind is more goal-based (you describe, AI does it).

Summary

Reflect lowers the barrier to E2E testing by removing the code requirement. QA engineers, product managers, and developers with no test automation experience can create and maintain tests using the browser extension. CI/CD integration, scheduled runs, and AI-assisted maintenance make it a complete no-code testing solution for web applications.

Continuous Production Monitoring

Reflect.io tests run when you schedule them. HelpMeTest monitors your production app continuously — tests run every 5 minutes, 24/7, with immediate alerts when something breaks.

Write monitoring tests in plain English. No code, no extension.

Start free →