Ручное тестирование

This section is a program for those starting from zero who want to become a manual tester: to understand why testing is needed, to be able to design checks, to find and report bugs, and to work on a team. There's no talk of automation here — only manual testing, where almost everyone begins.

Forty articles go in order: from "what testing even is" to tools and teamwork. Read them in sequence — each topic builds on the previous ones.

Getting started: what testing is

1. What testing is and why it's needed — why software breaks and how checks save money and reputation.
2. Who a tester is — what a QA does, how they fit into the team, and what's expected of them.
3. Testing myths and what you need to start — do you need to code, will AI replace testers, and an honest starter checklist.
4. Manual and automated testing — the difference and why manual isn't going anywhere.
5. The software lifecycle and where testing fits — how a product is born and where testing sits in it (SDLC and STLC).
6. Software development models — waterfall, the V-model, and iterations: how the model changes when and how testing happens.

Types and levels

7. Test levels — unit, integration, system, and acceptance in plain words.
8. Types of testing — functional and non-functional: what we check and how.
9. Non-functional types in practice — usability vs GUI, security, compatibility, performance, and alpha/beta testing.
10. Black, white, and grey box — three views of the system plus smoke, regression, and sanity.
11. Exploratory testing — sessions with charters, error guessing, and the 'simple positive to complex negative' order.
12. Localization testing — how to check translations, date and currency formats, and layout for another language.

Test-case design

13. How to write a test case — steps, expected result, and what makes a case good.
14. Test case quality — the specificity/generality balance, fault-finding power, and typical case-writing mistakes.
15. Test plan and test suites — how to organize checks and not drown.
16. Test result reporting and metrics — reporting with facts, the logic of conclusions and recommendations, basic metrics.
17. Effort estimation — answering "how long will it take," decomposition, buffers, and your own productivity.
18. Test design techniques — equivalence classes and boundary values: fewer cases, more bugs.
19. Decision tables and pairwise testing — how to check complex combinations of conditions.
20. Checklists and test data — when a checklist beats a case and where to get data for checks.
21. User scenarios and personas — chains of actions, personas from 'Cautious' to 'Reckless', and case suites.

Bugs

22. What a bug is: severity and priority — what counts as a defect and how to assess its importance.
23. How to write a bug report — steps to reproduce, expected and actual result.
24. Bug report quality — the "what you did, what you got, what you expected" formula, detail level, and typical mistakes.
25. Finding the root cause of a defect — from symptom to root cause: the hypothesis-and-check algorithm.
26. The bug lifecycle and trackers — a defect's path from find to close and how it looks in Jira.

Tools and practice

27. Test management: TestRail, Qase, Zephyr — where to store cases and run test runs.
28. Web basics — HTML, CSS, JavaScript, and the DOM: what the page you test is built from.
29. Client-server and HTTP — how the page talks to the server: request, response, methods, and status codes.
30. Browser DevTools for testers — Console, Network, and Elements: what to look at while testing.
31. API testing basics in Postman — how to check requests to the server by hand.
32. SQL for testers — simple queries to check data in the database.
33. Cross-browser and mobile testing — how to check on different browsers and phones.
34. Linux commands and the terminal — how to read server logs via the terminal: cat, tail, grep.

On a team and beyond

35. QA in Agile and Scrum — the tester's role in the sprint and its ceremonies.
36. Testing against requirements — how to check what's described in the task and work with analysts.
37. Requirement levels and properties — three levels of requirements and a checklist of properties: from completeness to unambiguity.
38. Requirements review — three forms of review, good questions, and the rules of working with someone else's document.
39. How automation works — the economics of autotests, the ladder of approaches from action recording to BDD, cases for automation.
40. Where to grow next — automation, analysis, and QA specializations.

The program also includes the SQL from scratch series as a separate phase — eight articles from tables and SELECT to transactions and indexes, no prerequisites.