At the Top of the Pyramid: Playwright Testing at Scale

This ad is not shown to multipass and full ticket holders
React Summit US
React Summit US 2025
November 18 - 21, 2025
New York, US & Online
The biggest React conference in the US
Learn More
In partnership with Focus Reactive
Upcoming event
React Summit US 2025
React Summit US 2025
November 18 - 21, 2025. New York, US & Online
Learn more
Bookmark
Rate this content

Discover how we tackled the common challenges of a large E2E test suite and made our React codebase easier to refactor.

In the past year, we went from zero to 20,000 lines of Playwright tests, pushing its capabilities beyond basic end-to-end testing. This talk will explore the challenges we encountered as we scaled our Playwright setup and how we solved them, thanks to the robust ecosystem and team creativity.

The talk covers:

- Testing approaches and where common tools fit on the testing pyramid

- Challenges scaling E2E test suites: performance, flakiness, ownership, mocking and more

- How we solved these challenges to unblock refactoring a large React codebase

- Advanced Playwright tips and tricks

This talk has been presented at React Summit 2025, check out the latest edition of this React Conference.

FAQ

Playwright comes with a feature called Code Jam, which allows users to generate tests by simply clicking around in their browser. This feature creates functioning test code without the need for manual coding.

The talk mentions several testing strategies including the testing pyramid, reverse testing pyramid, testing ice cream cone, testing diamond, testing trophy, testing Dorito, and the testing mushroom. Each strategy emphasizes different aspects of testing, such as end-to-end, integration, and unit testing.

Playwright offers a best-in-class developer experience with features like a built-in debugger, VS Code extension, screenshots, reports, videos, and Trace Viewer. The Trace Viewer provides detailed information on test failures, including test steps, screenshots, errors, console logs, and network requests.

The Playwright network cache plugin allows tests to run faster by storing results of slow operations in cache and reusing them. This approach reduces test running time without maintaining mocks, offering a performance improvement while maintaining test integrity.

To reduce flakiness, follow Playwright's best practices to handle browser latencies and other issues. If server downtime causes test failures, those are expected in end-to-end tests and should be addressed by the backend team.

Playwright supports full parallel mode testing with configurable numbers of workers. Increasing workers allows more tests to run simultaneously, reducing overall test time. The number of workers can be adjusted based on the available CI/CD resources.

Implementing automated tests led to stable, readable tests that catch real bugs, improved code base organization, accelerated TypeScript migration, and facilitated easier feature development.

Installing the ESLint plugin for Playwright helps identify and fix common issues in test code, ensuring best practices are followed and reducing random test failures.

Playwright is a popular end-to-end testing tool that is easy to install and provides default browsers, configuration, example tests, and GitHub Action. It supports features like visual comparisons, snapshots, API testing, and more, offering a comprehensive solution for testing modern web applications.

The testing mushroom is a metaphorical strategy focusing on end-to-end testing to meet regulation requirements. It serves as a safety net for refactoring and introducing integration and unit tests, adapting as more is learned about the project.

Kate Marshalkina
Kate Marshalkina
25 min
13 Jun, 2025

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Introduction to Playwright as an end-to-end testing tool with easy installation and code generation. Features include visual comparisons, API testing, and best-in-class developer experience. Playwright offers AI capabilities, practical testing tools, and innovative testing strategies. Challenges in testing specialized domains are addressed, along with best practices for test dependencies and readability. Optimizing testing efficiency through parallelism, code organization, and network cache usage. The discussion also covers test performance enhancement, managing workers, optimizing dependencies, stability of test functions, and the use of Playwright sharding in CI/CD runs.

1. Exploring Playwright Testing Tool

Short description:

Introduction to Playwright as an end-to-end testing tool with easy installation and code generation. Features include visual comparisons, API testing, and best-in-class developer experience with debugging and Trace Viewer.

We've wipe-coded our application real quick, or we inherited a legacy large codebase. How do we test it? Is testing easy in 2025? That's a tricky question. And before I jump in, a quick check. Can you please raise your hand if you worked with Playwright before? Great. It's like almost half of the audience, maybe even more.

For the rest of us, a brief introduction to Playwright. Playwright is a very popular end-to-end testing tool. It's very easy to install. With just one command, you get the default browsers, configuration, example test, and even GitHub Action. It comes with Code Jam. It allows you to generate tests without writing any code at all. You basically click around in your browser, on your website, and you get back a simple, basic, but functioning test code.

When you have more advanced test scenarios, Playwright has all the features. Visual comparisons, snapshots, API testing, Chrome extensions testing, component testing. If for some reason you don't like TypeScript, there are other options as well. When tests inevitably fail, Playwright has best-in-class developer experience. It has a built-in debugger, VS Code extension, screenshots, reports, videos, and my favorite, the Trace Viewer.

2. Playwright AI Features and Practical Testing Tools

Short description:

Overview of Playwright's features including Trace Viewer for test failures, AI capabilities like AI prompt and Playwright MCP server, and practical testing tools with auto-weighting, assertions, and community support.

The Trace Viewer is a one-stop shop for any test failure. It provides all the test steps along with screenshots, errors, console logs, network requests, and basically everything that we usually check in the browser dev tools. Of course, the mandatory AI slide. Playwright has a couple of nice AI features, copy error as AI prompt and Playwright MCP server to allow large language models communicate with Playwright APIs. Let me give you a quick demo. Here, I'm asking Courser to write a quick conference review draft for my blog. Courser asks Playwright MCP to fetch a conference agenda, and Playwright returns an accessibility snapshot of the page, something that is very easy for Courser to digest.

And as a result, Courser generates a good first draft, even for the talks that were not presented yet. Pretty cool, but of course, Playwright's main goal is to help us write reliable, predictable tests, and Playwright is a very practical tool. It comes with auto-weighting and web-first assertions. Authentication and multi-user comes out of the box, the same with parallelism and sharding. Finally, it has great community that provides community plugins, best practices, and integrations with other tools. All in all, Playwright checks all the boxes to make testing easy.

3. Challenges in Testing Specialized Domains

Short description:

Joining a healthcare analytics team facing challenges in testing, dealing with specialized domains, legacy systems, and complex UI components.

At least this is what I thought when a year ago, I joined a team at ATO, a healthcare analytics company that offers a range of products for data scientists in the healthcare sector. It's a highly specialized and regulated business domain that probably has an acronym for pretty much everything in the world. Let me give you an example. In the International Classification of Diseases, that's a real thing, there is a code, W6162XD, that means, it literally means, struck by a duck, subsequent encounter. And in such a specialized business domain, our team was asked to cover all the major features with automated tests for regulation purposes.

The scope included 64 epics of tests. I still remember this number. For a non-professional like me, the UI looked like gazillion checkboxes, acronyms, tables with random numbers all around, powered by five-year-old React application and ten-year-old Java backend. Java had its own story going from monolith to microservices, then back, leaving us with a bunch of legacy outdated APIs, but that's for another time. For now, let's focus on React. As the product was evolving, some of the components have grown over a thousand lines of code with those huge use effects, with missing dependencies, and dependency array, and all that stuff.

React version 17, most of the code untyped. ESLint and Prettier got lost during cloud migration. And before we move on, I just wanted to mention that this is not an uncommon situation for growing businesses that focus on building new features. Now, having that said, our first reaction to this project can be summarized by a quote from my teammate. This code is impossible to test. Or, speaking scientific language, R45.4, irritability and anger. Challenge was not accepted. With all those excuses running in my head, no, it's not my job, even a junior developer can do that, even AI can do that, and after five hours of me prompting chatgpt, stupid AI, it will never take my job, okay, I'll write the test, at least tell me what kind of test should I write, where do I start? We needed a testing strategy.

4. Innovative Testing Mushroom Strategy

Short description:

Introduction to various testing strategies like the testing pyramid, diamond, trophy, and Dorito leading to the innovative testing mushroom approach for end-to-end testing.

Now it's time for a brief theoretical block. Probably the most popular testing strategy out there is the testing pyramid. It promotes breaking software into smaller testable units. It's not our case, to be honest.

The other option is to put the pyramid upside down to get the reverse testing pyramid. If we put a bit of ice cream on top, then we get the testing ice cream cone, the default testing strategy for many companies. Not that tasty. Most of the testing is manual, and only some of that gets automated.

Another option is the testing diamond, and puts main focus on the integration tests. Another evolution of the testing diamond that is more popular in the front-end community is the testing trophy by Kent C. Dots. It clarifies what different types of tests mean in the context of the modern JavaScript ecosystem and also makes static checks such as slint and TypeScript more explicit.

Not everyone knows, but Kent's favorite strategy is the testing Dorito by Tim Meyers. Let me read it for you from top to bottom. Tests I plan to write. Tests I start writing. Tests I delete because I think they're stupid, and they can take a lot of time and they are not worth. Finally, tests! And the testing Dorito is a good reminder that theory and practice don't always have a perfect match.

So, without further ado, please welcome brand-new testing strategy, the testing mushroom. The cup of the mushroom is all about end-to-end testing. It clears regulation requirements and also helps us build a safety net so that we can start refactoring and introducing integration and unit tests. The testing mushroom is a living organism, so it's expected to change its shape once we learn more.

Great, we've got our strategy, so it's time to execute. The whole team sat down to write as many tests as possible, as fast as possible. And a month later... It was a disaster. It didn't work. The more tests we were writing, the more of them were failing, with all the random reasons and it was impossible to figure out what was going on. It was time for an emergency action. Namely, written documentation.

5. Best Practices and Test Dependencies

Short description:

Dealing with best practices and challenges in utilizing the Playwright API, including handling test dependencies and ensuring correct testing procedures.

At least the best practices part. Apparently, we were misusing the Playwright API. And here I have a couple of examples for you. The line at the top is the wrong way to check the welcome text on screen. And the line below is the right way to do that. Both work, it's just the first one sometimes randomly fails. And to be honest, the difference is subtle. Especially when you review thousands of lines of test code.

Luckily, there is a simple solution. We installed ESLint plugin Playwright. It fixed all the issues and also helped us learn what was the right way to use Playwright. Great, with that, we continued. And two months into the project, we realized we were behind schedule. So we had to ask our colleagues from other teams for help. This is when we faced our next challenge.

Test dependencies. As you remember, we are dealing with a quite complex business domain. A typical user journey can take several minutes before you achieve some meaningful result. And for a developer, it's tempting to reuse results from previous tests to build new tests on top of that. Unfortunately, it breaks completely test retries and makes local debugging practically impossible. You never know in which order and which tests to run in order to reproduce the issue.

6. Isolating Tests and Enhancing Readability

Short description:

Following best practices by isolating tests, running them in parallel, and enhancing test readability using Allure Reports in Playwright.

Now, once again, we decided to follow best practices. And one of them says, make tests as isolated as possible. Well, easy to say, we had to enforce it with fully parallel mode and increase the number of workers to three to actually run the tests in parallel. That revealed a few issues that we sorted. And with that, finally, we agreed. Our tests became much more stable, and they started catching real bugs, like that one in the top right corner.

Let's actually see what's wrong with it. Okay, that's my test. I can see immediately what's the issue. It's one of the backend APIs not returning the right response. So I'm pushing it to the backend team. The backend team opens it, apparently in the dark mode, and can't understand anything, just like you probably, because it's too small. So they push it back to us, and we push it back to them, and so on and so forth.

If I zoom out a little bit, this is how the failed test looks in the testing report. It contains all the test steps, screenshots, videos, test retries, tags, history, and all that comes from Allure Reports. Allure Reports is an open-source cross-language, cross-framework tool for building beautiful test reports so that even non-technical users can figure out what's going on in the test. And as usual, it's very easy to configure it with Playwright.

7. Optimizing Testing Efficiency

Short description:

Organizing code using page object model, integrating StepDecorator for logical steps, and accelerating test speed for efficient deployment pipelines.

In testing, there's a common pattern, page object model, where you organize your code in screens or pages. For example, here I have a login page class, and it contains all actions that you can perform on that screen or page. Login, logout, password reset, et cetera. We already had our code organized this way. And apparently, we were just one step away from making our reports as readable.

And when I say one step, I literally mean it with StepDecorator. StepDecorator groups lower-level Playwright actions into higher-level steps, logical steps that you can understand. It doesn't come out of the box, but there's documentation, how you can configure it for your needs. With that, our test reports became much more readable, even for our lovely backend team.

Great, with that, we're on the finish line when our platform engineering team reached out with a much bigger problem. Yes, our tests were green. Yes, they were stable, but they were super slow. They could block the deployment pipeline for an hour or two, and it was not acceptable. To be honest, we never focused on speed. We had other priorities.

8. Efficient Test Speed Optimization

Short description:

Optimizing test speed by running in parallel mode, utilizing Playwright network cache plugin for efficient test execution.

Yes, they were stable, but they were super slow. They could block the deployment pipeline for an hour or two, and it was not acceptable. To be honest, we never focused on speed. So as a reminder, we're running tests in full parallel mode and free workers. With just one configuration change, we went from 51 minutes to 17 minutes. We increased the number of workers, allowing more tests to run in parallel. End-to-end tests compared to integration tests usually run faster due to skipping or mocking expensive operations.

In Playwright, there's a network API for intercepting HTTP requests, but some find working without mocks more efficient. The Playwright network cache plugin offers a way to gain performance improvement without maintaining mocks. By caching responses, subsequent tests can reuse the stored results, saving time. This approach may not be a pure end-to-end test, but it significantly optimizes test running time. The testing mushroom analogy is used to illustrate the testing strategy employed, emphasizing efficiency over traditional methods.

9. Enhancing Test Performance with Playwright

Short description:

Avoiding mocks for improved performance using Playwright network cache plugin.

In Playwright, we have a network API for intercepting HTTP requests. But personally, I'm not a huge fan of this approach. On one project, we mocked all the HTTP requests. Our tests were super fast, super green, but they never caught a single bug. Instead, we were constantly regenerating and updating the mocks. Not super cool. Could we gain similar performance improvement, but without actually maintaining mocks? Working without mocks, as I call it.

This is exactly what Playwright network cache plugin offers. Let me show you an example. Imagine we have five slow tests. Each starts with performing some slow operation, let's say opening a test project. With Playwright network cache, the first test will perform the operation, doesn't matter if you get or post multiple requests, or just one, and will store the result in cache. All the other tests will reuse that cache as mocks. In our case, we actually had 200 tests like that and we got back 10 minutes of test running time. That's insane.

Now, if you think it's cheating, you're not wrong, because it's no longer a pure end-to-end test. That's why in the testing mushroom, our integration tests sit inside the mushroom cup. And I could talk more and more about the testing mushroom, because it's just a lot of fun, but honestly, I made it up completely for the purposes of this talk, to illustrate the approach that we took for this particular project. And your approach will be different. I hope the testing mushroom inspires you to explore the different shapes and strategies out there and find what works for you and makes testing, if not easier, then at least more fun.

QnA

Testing Evolution and Code Enhancement

Short description:

Reflecting on test stability, code upgrades, and enhanced development through testing strategies.

With that, let me recap. We wrote all the tests. Mission complete. They are stable and readable. They catch real bugs. They run in full parallel mode. Great job to the team.

But there is something else that I didn't mention, an unexpected side effect. Today, one year later, we have React and other major libraries upgraded. We duplicated those outdated integration tests with those legacy mocks that nobody could maintain. The team switched to Monorepo to improve developer experience.

We migrated to feature-sliced design code structure to align better with our business domain and also to start breaking down our code into smaller, testable units. It accelerated TypeScript migration. Today, building new features is much easier. It's a completely different code base, but I know it all started with testing. So back to the question, is testing easy? It depends on the right strategy, discipline, and skill. But the good news, everything else becomes easier when you've got your testing right.

Testing Approaches and Parallelism

Short description:

Kate at React Summit 2025 discussing testing approaches and parallelism, including insights on disabling parallelization for specific test suites and the use of workers in CI.

Here's my favorite. RS 202.5, Obsessed with Testing, at React Summit 2025. My name is Kate. I'm collaborating on social media. Happy testing. Thank you.

We have Slido running. And don't forget that you can add your questions as we discuss. And yeah, we're going to see who upvotes what.

But why don't we start out with testing approaches? So you went through several different snacks that represent testing approaches. Which one do you think is best? I think that's asterisk question. Yeah, that's a tricky one because the whole point of my talk is that it depends on the code base that you handle. And sometimes, like my best is, of course, the classic testing pyramid, but it's not always possible to start with it if you deal with a legacy code base or, you know, the situation is what it is.

So I would say find what works for you and then look around because there are some smart people that come up with some interesting ideas. Absolutely. But I think we can all agree what is the cutest testing strategy, which is obviously the Dorito. I don't know about the Dorito. Maybe. Depends on the flavor.

OK, so let's see. How about the parallelism? We got a couple of questions about that. So is there a way to disable parallelization for certain test suites that have long initial load times? Yes, I think what the person wants to achieve is perfectly possible. Playwright is a very configurable tool, but I would change that. Change that. So we forced ourselves in this situation where we had to deal with full parallel mode and it helped us a lot to actually follow best practices and help us maintain it as it grows. Awesome. Awesome. And on that same subject, so in the parallel workers, how many did you finally use? Or perhaps the wider question is, how do you determine how many to use? And were you running in CI? In continuous integration? Yeah. We currently use 12 workers in CI. We don't use it on local, for example.

Managing Workers and Flaky Tests

Short description:

Discussion on using workers in CI and locally, managing flaky end-to-end tests by following Playwright best practices, and distinguishing between at step and test.step for test optimization.

Local, I use four workers maximum. In our case, we just picked the largest machine that was available for us in CI and that's it. It was simple. The number of CPUs. Yeah. Work with what you got, right? Awesome.

And so how about those end-to-end tests that are – how do you ensure that they aren't flaky? Because you have some issue with the server, some random downtime, something else goes wrong. What do you do against flaky end-to-end tests? That's a great question. So if you follow Playwright best practices, then you reduce unnecessary flakiness that comes from the fact that you're using browser and there are some latencies, et cetera. Now if your server is down, there's nothing that can help you. And that's at the core of the end-to-end test as opposed to just the whole thing.

So we let them fail if the server fails and we ping our lovely backend team to fix that. Now there are these mixed approaches, as I mentioned, with this same integration tests when you mock some of these things. This is the other approach that you can use. And you can go creative. Yeah. Yeah. Okay. Again, you got to roll with the punches, right? You got to get creative for whatever the problem is at hand. Okay. We have a question about, a very specific question. What is the difference between at step and test.step? That's the same thing. It's just at step is a decorator that wraps the methods for you. Beautiful. So you don't need to modify all your code base or the existing test, you just add the decorator. Yeah. So that's the performance thing. Again, what does your team prefer? What's your style? Are you used to working with decorators? Are you not? Cool.

Optimizing User Registration Dependencies

Short description:

Discussion on managing user registration dependencies by using pre-configured test users to avoid repetitive registrations.

So, let's see. So many great new questions are coming in. I love to see this. Even though we're having a bit of a silent disco and so it's very quiet in real life here, we're all having an awesome virtual interaction, which is bringing me back to like five years ago. Anybody? 2020 vibes? Okay.

How do you approach, for example, dependencies on user registration without repeating registrations every time? Yeah. That's a great question. First of all, we have pre-configured test user like seed data that we have and they already contain some test users. So we test registration only once, but then we use those pre-configured users. Awesome.

As the questions are coming in, don't forget you can upvote the ones that you want to hear answered. But if your question isn't answered, or if you were perhaps too enraptured by the joys of thinking about testing strategies to ask it here online on Slido, those of you that are in person will have a chance to join Kate's Q&A corner later on. All righty.

Optimizing Test Functions and Stability

Short description:

Discussing the use of fixtures for repeated code in playwright testing and the importance of stability in test functions.

All righty. But in the meantime, back to our virtual disco, silent disco party. I wish we had like roller skates or something. No? Just me? I'm sure nobody would get hurt. That would be fine.

Okay. So, speaking of logins, I guess, and registration, so any thoughts on optimizing login generators or util functions that will be run for each test? So this person has had trouble with, or their team has had trouble with parallelization and timeouts when hitting various endpoints. The answer is quite long, so let's chat after the talk. In short, for repeated code, we use fixtures a lot. They mean different things in playwright than in other things.

And for stability, we need to chat, because it depends. It depends. It depends. The software engineer's most used sword. Absolutely. I think we have time for a couple of more questions, if you're up for it. I'm up for a talk, honestly. Let's rock and roll. There are going to be more talks on the alternate stage, so yes. But don't worry if you do miss any of the talks, because you're, again, having such a great time silently talking about testing up here, don't worry. They'll record it. You can catch them later.

Playwright Sharding in CI/CD Runs

Short description:

Discussing the utilization of playwright sharding in CI/CD runs and the considerations around its implementation.

They'll record it. You can catch them later. So we will make sure to catch that. Once you've had a chance to cool down as well. But let's see, would you be willing to do one more for our audience here? Can we get a virtual woo to encourage this? Absolutely. Amazing. Fabulous.

Let's see. Our most popular question at the end is, are you using playwright sharding in CI and CD runs? And if not, why not? We just don't need it. We use a large machine. As soon as we need it, we will use it. Sharding requires a bit of massaging of the reports, so you need to merge them back. And we don't want to do that. When we grow big enough, we will do that for sure.

So again, depending on the need, right? Depending on what your actual capacity is and what your actual needs are. But it's a great question. Awesome. Awesome. Well, I love that we have such a colorful discussion going on about what I'm now going to think of as a very hunger-inducing part of software development, testing strategy. So can we all please give a virtual and real huge, huge thank you to the amazing Kate and all of the testing shapes. Thank you very much. Thank you so much, Kate. Thank you.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Network Requests with Cypress
TestJS Summit 2021TestJS Summit 2021
33 min
Network Requests with Cypress
Top Content
Cecilia Martinez, a technical account manager at Cypress, discusses network requests in Cypress and demonstrates commands like cydot request and SCI.INTERCEPT. She also explains dynamic matching and aliasing, network stubbing, and the pros and cons of using real server responses versus stubbing. The talk covers logging request responses, testing front-end and backend API, handling list length and DOM traversal, lazy loading, and provides resources for beginners to learn Cypress.
Testing Pyramid Makes Little Sense, What We Can Use Instead
TestJS Summit 2021TestJS Summit 2021
38 min
Testing Pyramid Makes Little Sense, What We Can Use Instead
Top Content
Featured Video
Gleb Bahmutov
Roman Sandler
2 authors
The testing pyramid - the canonical shape of tests that defined what types of tests we need to write to make sure the app works - is ... obsolete. In this presentation, Roman Sandler and Gleb Bahmutov argue what the testing shape works better for today's web applications.
Full-Circle Testing With Cypress
TestJS Summit 2022TestJS Summit 2022
27 min
Full-Circle Testing With Cypress
Top Content
Cypress is a powerful tool for end-to-end testing and API testing. It provides instant feedback on test errors and allows tests to be run inside the browser. Cypress enables testing at both the application and network layers, making it easier to reach different edge cases. With features like AppActions and component testing, Cypress allows for comprehensive testing of individual components and the entire application. Join the workshops to learn more about full circle testing with Cypress.
Test Effective Development
TestJS Summit 2021TestJS Summit 2021
31 min
Test Effective Development
Top Content
This Talk introduces Test Effective Development, a new approach to testing that aims to make companies more cost-effective. The speaker shares their personal journey of improving code quality and reducing bugs through smarter testing strategies. They discuss the importance of finding a balance between testing confidence and efficiency and introduce the concepts of isolated and integrated testing. The speaker also suggests different testing strategies based on the size of the application and emphasizes the need to choose cost-effective testing approaches based on the specific project requirements.
Playwright Test Runner
TestJS Summit 2021TestJS Summit 2021
25 min
Playwright Test Runner
Top Content
The Playwright Test Runner is a cross-browser web testing framework that allows you to write tests using just a few lines of code. It supports features like parallel test execution, device emulation, and different reporters for customized output. Code-Gen is a new feature that generates code to interact with web pages. Playwright Tracing provides a powerful tool for debugging and analyzing test actions, with the ability to explore trace files using TraceViewer. Overall, Playwright Test offers installation, test authoring, debugging, and post-mortem debugging capabilities.
Everyone Can Easily Write Tests
TestJS Summit 2023TestJS Summit 2023
21 min
Everyone Can Easily Write Tests
Playwright is a reliable end-to-end testing tool for modern web apps that provides one API, full isolation, fast execution, and supports multiple languages. It offers features like auto-weighting, retrying assertions, seamless testing of iframes and shadow DOM, test isolation, parallelism, and scalability. Playwright provides tools like VS Code extension, UiMode, and Trace Viewer for writing, debugging, and running tests. Effective tests prioritize user-facing attributes, use playwright locators and assertions, and avoid testing third-party dependencies. Playwright simplifies testing by generating tests, providing code generation and UI mode, and allows for easy running and debugging of tests. It helps in fixing failed tests and analyzing DOM changes, fixing locator mismatches, and scaling tests. Playwright is open source, free, and continuously growing.

Workshops on related topic

Designing Effective Tests With React Testing Library
React Summit 2023React Summit 2023
151 min
Designing Effective Tests With React Testing Library
Top Content
Featured Workshop
Josh Justice
Josh Justice
React Testing Library is a great framework for React component tests because there are a lot of questions it answers for you, so you don’t need to worry about those questions. But that doesn’t mean testing is easy. There are still a lot of questions you have to figure out for yourself: How many component tests should you write vs end-to-end tests or lower-level unit tests? How can you test a certain line of code that is tricky to test? And what in the world are you supposed to do about that persistent act() warning?
In this three-hour workshop we’ll introduce React Testing Library along with a mental model for how to think about designing your component tests. This mental model will help you see how to test each bit of logic, whether or not to mock dependencies, and will help improve the design of your components. You’ll walk away with the tools, techniques, and principles you need to implement low-cost, high-value component tests.
Table of contents- The different kinds of React application tests, and where component tests fit in- A mental model for thinking about the inputs and outputs of the components you test- Options for selecting DOM elements to verify and interact with them- The value of mocks and why they shouldn’t be avoided- The challenges with asynchrony in RTL tests and how to handle them
Prerequisites- Familiarity with building applications with React- Basic experience writing automated tests with Jest or another unit testing framework- You do not need any experience with React Testing Library- Machine setup: Node LTS, Yarn
Detox 101: How to write stable end-to-end tests for your React Native application
React Summit 2022React Summit 2022
117 min
Detox 101: How to write stable end-to-end tests for your React Native application
Top Content
Workshop
Yevheniia Hlovatska
Yevheniia Hlovatska
Compared to unit testing, end-to-end testing aims to interact with your application just like a real user. And as we all know it can be pretty challenging. Especially when we talk about Mobile applications.
Tests rely on many conditions and are considered to be slow and flaky. On the other hand - end-to-end tests can give the greatest confidence that your app is working. And if done right - can become an amazing tool for boosting developer velocity.
Detox is a gray-box end-to-end testing framework for mobile apps. Developed by Wix to solve the problem of slowness and flakiness and used by React Native itself as its E2E testing tool.
Join me on this workshop to learn how to make your mobile end-to-end tests with Detox rock.
Prerequisites- iOS/Android: MacOS Catalina or newer- Android only: Linux- Install before the workshop
API Testing with Postman Workshop
TestJS Summit 2023TestJS Summit 2023
48 min
API Testing with Postman Workshop
Top Content
WorkshopFree
Pooja Mistry
Pooja Mistry
In the ever-evolving landscape of software development, ensuring the reliability and functionality of APIs has become paramount. "API Testing with Postman" is a comprehensive workshop designed to equip participants with the knowledge and skills needed to excel in API testing using Postman, a powerful tool widely adopted by professionals in the field. This workshop delves into the fundamentals of API testing, progresses to advanced testing techniques, and explores automation, performance testing, and multi-protocol support, providing attendees with a holistic understanding of API testing with Postman.
1. Welcome to Postman- Explaining the Postman User Interface (UI)2. Workspace and Collections Collaboration- Understanding Workspaces and their role in collaboration- Exploring the concept of Collections for organizing and executing API requests3. Introduction to API Testing- Covering the basics of API testing and its significance4. Variable Management- Managing environment, global, and collection variables- Utilizing scripting snippets for dynamic data5. Building Testing Workflows- Creating effective testing workflows for comprehensive testing- Utilizing the Collection Runner for test execution- Introduction to Postbot for automated testing6. Advanced Testing- Contract Testing for ensuring API contracts- Using Mock Servers for effective testing- Maximizing productivity with Collection/Workspace templates- Integration Testing and Regression Testing strategies7. Automation with Postman- Leveraging the Postman CLI for automation- Scheduled Runs for regular testing- Integrating Postman into CI/CD pipelines8. Performance Testing- Demonstrating performance testing capabilities (showing the desktop client)- Synchronizing tests with VS Code for streamlined development9. Exploring Advanced Features - Working with Multiple Protocols: GraphQL, gRPC, and more
Join us for this workshop to unlock the full potential of Postman for API testing, streamline your testing processes, and enhance the quality and reliability of your software. Whether you're a beginner or an experienced tester, this workshop will equip you with the skills needed to excel in API testing with Postman.
Monitoring 101 for React Developers
React Summit US 2023React Summit US 2023
107 min
Monitoring 101 for React Developers
Top Content
WorkshopFree
Lazar Nikolov
Sarah Guthals
2 authors
If finding errors in your frontend project is like searching for a needle in a code haystack, then Sentry error monitoring can be your metal detector. Learn the basics of error monitoring with Sentry. Whether you are running a React, Angular, Vue, or just “vanilla” JavaScript, see how Sentry can help you find the who, what, when and where behind errors in your frontend project. 
Workshop level: Intermediate
Testing Web Applications Using Cypress
TestJS Summit - January, 2021TestJS Summit - January, 2021
173 min
Testing Web Applications Using Cypress
Top Content
Workshop
Gleb Bahmutov
Gleb Bahmutov
This workshop will teach you the basics of writing useful end-to-end tests using Cypress Test Runner.
We will cover writing tests, covering every application feature, structuring tests, intercepting network requests, and setting up the backend data.
Anyone who knows JavaScript programming language and has NPM installed would be able to follow along.
Best Practices for Writing and Debugging Cypress Tests
TestJS Summit 2023TestJS Summit 2023
148 min
Best Practices for Writing and Debugging Cypress Tests
Top Content
Workshop
Filip Hric
Filip Hric
You probably know the story. You’ve created a couple of tests, and since you are using Cypress, you’ve done this pretty quickly. Seems like nothing is stopping you, but then – failed test. It wasn’t the app, wasn’t an error, the test was… flaky? Well yes. Test design is important no matter what tool you will use, Cypress included. The good news is that Cypress has a couple of tools behind its belt that can help you out. Join me on my workshop, where I’ll guide you away from the valley of anti-patterns into the fields of evergreen, stable tests. We’ll talk about common mistakes when writing your test as well as debug and unveil underlying problems. All with the goal of avoiding flakiness, and designing stable test.