Description
End-to-end tests fail two ways. They do not exist, so a broken checkout ships because every unit test passed in isolation. Or they exist and are flaky, failing randomly on timing and selectors until the team stops trusting them and clicks merge through a red build, which is worse than no tests at all. Most Playwright suites die of flakiness, and almost all of that flakiness is self-inflicted: arbitrary waits, brittle selectors tied to the DOM, tests that depend on each other and on yesterday data, and no isolation. Writing E2E tests that catch real bugs and stay reliable is a real skill, and it is mostly about waiting on the right thing, selecting the stable thing, and keeping each test independent.
This book teaches you to build a Playwright suite that catches real bugs and stays trustworthy, instead of a flaky pile the team learns to ignore. It starts from why end-to-end testing matters and where it fits (the few high-value flows worth testing through the whole stack, versus the things a unit test should cover) so you do not drown in slow tests. Then it goes deep on the two things that decide whether a suite is reliable: locating elements by what the user sees and by stable roles and test ids rather than brittle CSS paths, and Playwright auto-waiting so you stop sprinkling arbitrary sleeps that are the number one cause of flakiness. It builds the real craft: writing a test that mirrors a user journey, the page object pattern so a UI change updates one file instead of fifty, handling auth and test data so tests start from a known state and do not depend on each other, and mocking the network to test the frontend without a flaky backend. The reliability chapters are the heart of the book: hunting down flakiness at its source, isolating tests so they can run in any order and in parallel, and debugging a failure with traces, videos, and screenshots instead of guessing. It closes on running the suite in CI so it actually gates releases, keeping it fast enough that people wait for it, and knowing what not to test end to end. The examples are a real app, shown with a flaky test and then a solid one. For engineers who want E2E tests people trust enough to block a release on.
Who this was written for
This book is for: engineers who need to test a real web app end to end and want a Playwright suite that catches actual bugs and stays green for the right reasons, not a flaky pile everyone learns to ignore.
The full table of contents
- Chapter 1: The red build the team learned to ignore
- Chapter 2: Which flows are worth your slowest test?
- Chapter 3: Why one redesign turns forty tests red
- Chapter 4: The bet you lose every time you guess a wait
- Chapter 5: The test that passes even when checkout is broken
- Chapter 6: One relabeled button, forty-three broken tests
- Chapter 7: The test that fails on data it never owned
- Chapter 8: How do you make a healthy backend fail on command?
- Chapter 9: When red stops meaning anything
- Chapter 10: The two tests that pass alone and fail together
- Chapter 11: Stop pushing console.log to a CI you can’t see
- Chapter 12: The test that only ran on closed laptops
- Chapter 13: The build your team finally believes
