Getting Started with HelpMeTest: Your First Automated Test in 10 Minutes

Getting started with test automation is often more painful than the actual testing. You install Playwright, configure browsers, write selectors, deal with async timing, set up CI integration — before you have verified a single user flow.

HelpMeTest removes that setup overhead. You sign up, install the CLI, and describe what you want to test. The AI executes the test in a real browser and tells you what passed and what failed.

This guide walks through everything: signup, CLI installation, your first test, health monitoring, and CI integration.

Prerequisites

• A web application you want to test (any URL — local or production)
• Node.js 16+ installed (for the CLI)
• 10 minutes

That is all.

Step 1: Create Your Account

Go to helpmetest.com and sign up. The free plan gives you:

• 10 automated tests
• Unlimited health checks
• 5-minute monitoring intervals
• Email alerts
• CI/CD integration

No credit card required for the free plan.

After signing up, you will land on the HelpMeTest dashboard. Keep this tab open — you will come back to it to see test results.

Step 2: Install the CLI

npm install -g helpmetest

Verify the installation:

helpmetest --version

Authenticate with your account:

helpmetest login

This opens a browser window to complete OAuth authentication. After logging in, the CLI stores your credentials locally.

Step 3: Initialize Your Project

Navigate to your project directory and initialize HelpMeTest:

cd my-project
helpmetest init

This creates a .helpmetest/ directory with a default configuration:

# .helpmetest/config.yaml
baseUrl: https://your-app.example.com
project: my-project

Update baseUrl to your application's URL. This is the starting point for all tests.

Step 4: Write Your First Test

Create a test file. HelpMeTest tests are Robot Framework .robot files written in plain language:

mkdir tests
<span class="hljs-built_in">touch tests/smoke.robot

Open tests/smoke.robot and write your first test:

*** Settings ***
Library    Browser

*** Test Cases ***
Homepage Loads Successfully
    Go To    ${BASE_URL}
    Get Element    css=body
    Get Title    !=    ${EMPTY}

User Can Navigate To About Page
    Go To    ${BASE_URL}
    Click    text=About
    Get URL    contains    about

If your application has a login flow:

*** Settings ***
Library    Browser

*** Variables ***
${EMAIL}       testuser@example.com
${PASSWORD}    TestPassword123

*** Test Cases ***
User Can Log In
    Go To    ${BASE_URL}/login
    Fill Text    [name="email"]    ${EMAIL}
    Fill Text    [name="password"]    ${PASSWORD}
    Click    [type="submit"]
    Get Element    css=.dashboard-header
    Get URL    contains    dashboard

Save the file.

Step 5: Run Your First Test

helpmetest run tests/smoke.robot

HelpMeTest uploads the test to the cloud, executes it in a real browser, and streams the results back to your terminal:

Running smoke.robot...

  ✓ Homepage Loads Successfully (3.2s)
  ✓ User Can Navigate To About Page (4.1s)

2 tests, 2 passed, 0 failed

View detailed results: https://app.helpmetest.com/runs/abc123

Click the link to see screenshots, step-by-step logs, and any errors from the test run.

Step 6: Push Tests to Your Account

To make tests permanent — scheduled, monitored, and accessible from the dashboard:

helpmetest push tests/

This uploads all tests in the tests/ directory to your HelpMeTest account. After pushing, you can see and manage them in the dashboard at app.helpmetest.com.

Writing Better Tests

Use Descriptive Test Names

Test names become your documentation. Be specific about what scenario you are testing:

*** Test Cases ***
# Good: describes exactly what is being tested
Guest User Sees Login Button On Homepage
Logged-In User Sees Dashboard After Login
Invalid Email Shows Validation Error On Login Form

# Bad: too vague to be useful
Homepage Works
Login
Error State

Test Complete User Journeys

Individual page loads are too granular for E2E tests. Test complete workflows:

*** Test Cases ***
New User Can Complete Onboarding
    Go To    ${BASE_URL}/signup
    Fill Text    [name="name"]    Jane Smith
    Fill Text    [name="email"]    jane@example.com
    Fill Text    [name="password"]    SecurePass123
    Click    [data-testid="create-account"]
    Get Element    text=Welcome to the app
    Get URL    contains    onboarding
    Click    text=Skip for now
    Get URL    contains    dashboard

Existing User Can Update Profile
    # Log in first
    Go To    ${BASE_URL}/login
    Fill Text    [name="email"]    ${EMAIL}
    Fill Text    [name="password"]    ${PASSWORD}
    Click    [type="submit"]
    # Navigate to profile
    Click    [data-testid="user-menu"]
    Click    text=Profile Settings
    # Update display name
    Clear Text    [name="displayName"]
    Fill Text    [name="displayName"]    Jane Updated
    Click    [data-testid="save-profile"]
    Get Element    text=Profile saved

Reuse Setup with Keywords

If multiple tests need the same setup (like logging in), create a keyword:

*** Keywords ***
Log In
    [Arguments]    ${email}=${EMAIL}    ${password}=${PASSWORD}
    Go To    ${BASE_URL}/login
    Fill Text    [name="email"]    ${email}
    Fill Text    [name="password"]    ${password}
    Click    [type="submit"]
    Wait For Elements State    .dashboard-header    visible

*** Test Cases ***
Dashboard Shows User Name
    Log In
    Get Element    text=Welcome, Jane

User Can View Recent Orders
    Log In
    Click    text=Orders
    Get Element    .order-list

Admin User Can Access Settings
    Log In    email=admin@example.com    password=AdminPass
    Get Element    text=Admin Settings

Test Edge Cases

Beyond the happy path, test what happens when things go wrong:

*** Test Cases ***
Login Fails With Wrong Password
    Go To    ${BASE_URL}/login
    Fill Text    [name="email"]    user@example.com
    Fill Text    [name="password"]    wrongpassword
    Click    [type="submit"]
    Get Element    text=Invalid email or password
    Get URL    ==    ${BASE_URL}/login

Login Form Requires Email
    Go To    ${BASE_URL}/login
    Fill Text    [name="password"]    Password123
    Click    [type="submit"]
    Get Element    css=.field-error

Setting Up Health Checks

Health checks are different from tests. A test verifies a user workflow. A health check verifies your application is alive and responding at regular intervals.

Health checks are perfect for:

• Monitoring that your site is up
• Verifying your API returns expected responses
• Catching deployment failures
• Getting alerted if a service goes down

CLI Health Check

# Report a health check from any script or service
helpmetest health my-app 30s

Arguments:

• my-app — name of the health check (any string)
• 30s — grace period before alerting if no heartbeat received

Use this in your application's startup or readiness script:

#!/bin/bash
<span class="hljs-comment"># startup.sh

<span class="hljs-comment"># Start your application
npm start &

<span class="hljs-comment"># Wait for it to be ready
<span class="hljs-keyword">until curl -sf http://localhost:3000/health; <span class="hljs-keyword">do <span class="hljs-built_in">sleep 1; <span class="hljs-keyword">done

<span class="hljs-comment"># Report to HelpMeTest
helpmetest health my-app 5m

Monitoring a URL

For web application uptime monitoring:

# Monitor a URL every 5 minutes
helpmetest monitor https://your-app.example.com 200

This checks that the URL returns HTTP 200 at 5-minute intervals and sends email alerts if it goes down.

View all your health checks in the dashboard under Health Checks. Each check shows a timeline of recent status reports and any alerts triggered.

CI/CD Integration

Run your tests automatically on every PR and deployment by integrating with your CI/CD pipeline.

GitHub Actions

# .github/workflows/e2e-tests.yml
name: E2E Tests

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

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

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install HelpMeTest CLI
        run: npm install -g helpmetest

      - name: Run tests
        env:
          HELPMETEST_API_KEY: ${{ secrets.HELPMETEST_API_KEY }}
        run: helpmetest run tests/

      - name: Report deployment health
        if: github.ref == 'refs/heads/main'
        env:
          HELPMETEST_API_KEY: ${{ secrets.HELPMETEST_API_KEY }}
        run: helpmetest health production 30m

Setting up the API key:

1. In the HelpMeTest dashboard, go to Settings → API Tokens
2. Create a new token named "github-actions"
3. Add the token as HELPMETEST_API_KEY in your GitHub repository's secrets (Settings → Secrets → Actions)

Other CI Providers

The same pattern works for any CI provider:

# CircleCI
- run:
    name: Run E2E Tests
    command: |
      npm install -g helpmetest
      helpmetest run tests/
    environment:
      HELPMETEST_API_KEY: ${HELPMETEST_API_KEY}

# Shell script (any CI)
npm install -g helpmetest
<span class="hljs-built_in">export HELPMETEST_API_KEY=<span class="hljs-string">"your-token-here"
helpmetest run tests/

Viewing Results

After each test run, you can view detailed results in the dashboard:

Test Runs — every execution of your tests, with pass/fail status, timing, and artifacts

Screenshots — HelpMeTest captures screenshots at key steps and on failure, so you can see exactly what the browser saw

Step Logs — each test step with timing, the action taken, and any errors

History — track test pass rates over time and identify flaky tests

Click any failed test to see the screenshot at the point of failure and the full step-by-step log. This is usually enough to diagnose the issue without running the test again.

Common Questions When Getting Started

My test keeps failing on a selector — how do I fix it?

Use descriptive selectors that reflect the element's purpose rather than its structure:

# Fragile: breaks when CSS changes
Click    css=.btn-primary.checkout-step-3

# Better: uses semantic purpose
Click    [data-testid="checkout-btn"]

# Also good: uses visible text
Click    text=Complete Purchase

# Also good: uses aria role
Click    [role="button"][name="Complete Purchase"]

If your application does not have data-testid attributes on key elements, add them — it takes five minutes and makes every testing tool more reliable.

My login test fails intermittently

This is usually a timing issue — the test tries to interact with the page before the login redirect completes. Add a wait for the expected post-login state:

Click    [type="submit"]
Wait For Elements State    .dashboard-header    visible    timeout=10s

I want to test with different users

Use variables for credentials and override them per test:

*** Variables ***
${ADMIN_EMAIL}       admin@example.com
${ADMIN_PASS}        AdminPass123
${USER_EMAIL}        user@example.com
${USER_PASS}         UserPass123

*** Test Cases ***
Admin Can View All Users
    Log In    ${ADMIN_EMAIL}    ${ADMIN_PASS}
    Click    text=Users
    Get Element    css=.user-list

Regular User Cannot See Admin Panel
    Log In    ${USER_EMAIL}    ${USER_PASS}
    Get Element Count    text=Admin Panel    ==    0

How do I test behind authentication?

HelpMeTest supports browser state persistence. Log in once, save the browser state, and reuse it in subsequent tests:

*** Test Cases ***
Save Auth State
    Go To    ${BASE_URL}/login
    Fill Text    [name="email"]    ${EMAIL}
    Fill Text    [name="password"]    ${PASSWORD}
    Click    [type="submit"]
    Save Storage State    auth.json

Tests That Need Auth
    [Setup]    Restore Storage State    auth.json
    Go To    ${BASE_URL}/dashboard
    # Already logged in — auth state loaded from file
    Get Element    text=Welcome

This prevents re-running the login flow for every test, making your suite faster and your tests more focused.

Next Steps

You have your first tests running. Here is where to go next:

Expand coverage: Write E2E tests for your 5-10 most critical user flows. Checkout, signup, core workflow, account settings.

Set up health monitoring: Add health checks for your production and staging environments. Get notified immediately when something goes down.

Integrate CI/CD: Add the helpmetest run step to your deployment pipeline. Catch issues before they reach production.

Explore visual testing: Add Check For Visual Flaws to your tests to verify UI appearance, not just functionality:

Go To    ${BASE_URL}/checkout
Check For Visual Flaws    css=.checkout-form

Review results regularly: Make checking test results part of your deployment workflow. A test that passes 95% of the time is a flaky test that needs investigation.

The goal is a test suite that gives you confidence before every deployment. Start small — even five well-written E2E tests covering your core flows will catch the majority of regressions that would otherwise reach production.

Getting Help

• Documentation: docs.helpmetest.com — full CLI reference, keyword library, and integration guides
• Dashboard: app.helpmetest.com — view tests, results, and health checks
• Support: Support is available via email on all plans

Start testing — your first test takes less time to write than diagnosing a production bug.