Why end-to-end testing
Every time you change your product, something might break that nobody meant to touch. An end-to-end test is the cheapest way to find out before your customers do.
What it is
Section titled “What it is”An end-to-end test uses your product the way a person does. It opens the real app, clicks the real buttons, types into the real fields, and checks that the screen shows what it should:
- Open the app and sign in.
- Add three items to the list.
- Tick one off.
- Check that the counter says “2 of 3 left”.
If any part of the chain is broken (the button, the code behind it, the server, the database, the screen that shows the result) the test fails. That’s the “end to end”: from what the user does to what the user sees, through everything in between.
How it differs from other tests
Section titled “How it differs from other tests”Most teams already have some tests. They’re useful, and they’re different:
| Kind of test | Checks | Catches | Misses |
|---|---|---|---|
| Unit test | One function or class, alone | Logic mistakes in that piece | Pieces that work alone but not together |
| Integration test | A few pieces together, often without a UI | Contracts between services, database queries | What the user actually sees and does |
| End-to-end test | The whole product, through its UI | Anything that stops a user from getting something done | Which line of code caused it (that’s what the other tests are for) |
| Manual testing | Whatever a person remembers to try | Things nobody thought to automate | Consistency: people skip steps, get tired, and can’t test every change |
Unit tests tell you a piece works. End-to-end tests tell you the product works. You want both: many fast unit tests underneath, and a focused set of end-to-end tests over the journeys that matter.
What end-to-end tests catch
Section titled “What end-to-end tests catch”Things that pass every unit test and still break for users:
- A button that’s there but hidden behind a banner, or disabled when it shouldn’t be.
- A form that saves, but the list doesn’t refresh.
- A menu item that a refactor quietly disconnected.
- A sign-in that works in one browser and not another.
- A layout that pushes “Pay now” off the screen on a phone.
- A desktop app that crashes when opened with last week’s settings.
- Two apps that should work together (export from one, open in the other) that no longer do.
These are the bugs customers report, and the ones that cost the most: support time, lost sales, emergency releases, and trust.
Why teams don’t have them (and why that’s changing)
Section titled “Why teams don’t have them (and why that’s changing)”End-to-end tests have a bad reputation, mostly earned:
- They’re slow to write. Usually code, with a framework to learn, page objects to maintain and fragile CSS selectors.
- They’re flaky. They fail randomly because the app was a little slow, so people stop trusting them.
- They only cover the web. Desktop apps, and apps mixing native windows with web content, are often left untested.
- They’re hard to read. Only the engineer who wrote one knows what it checks.
Sisyphus is built to remove each of these. Tests are short and readable, every step waits for the app by itself, one format covers web and desktop, and your AI coding agent can write and fix tests for you. Why Sisyphus explains how.
What it’s worth
Section titled “What it’s worth”A good end-to-end suite changes how a team ships:
- Release without fear. If the critical journeys pass, you can ship on a Friday.
- Change code faster. Refactors stop being risky when something checks the product still works afterwards.
- Find bugs in minutes, not weeks. A failure on a pull request points at the change that caused it, while it’s still fresh.
- Spend people on what people are good at. Manual testers explore new features instead of re-clicking the same 200 steps every release.
- A living spec. The tests describe, in plain words, what the product does. New people read them to learn it.
A test written once runs on every change, for years. That’s the trade Sisyphus is named after: the boulder gets pushed up the hill every single time, and you never have to push it yourself.
Where to start
Section titled “Where to start”You don’t need hundreds of tests. Start with the five to ten journeys that would hurt most if they broke: signing up, signing in, the main thing people pay you for, checkout, saving their work. Write one test for each. That alone catches most of the bugs that matter.
Next: Why Sisyphus, or jump straight to your first test.
