> ## Documentation Index
> Fetch the complete documentation index at: https://docs.testsprite.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Quickstart
> Walk through your first UI project end-to-end — from project creation to a passing browser test — in about 10 minutes.
By the end of this guide you'll have a UI project that's been explored, planned, generated as Playwright code, and run against your live app, with a recorded video for every test. No code on your side.
**Doing API testing instead?** See the [API Quickstart](/web-portal/core/api/quickstart) for the backend-flavored walkthrough.
## Step 1: Project Setup & PRD Upload
From the dashboard, click Create Tests. The first screen asks for two things only: a **project name** and your **PRD** (or any product-spec document — markdown, PDF, plain text all work).
**Uploading a PRD is the single biggest lever on plan quality.** With a PRD, plans reflect what your product is *supposed to do*. Without one, plans rely only on what TestSprite can see by clicking around your live app — useful, but missing intent. Skipping the PRD upload is fine for a quick demo; for any real coverage, upload one.
## Step 2: Feature & Use-Case Extraction
If you uploaded a PRD, TestSprite analyzes it and shows the **Use Cases & Features** screen with a flow graph of every feature it identified and the use cases under each. Stages while it's working: *Reading your documentation → Identifying key features → Mapping use cases*. A toast confirms the count when it's done (e.g. "Found 12 features and 47 use cases").
This feature map is what grounds everything downstream — exploration targets these use cases, plan generation scopes test cases to them, and the report attributes coverage back to them. Click Re-extract to redo the analysis on the same PRD (e.g. after editing the file). Otherwise continue.
If you skipped the PRD upload, this step is bypassed and the wizard goes straight to configuration.
## Step 3: Choose Test Type and Configure
Pick the test type tab — Frontend (URLs) for this UI walkthrough — then provide your starting URL, test account, and any extra testing instructions.
| Field | What to provide |
| :------------------------------------ | :------------------------------------------------------------------------------- |
| Application URL | The live URL TestSprite will explore (staging or local with a tunnel) |
| Authentication | Test-account credentials TestSprite uses to log in |
| Extra testing instructions | Free-form hints — e.g. *"avoid the help center"*, *"focus on the checkout flow"* |
Provide a long-lived **test account** with permissions across the surface you want covered. Exploration and runs both use real credentials; using a dedicated account keeps your real users' data clean.
## Step 4: Wait for Feature Exploration *(Beta)*
TestSprite walks your live app feature by feature, targeting the use cases from your feature map. You watch a live preview as it runs.
Per-feature status: Exploring while it's running, then Done, Failed, or Blocked when it finishes. You can retry individual features or update credentials without re-running everything.
When you're satisfied, click Continue to test plan.
Free plan: **10 features lifetime** for exploration. Pro plans: unlimited.
## Step 5: Review and Adjust the Plan
TestSprite drafts a customized test plan grounded in what was observed. Each row has a clear description explaining its purpose.
Use Select All to toggle the whole batch. Untick anything irrelevant, edit descriptions in natural language to refine focus, then click Generate Tests.
**Don't be precious about pruning.** Selecting all is usually right on a first run for full coverage. The high-leverage cases tend to be 60% of what's there; pruning the rest makes runs faster but doesn't change correctness.
## Step 6: Watch Tests Generate and Run
TestSprite converts the approved plan into Playwright code per test case, then executes each test in our cloud sandbox. Tests stream into the project view as they finish.
Each row surfaces one of: Pending, Running, Pass, Failed, Blocked.
## Step 7: Replay Step-by-Step
Click any test row to open its detail page. The right pane plays the **recorded video** of the run; the **Steps** panel inside the **Overview** tab lists every action with a clickable HTML snapshot per step.
For failures, the **Error / Trace / Fix** tabs surface the Playwright error, raw stack trace, and an AI-authored cause-and-fix suggestion.
Deeper tour of the per-step replay view
## Step 8: Refine and Rerun
To iterate on a test, open its detail page and use the Chat tab — describe what to fix in natural language. TestSprite either tweaks the assertions in place or regenerates the test.
To re-execute, click Run (or Save & Run if you have unsaved edits) and confirm in the **Rerun this test** dialog. Pro plans get the **Auto-heal on UI drift** toggle there, which absorbs UI changes that don't actually break the flow.
Every refinement path in detail
Recover UI tests when the page changed but the flow is fine
## The Final Report
Once the run finishes, the **Test Report** tab summarizes pass / fail / blocked counts, highlights failures with cause-and-fix suggestions, and links into per-test detail. This is what you'll share with the team.
## Where to Go Next
Deep dive on the exploration phase
The mechanics of plan review
Project-level video gallery of every recording
Run on a cadence to catch regressions