Smarter Playwright Debugging with TestDino

Debugging is the worst part of testing. You know it. We know it.

A test fails in CI. You open the logs. Then the trace viewer . Then you hunt for screenshots. Twenty minutes later, you're still piecing together what went wrong, and your PR is blocked.

Industry studies show developers can spend nearly half their day just trying to fix bugs. That’s a huge amount of time not spent building new things. When debugging is slow, it blocks your entire team. So, we decided to create a better way.

TestDino, It’s a reporting tool that makes Playwright debugging simple. It brings all your traces , logs, and visual evidence into one place and uses AI and trend analysis to point you to the fix. It just plugs into the workflow you already have.

Good debugging isn’t just about fixing code. It’s about keeping your whole engineering team moving forward. When it’s slow, it creates bottlenecks that hurt everyone.

Slow debugging kills productivity.

A developer has to stop what they’re doing, switch gears, and start a long investigation. They might spend hours wrestling with CI logs or trying to catch a random, flaky failure. This is an invisible tax on your team’s time.

It adds up fast. This is time not spent building features. It’s a direct hit to productivity. As these small delays add up, pull requests stay open longer, releases get pushed back, and your team gets stuck resolving bugs and managing test failures instead of creating value.

When you can debug things quickly, everything gets better. It’s that simple.

A fast diagnosis means a fast fix. Fewer bugs make it into production. Developers get clear feedback from their tests right away, which helps them stay in the flow. This removes a major blocker and makes your entire delivery pipeline smoother and more reliable.

To debug fast, you need the right evidence. The Playwright test runner provides several features to help you run and debug Playwright tests efficiently.

Playwright gives you several types of artifacts that tell the full story of a test run. Running and debugging tests effectively requires understanding the available artifacts and tools.

A Playwright trace is the flight recorder for your test. It’s a complete, step-by-step recording of everything that happened. It saves DOM snapshots, screenshots, network calls, and console messages for every single action.

When a test fails, you just open the trace and go back in time and pinpoint exactly what the browser was doing. It’s the single best piece of evidence for understanding: What was the state of your application when it failed?

Visuals show you what the user would have seen.

A screenshot taken at the moment of failure can instantly explain why a test broke. Was there an unexpected pop-up? Did the page render incorrectly?

Videos record the entire session. They're perfect for understanding the sequence of events that led to the problem, especially for complex user flows.

Visual comparison is like an automated "spot the difference" game for your UI. You give it a "baseline" screenshot of how a page should look. Then, every time you run your tests, it takes a new screenshot and compares it to the baseline.

If even one pixel is different, the test fails. It’s a powerful way to catch visual bugs, like layout shifts or style changes, that normal tests would miss.

Playwright gives you some good tools for debugging on your own machine. They work well, but they can be clumsy when a test only fails in CI.

The Playwright Inspector tool is a GUI utility that opens a dedicated Playwright inspector window for interactive debugging. It’s great for writing new tests because you can pause execution at any test line, check selectors, and see what’s happening live.

The Inspector also acts as a recording tool, allowing you to generate a recorded script by capturing user interactions. Additionally, it helps you accurately identify the target element for your selectors. You can start it with a simple command:

The Playwright Trace Viewer is a GUI tool for analyzing test execution using your trace.zip files. First, you have to tell Playwright to save traces in your playwright.config.ts file. For CI, trace: ‘on-first-retry’ is a good setting because it only saves traces for tests that fail.

Traces are stored in the test results directory after test execution. You can find the trace files there for further analysis.

After you get a trace file from your CI run, you open it from your command line.

The viewer is great, but it makes you download the file from your CI server first. That extra step takes time.

CI is where things get tough.

CI debugging with standard Playwright tools feels like solving a puzzle blindfolded. Your failing tests run in headless mode on remote servers, often with different specs than your local machine.

When a test fails in CI, you can’t use the interactive Inspector. The trace files and screenshots are zipped up as artifacts on a remote server. You have to find the right CI job, download the files, unzip them, and then use a specific test command to open the trace viewer locally.

There’s a big gap between the failure and the clues. This manual process is slow and pulls you out of your workflow.

TestDino is a reporting and analytics platform built to fix this broken workflow. It centralizes all your test artifacts and uses AI to give you actionable insights, making debug sessions fast and simple for any Playwright project.

The TestDino Dashboard is your home base. The TestDino Dashboard adapts to your role.

It gives different views to QA, developers, and managers, so everyone sees what they need. You can also configure projects for different environments and testing needs, making it easy to manage and switch between various setups. The system automatically flags tests that fail intermittently, showing you their flaky rate percentage.

You get a clean look at pass/fail trends, a list of your flaky tests , and AI insights that point out the big problems. No more digging through CI logs.

Finally! This is where you will find answers to all your issues. Click on any failed test, and TestDino’s Test Case View opens everything you need in a single pane. No downloading files. No switching between tools.

The real magic happens when you open the built-in trace viewer from Playwright. Without leaving TestDino, you can inspect the timeline, explore network calls, and examine DOM snapshots.

In the trace viewer, you can use the elements panel to manually inspect and select DOM elements, and the playwright object is available in the console to debug selectors and actions. Every piece of evidence is right there, connected and correlated.

Reviewing visual bugs can be a pain.

If your tests already use Playwright's powerful visual snapshots (like toHaveScreenshot), TestDino makes your life easier. We integrate that feature directly into our UI. No more downloading reports just to see what changed.

Our Visual Comparison tool shows you the expected, actual, and difference between images side-by-side, right in the Test Cases view.

The History tab gives a branch-specific breakdown of the test performance with their failure and flay rates. You can see if a test started failing after a specific commit, whether it's flaky on certain branches, or if it's been consistently broken for days.

TestDino doesn’t just show you data. It helps you understand it and act on it. TestDino can also integrate with the default Playwright HTML report to provide enhanced analysis and insights.

Every test failure gets automatically analyzed and categorized. The AI examines the error message, stack trace, and failure patterns to classify each issue:

Actual Bug: Consistent failures indicating real product defects

UI Change: Failures due to modified interfaces or selectors

Flaky Test: Intermittent failures from timing or environment issues

Miscellaneous: Infrastructure or configuration problems

The system groups similar failures together. Each classification comes with a confidence score and suggested next steps.

The Analytics dashboards show you the big picture. You can track:

The Specs Explorer provides detailed analytics for all your test files, showing every test file’s metrics in one table: execution count, failure rate, flaky rate, average duration, and last execution time. Sort by any column to find your slowest specs or most unreliable tests instantly.

TestDino integrates directly where your team works.

For , the TestDino GitHub App posts AI-powered summaries on every pull request. The comment includes pass/fail status, failure categories, and direct links to detailed reports. No need to leave GitHub to understand why tests failed.

The Slack integration sends real-time notifications to your team channels. Each alert includes:

From TestDino, you can create Jira or Linear tickets with one click. The ticket automatically includes the failure details, stack trace, and a link back to the test run. No copy-pasting required.

Getting started with TestDino takes about five minutes. First, ensure your playwright.config.ts includes the standard reporters:

That's it. TestDino now captures every test run automatically. When a test fails, just open your TestDino dashboard, find the run, and start investigating with all the evidence already collected and organized.

Here’s how to debug a failed test in three simple steps with TestDino.

Go to the Test Runs page. You’ll see a list of your latest CI builds. Just filter for "Failed" runs. The red flags and AI labels will show you exactly what needs attention.

Click a failed run. This takes you to the Summary view, where failures are grouped by cause, like "Timeout Issues." Click on any failed test to see the detailed Test Case view. Now you can check the trace, read the logs, and watch the video.

Check the AI Insights tab for a quick diagnosis. The AI will tell you the likely cause and show you if it’s a new or old problem. This helps you decide what to do next.

Don't waste time rerunning your whole test suite for a small fix. TestDino lets you rerun only the tests that failed. This can cut your CI wait time from many minutes down to just a few seconds.

It works by remembering the results from a full run. Then, a simple command tells Playwright to only run the tests that failed last time. It works even on fresh CI machines.

Here’s a quick example for GitHub Actions:

This setup gives you a super-fast way to check your fixes. You can find more details in our CI setup guide.

Good Playwright debug habits are key to shipping great software fast. Playwright’s own tools are fine for your local machine, but they just aren't built for the speed of modern CI/CD.

No more manual log correlation. No more guessing why tests fail in CI but pass locally. TestDino takes the guesswork out of debugging.

Your tests are trying to tell you something. TestDino makes sure you hear it loud and clear.