Atlas: The Living Blueprint.

Picture a single, living blueprint that covers your entire web app, built automatically. Every screen, every state, and every user journey - all in one place.

That's Atlas. It ensures every test plan, user story, and bug report is 100% specific to your app, not a generic guesswork, or AI slop.

Structural Knowledge

Understanding the "Places" within your application.

The Site Map

Your app's structural blueprint, built and updated automatically. Every time an Exploration runs, Atlas maps every screen and state (like 'Admin Dashboard' vs. 'Logged-out User') into an easy-to-understand hierarchy.

This isn't just a map; it's your command center.

Organised Bugs

Bugs are no longer lost in a flat list. Atlas automatically analyzes and catalogs every issue—from the DOM, console, network, or screenshots—and pins it directly to the screen and state where it was found.

Visual Regressions

Stop drowning in false positives. Our context-aware engine compares new screenshots against an "approved baseline" for every screen-state to spot material regressions.

You can even upload a Figma design as your baseline to compare your plan directly against the final build.

Smart Knowledge Base

A flat folder of PRDs isn't useful. Atlas lets you attach your docs—PRDs, specs, user stories—directly to the screen or feature they relate to.

When the AI writes a test, it retrieves the exact, relevant context for that specific part of your app.

Behavioural Knowledge

Understanding the "Pathways" through your app.

Visualize User Journeys

Stop thinking of tests as a flat list of files. The Behaviour Map renders your entire SmartTest suite as an interactive journey tree.

See your coverage, understand test flow, and pinpoint exactly where screen transitions (like 'Login' -> 'Dashboard') happen.

Expand the Test Suite

Find the "unhappy paths" you missed. Right-click any node in a journey and ask the AI to "Expand Test Suite."

The agent will navigate to that step, analyze the page for unexplored branches, and automatically generate a new test plan to cover them.

Run Hyper-Focused Explorations

Don't run your entire suite just to check one small change. Click on any node in a journey and select "Run ExploreChimp."

The agent will use that test as its guide, focusing its powerful analysis on one specific pathway.

FAQs

How can I visualize my entire web app's test coverage?

TestChimp Atlas automatically builds a visual map of every screen and state visited during your test runs. This gives you a complete picture of what your site looks like, including a clear picture of your test coverage.

How can I find design or UX flaws in my app automatically?

TestChimp “sees” your app. By analyzing screenshots of every state, the AI detects visual inconsistencies, layout breaks, and even accessibility issues (like poor contrast). It highlights these design flaws, acting as an automated design review that catches UX bugs functional tests often miss.

How can I quickly expand my automated test suite?

Instead of writing scripts by hand, use Atlas’s “Expand Test Suite” feature. It automatically navigates your app, finding “unhappy paths” and edge cases, and generating robust test plans for you instantly.

How can I automate visual testing for pages with dynamic content?

Atlas uses context-aware visual regression. It learns which parts of your page change frequently (like timestamps, user data, or ads) and intelligently ignores them, focusing strict comparison only on structural elements and layout.

Which screen is slowing down my app?

Atlas identifies screens with abnormal load times or heavy asset requests. These performance anomalies are flagged on the node itself, helping you correlate specific UI states with performance degradation.

Our agent captures and analyzes deep browser performance metrics such as:

CLS (Cumulative Layout Shift) – where janky content shifts occur
INP (Interaction to Next Paint) – slow button responses, input lag
Long Tasks – heavy JS blocking the main thread
Large or unoptimized resource loads
TBT (Total Blocking Time)
Memory heap usage and leaks
Network timing and caching misses

How can I generate test cases directly from my requirements docs?

Atlas allows you to upload PRDs and user stories directly into its Knowledge Base. The AI then uses this specific context to generate tests that validate your actual business logic and requirements, rather than just generic interactions.

How can I see which user journeys are missing from my tests?

Visual observability is key. Atlas converts your text-based test files into a visual “Behaviour Map,” showing you exactly which paths are covered and highlighting the branches or transitions you haven’t tested yet.

How can I prevent hallucinations when using AI to exapnd my test suite?

Generic LLMs guess because they lack ground truth. TestChimp Atlas provides the ground truth (the exact structure, selectors, and valid states of your app) constraining the AI to reality so generated code always compiles.

How do I test AI-native applications where my content is dynamic?

AI apps are often non-deterministic. Atlas’s semantic understanding of “valid states” versus “regressions” allows it to test dynamic, AI-driven interfaces more effectively than rigid, selector-based scripts.<

How do I identify the bug hotspots in my application?

Atlas transforms your bug logs into a visual map. Instead of sifting through list-based reports, Atlas pins every console error, failed test, and network issue directly to the specific screen where it occurred on the Site Map. This allows you to instantly spot which features require immediate attention.

How do I know if my site has logic gaps?

The Behaviour Map reveals the actual paths taken through your app, highlighting “dead ends” and circular loops where users (or the AI) get stuck. Additionally, the “Expand Test Suite” feature actively hunts for “unhappy paths” – edge cases and logical breaks that aren’t covered by your happy-path tests.

How can I trace a regression back to its root cause?

Atlas provides “Time-Travel” context. When a bug is pinned, you don’t just get the error; you get the full journey trace, the visual snapshot of the failure, and the console/network state at that exact moment. This allows developers to reproduce the exact conditions of the failure instantly.

How do I determine which parts of my app are untested?

Visual coverage is the only true coverage. The Site Map shows your entire application structure, while the Behaviour Map overlays the paths your tests actually cover. Any screen or state that appears in the Site Map but is not traversed in the Behaviour Map represents a gap in your testing strategy.