Start here

Before any tool. These four decide what you write and where it goes; get them wrong and the best tooling in the world just runs the wrong tests faster.

• The Testing Pyramid— why the cheap tests have to outnumber the expensive ones
• Unit Testing— what a unit actually is, and what it is not
• Test Doubles— mock, stub, fake, spy, dummy — the words used precisely
• Arrange-Act-Assert— the shape every test in every language has

The difference between a suite people trust and one they skip is almost never the framework. It is these.

• Writing Testable Code— most untestable code is a design problem wearing a testing costume
• Dependency Injection for Testability— the one technique that makes the rest possible
• Test Data Management— where the data comes from decides whether tests can run in parallel
• Flaky Tests— the failure mode that quietly kills suites

Browser automation, and the patterns that stop a hundred end-to-end tests from becoming a hundred maintenance problems.

• End-to-End Testing— what belongs up here, and what does not
• Playwright— the default choice, and why
• The Page Object Model— the pattern everyone reaches for, and its failure mode
• Screenshots— a failure you cannot see is a failure you cannot fix

A test suite that only runs on a laptop is a document. These make it a gate.

• Testing in GitHub Actions— a full matrix pipeline, end to end
• Playwright Sharding— cutting a forty-minute suite to four
• Code Coverage— what the number means and what it does not
• Running Tests in Parallel— the shared-resource problems parallelism uncovers

Correct and fast are not the same as good. These are the tests that catch what functional tests structurally cannot.

• Performance Testing— load, stress and the difference between them
• Security Testing— where automation helps and where it cannot
• Authorization Testing— the bug class end-to-end suites miss most often
• Database Testing— testing the layer everything else depends on